comparing 4f93fafb1d4b77601829cbfade20a04728e9364a and main on bretton.dev/coves

+109

internal/atproto/lexicon/social/coves/community/comment/create.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "social.coves.community.comment.create",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Create a comment on a post or another comment. Comments support nested threading, rich text, embeds, and self-labeling.",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "required": ["reply", "content"],

     

       13
       13
       +
                 "properties": {

     

       14
       14
       +
                   "reply": {

     

       15
       15
       +
                     "type": "object",

     

       16
       16
       +
                     "description": "References for maintaining thread structure. Root always points to the original post, parent points to the immediate parent (post or comment).",

     

       17
       17
       +
                     "required": ["root", "parent"],

     

       18
       18
       +
                     "properties": {

     

       19
       19
       +
                       "root": {

     

       20
       20
       +
                         "type": "ref",

     

       21
       21
       +
                         "ref": "com.atproto.repo.strongRef",

     

       22
       22
       +
                         "description": "Strong reference to the original post that started the thread"

     

       23
       23
       +
                       },

     

       24
       24
       +
                       "parent": {

     

       25
       25
       +
                         "type": "ref",

     

       26
       26
       +
                         "ref": "com.atproto.repo.strongRef",

     

       27
       27
       +
                         "description": "Strong reference to the immediate parent (post or comment) being replied to"

     

       28
       28
       +
                       }

     

       29
       29
       +
                     }

     

       30
       30
       +
                   },

     

       31
       31
       +
                   "content": {

     

       32
       32
       +
                     "type": "string",

     

       33
       33
       +
                     "maxGraphemes": 10000,

     

       34
       34
       +
                     "maxLength": 100000,

     

       35
       35
       +
                     "description": "Comment text content"

     

       36
       36
       +
                   },

     

       37
       37
       +
                   "facets": {

     

       38
       38
       +
                     "type": "array",

     

       39
       39
       +
                     "description": "Annotations for rich text (mentions, links, etc.)",

     

       40
       40
       +
                     "items": {

     

       41
       41
       +
                       "type": "ref",

     

       42
       42
       +
                       "ref": "social.coves.richtext.facet"

     

       43
       43
       +
                     }

     

       44
       44
       +
                   },

     

       45
       45
       +
                   "embed": {

     

       46
       46
       +
                     "type": "union",

     

       47
       47
       +
                     "description": "Embedded media or quoted posts",

     

       48
       48
       +
                     "refs": [

     

       49
       49
       +
                       "social.coves.embed.images",

     

       50
       50
       +
                       "social.coves.embed.post"

     

       51
       51
       +
                     ]

     

       52
       52
       +
                   },

     

       53
       53
       +
                   "langs": {

     

       54
       54
       +
                     "type": "array",

     

       55
       55
       +
                     "description": "Languages used in the comment content (ISO 639-1)",

     

       56
       56
       +
                     "maxLength": 3,

     

       57
       57
       +
                     "items": {

     

       58
       58
       +
                       "type": "string",

     

       59
       59
       +
                       "format": "language"

     

       60
       60
       +
                     }

     

       61
       61
       +
                   },

     

       62
       62
       +
                   "labels": {

     

       63
       63
       +
                     "type": "ref",

     

       64
       64
       +
                     "ref": "com.atproto.label.defs#selfLabels",

     

       65
       65
       +
                     "description": "Self-applied content labels"

     

       66
       66
       +
                   }

     

       67
       67
       +
                 }

     

       68
       68
       +
               }

     

       69
       69
       +
             },

     

       70
       70
       +
             "output": {

     

       71
       71
       +
               "encoding": "application/json",

     

       72
       72
       +
               "schema": {

     

       73
       73
       +
                 "type": "object",

     

       74
       74
       +
                 "required": ["uri", "cid"],

     

       75
       75
       +
                 "properties": {

     

       76
       76
       +
                   "uri": {

     

       77
       77
       +
                     "type": "string",

     

       78
       78
       +
                     "format": "at-uri",

     

       79
       79
       +
                     "description": "AT-URI of the created comment"

     

       80
       80
       +
                   },

     

       81
       81
       +
                   "cid": {

     

       82
       82
       +
                     "type": "string",

     

       83
       83
       +
                     "format": "cid",

     

       84
       84
       +
                     "description": "CID of the created comment record"

     

       85
       85
       +
                   }

     

       86
       86
       +
                 }

     

       87
       87
       +
               }

     

       88
       88
       +
             },

     

       89
       89
       +
             "errors": [

     

       90
       90
       +
               {

     

       91
       91
       +
                 "name": "InvalidReply",

     

       92
       92
       +
                 "description": "The reply reference is invalid, malformed, or refers to non-existent content"

     

       93
       93
       +
               },

     

       94
       94
       +
               {

     

       95
       95
       +
                 "name": "ContentTooLong",

     

       96
       96
       +
                 "description": "Comment content exceeds maximum length constraints"

     

       97
       97
       +
               },

     

       98
       98
       +
               {

     

       99
       99
       +
                 "name": "ContentEmpty",

     

       100
       100
       +
                 "description": "Comment content is empty or contains only whitespace"

     

       101
       101
       +
               },

     

       102
       102
       +
               {

     

       103
       103
       +
                 "name": "NotAuthorized",

     

       104
       104
       +
                 "description": "User is not authorized to create comments on this content"

     

       105
       105
       +
               }

     

       106
       106
       +
             ]

     

       107
       107
       +
           }

     

       108
       108
       +
         }

     

       109
       109
       +
       }

+41

internal/atproto/lexicon/social/coves/community/comment/delete.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "social.coves.community.comment.delete",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Delete a comment. Only the comment author can delete their own comments.",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "required": ["uri"],

     

       13
       13
       +
                 "properties": {

     

       14
       14
       +
                   "uri": {

     

       15
       15
       +
                     "type": "string",

     

       16
       16
       +
                     "format": "at-uri",

     

       17
       17
       +
                     "description": "AT-URI of the comment to delete"

     

       18
       18
       +
                   }

     

       19
       19
       +
                 }

     

       20
       20
       +
               }

     

       21
       21
       +
             },

     

       22
       22
       +
             "output": {

     

       23
       23
       +
               "encoding": "application/json",

     

       24
       24
       +
               "schema": {

     

       25
       25
       +
                 "type": "object",

     

       26
       26
       +
                 "properties": {}

     

       27
       27
       +
               }

     

       28
       28
       +
             },

     

       29
       29
       +
             "errors": [

     

       30
       30
       +
               {

     

       31
       31
       +
                 "name": "CommentNotFound",

     

       32
       32
       +
                 "description": "Comment with the specified URI does not exist"

     

       33
       33
       +
               },

     

       34
       34
       +
               {

     

       35
       35
       +
                 "name": "NotAuthorized",

     

       36
       36
       +
                 "description": "User is not authorized to delete this comment (not the author)"

     

       37
       37
       +
               }

     

       38
       38
       +
             ]

     

       39
       39
       +
           }

     

       40
       40
       +
         }

     

       41
       41
       +
       }

+97

internal/atproto/lexicon/social/coves/community/comment/update.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "social.coves.community.comment.update",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Update an existing comment's content, facets, embed, languages, or labels. Threading references (reply.root and reply.parent) are immutable and cannot be changed.",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "required": ["uri", "content"],

     

       13
       13
       +
                 "properties": {

     

       14
       14
       +
                   "uri": {

     

       15
       15
       +
                     "type": "string",

     

       16
       16
       +
                     "format": "at-uri",

     

       17
       17
       +
                     "description": "AT-URI of the comment to update"

     

       18
       18
       +
                   },

     

       19
       19
       +
                   "content": {

     

       20
       20
       +
                     "type": "string",

     

       21
       21
       +
                     "maxGraphemes": 10000,

     

       22
       22
       +
                     "maxLength": 100000,

     

       23
       23
       +
                     "description": "Updated comment text content"

     

       24
       24
       +
                   },

     

       25
       25
       +
                   "facets": {

     

       26
       26
       +
                     "type": "array",

     

       27
       27
       +
                     "description": "Updated annotations for rich text (mentions, links, etc.)",

     

       28
       28
       +
                     "items": {

     

       29
       29
       +
                       "type": "ref",

     

       30
       30
       +
                       "ref": "social.coves.richtext.facet"

     

       31
       31
       +
                     }

     

       32
       32
       +
                   },

     

       33
       33
       +
                   "embed": {

     

       34
       34
       +
                     "type": "union",

     

       35
       35
       +
                     "description": "Updated embedded media or quoted posts",

     

       36
       36
       +
                     "refs": [

     

       37
       37
       +
                       "social.coves.embed.images",

     

       38
       38
       +
                       "social.coves.embed.post"

     

       39
       39
       +
                     ]

     

       40
       40
       +
                   },

     

       41
       41
       +
                   "langs": {

     

       42
       42
       +
                     "type": "array",

     

       43
       43
       +
                     "description": "Updated languages used in the comment content (ISO 639-1)",

     

       44
       44
       +
                     "maxLength": 3,

     

       45
       45
       +
                     "items": {

     

       46
       46
       +
                       "type": "string",

     

       47
       47
       +
                       "format": "language"

     

       48
       48
       +
                     }

     

       49
       49
       +
                   },

     

       50
       50
       +
                   "labels": {

     

       51
       51
       +
                     "type": "ref",

     

       52
       52
       +
                     "ref": "com.atproto.label.defs#selfLabels",

     

       53
       53
       +
                     "description": "Updated self-applied content labels"

     

       54
       54
       +
                   }

     

       55
       55
       +
                 }

     

       56
       56
       +
               }

     

       57
       57
       +
             },

     

       58
       58
       +
             "output": {

     

       59
       59
       +
               "encoding": "application/json",

     

       60
       60
       +
               "schema": {

     

       61
       61
       +
                 "type": "object",

     

       62
       62
       +
                 "required": ["uri", "cid"],

     

       63
       63
       +
                 "properties": {

     

       64
       64
       +
                   "uri": {

     

       65
       65
       +
                     "type": "string",

     

       66
       66
       +
                     "format": "at-uri",

     

       67
       67
       +
                     "description": "AT-URI of the updated comment (unchanged from input)"

     

       68
       68
       +
                   },

     

       69
       69
       +
                   "cid": {

     

       70
       70
       +
                     "type": "string",

     

       71
       71
       +
                     "format": "cid",

     

       72
       72
       +
                     "description": "New CID of the updated comment record"

     

       73
       73
       +
                   }

     

       74
       74
       +
                 }

     

       75
       75
       +
               }

     

       76
       76
       +
             },

     

       77
       77
       +
             "errors": [

     

       78
       78
       +
               {

     

       79
       79
       +
                 "name": "CommentNotFound",

     

       80
       80
       +
                 "description": "Comment with the specified URI does not exist"

     

       81
       81
       +
               },

     

       82
       82
       +
               {

     

       83
       83
       +
                 "name": "ContentTooLong",

     

       84
       84
       +
                 "description": "Updated comment content exceeds maximum length constraints"

     

       85
       85
       +
               },

     

       86
       86
       +
               {

     

       87
       87
       +
                 "name": "ContentEmpty",

     

       88
       88
       +
                 "description": "Updated comment content is empty or contains only whitespace"

     

       89
       89
       +
               },

     

       90
       90
       +
               {

     

       91
       91
       +
                 "name": "NotAuthorized",

     

       92
       92
       +
                 "description": "User is not authorized to update this comment (not the author)"

     

       93
       93
       +
               }

     

       94
       94
       +
             ]

     

       95
       95
       +
           }

     

       96
       96
       +
         }

     

       97
       97
       +
       }

+38

internal/core/comments/types.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       // CreateCommentRequest contains parameters for creating a comment

     

       4
       4
       +
       type CreateCommentRequest struct {

     

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

     

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

     

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

     

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

     

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

     

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

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       // CreateCommentResponse contains the result of creating a comment

     

       14
       14
       +
       type CreateCommentResponse struct {

     

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

     

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

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       // UpdateCommentRequest contains parameters for updating a comment

     

       20
       20
       +
       type UpdateCommentRequest struct {

     

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

     

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

     

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

     

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

     

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

     

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

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       // UpdateCommentResponse contains the result of updating a comment

     

       30
       30
       +
       type UpdateCommentResponse struct {

     

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

     

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

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       // DeleteCommentRequest contains parameters for deleting a comment

     

       36
       36
       +
       type DeleteCommentRequest struct {

     

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

     

       38
       38
       +
       }

+130

internal/api/handlers/comments/create_comment.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/api/middleware"

     

       5
       5
       +
       	"Coves/internal/core/comments"

     

       6
       6
       +
       	"encoding/json"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"net/http"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // CreateCommentHandler handles comment creation requests

     

       12
       12
       +
       type CreateCommentHandler struct {

     

       13
       13
       +
       	service comments.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // NewCreateCommentHandler creates a new handler for creating comments

     

       17
       17
       +
       func NewCreateCommentHandler(service comments.Service) *CreateCommentHandler {

     

       18
       18
       +
       	return &CreateCommentHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       // CreateCommentInput matches the lexicon input schema for social.coves.community.comment.create

     

       24
       24
       +
       type CreateCommentInput struct {

     

       25
       25
       +
       	Reply struct {

     

       26
       26
       +
       		Root struct {

     

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

     

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

     

       29
       29
       +
       		} `json:"root"`

     

       30
       30
       +
       		Parent struct {

     

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

     

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

     

       33
       33
       +
       		} `json:"parent"`

     

       34
       34
       +
       	} `json:"reply"`

     

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

     

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

     

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

     

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

     

       39
       39
       +
       	Labels  interface{}   `json:"labels,omitempty"`

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       // CreateCommentOutput matches the lexicon output schema

     

       43
       43
       +
       type CreateCommentOutput struct {

     

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

     

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

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       // HandleCreate handles comment creation requests

     

       49
       49
       +
       // POST /xrpc/social.coves.community.comment.create

     

       50
       50
       +
       //

     

       51
       51
       +
       // Request body: { "reply": { "root": {...}, "parent": {...} }, "content": "..." }

     

       52
       52
       +
       // Response: { "uri": "at://...", "cid": "..." }

     

       53
       53
       +
       func (h *CreateCommentHandler) HandleCreate(w http.ResponseWriter, r *http.Request) {

     

       54
       54
       +
       	// 1. Check method is POST

     

       55
       55
       +
       	if r.Method != http.MethodPost {

     

       56
       56
       +
       		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)

     

       57
       57
       +
       		return

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

       60
       60
       +
       	// 2. Limit request body size to prevent DoS attacks (100KB should be plenty for comments)

     

       61
       61
       +
       	r.Body = http.MaxBytesReader(w, r.Body, 100*1024)

     

       62
       62
       +
       

     

       63
       63
       +
       	// 3. Parse JSON body into CreateCommentInput

     

       64
       64
       +
       	var input CreateCommentInput

     

       65
       65
       +
       	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {

     

       66
       66
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "Invalid request body")

     

       67
       67
       +
       		return

     

       68
       68
       +
       	}

     

       69
       69
       +
       

     

       70
       70
       +
       	// 4. Get OAuth session from context (injected by auth middleware)

     

       71
       71
       +
       	session := middleware.GetOAuthSession(r)

     

       72
       72
       +
       	if session == nil {

     

       73
       73
       +
       		writeError(w, http.StatusUnauthorized, "AuthRequired", "Authentication required")

     

       74
       74
       +
       		return

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	// 5. Convert labels interface{} to *comments.SelfLabels if provided

     

       78
       78
       +
       	var labels *comments.SelfLabels

     

       79
       79
       +
       	if input.Labels != nil {

     

       80
       80
       +
       		labelsJSON, err := json.Marshal(input.Labels)

     

       81
       81
       +
       		if err != nil {

     

       82
       82
       +
       			writeError(w, http.StatusBadRequest, "InvalidLabels", "Invalid labels format")

     

       83
       83
       +
       			return

     

       84
       84
       +
       		}

     

       85
       85
       +
       		var selfLabels comments.SelfLabels

     

       86
       86
       +
       		if err := json.Unmarshal(labelsJSON, &selfLabels); err != nil {

     

       87
       87
       +
       			writeError(w, http.StatusBadRequest, "InvalidLabels", "Invalid labels structure")

     

       88
       88
       +
       			return

     

       89
       89
       +
       		}

     

       90
       90
       +
       		labels = &selfLabels

     

       91
       91
       +
       	}

     

       92
       92
       +
       

     

       93
       93
       +
       	// 6. Convert input to CreateCommentRequest

     

       94
       94
       +
       	req := comments.CreateCommentRequest{

     

       95
       95
       +
       		Reply: comments.ReplyRef{

     

       96
       96
       +
       			Root: comments.StrongRef{

     

       97
       97
       +
       				URI: input.Reply.Root.URI,

     

       98
       98
       +
       				CID: input.Reply.Root.CID,

     

       99
       99
       +
       			},

     

       100
       100
       +
       			Parent: comments.StrongRef{

     

       101
       101
       +
       				URI: input.Reply.Parent.URI,

     

       102
       102
       +
       				CID: input.Reply.Parent.CID,

     

       103
       103
       +
       			},

     

       104
       104
       +
       		},

     

       105
       105
       +
       		Content: input.Content,

     

       106
       106
       +
       		Facets:  input.Facets,

     

       107
       107
       +
       		Embed:   input.Embed,

     

       108
       108
       +
       		Langs:   input.Langs,

     

       109
       109
       +
       		Labels:  labels,

     

       110
       110
       +
       	}

     

       111
       111
       +
       

     

       112
       112
       +
       	// 7. Call service to create comment

     

       113
       113
       +
       	response, err := h.service.CreateComment(r.Context(), session, req)

     

       114
       114
       +
       	if err != nil {

     

       115
       115
       +
       		handleServiceError(w, err)

     

       116
       116
       +
       		return

     

       117
       117
       +
       	}

     

       118
       118
       +
       

     

       119
       119
       +
       	// 8. Return JSON response with URI and CID

     

       120
       120
       +
       	output := CreateCommentOutput{

     

       121
       121
       +
       		URI: response.URI,

     

       122
       122
       +
       		CID: response.CID,

     

       123
       123
       +
       	}

     

       124
       124
       +
       

     

       125
       125
       +
       	w.Header().Set("Content-Type", "application/json")

     

       126
       126
       +
       	w.WriteHeader(http.StatusOK)

     

       127
       127
       +
       	if err := json.NewEncoder(w).Encode(output); err != nil {

     

       128
       128
       +
       		log.Printf("Failed to encode response: %v", err)

     

       129
       129
       +
       	}

     

       130
       130
       +
       }

+80

internal/api/handlers/comments/delete_comment.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/api/middleware"

     

       5
       5
       +
       	"Coves/internal/core/comments"

     

       6
       6
       +
       	"encoding/json"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"net/http"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // DeleteCommentHandler handles comment deletion requests

     

       12
       12
       +
       type DeleteCommentHandler struct {

     

       13
       13
       +
       	service comments.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // NewDeleteCommentHandler creates a new handler for deleting comments

     

       17
       17
       +
       func NewDeleteCommentHandler(service comments.Service) *DeleteCommentHandler {

     

       18
       18
       +
       	return &DeleteCommentHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       // DeleteCommentInput matches the lexicon input schema for social.coves.community.comment.delete

     

       24
       24
       +
       type DeleteCommentInput struct {

     

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

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       // DeleteCommentOutput is empty per lexicon specification

     

       29
       29
       +
       type DeleteCommentOutput struct{}

     

       30
       30
       +
       

     

       31
       31
       +
       // HandleDelete handles comment deletion requests

     

       32
       32
       +
       // POST /xrpc/social.coves.community.comment.delete

     

       33
       33
       +
       //

     

       34
       34
       +
       // Request body: { "uri": "at://..." }

     

       35
       35
       +
       // Response: {}

     

       36
       36
       +
       func (h *DeleteCommentHandler) HandleDelete(w http.ResponseWriter, r *http.Request) {

     

       37
       37
       +
       	// 1. Check method is POST

     

       38
       38
       +
       	if r.Method != http.MethodPost {

     

       39
       39
       +
       		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)

     

       40
       40
       +
       		return

     

       41
       41
       +
       	}

     

       42
       42
       +
       

     

       43
       43
       +
       	// 2. Limit request body size to prevent DoS attacks (100KB should be plenty for comments)

     

       44
       44
       +
       	r.Body = http.MaxBytesReader(w, r.Body, 100*1024)

     

       45
       45
       +
       

     

       46
       46
       +
       	// 3. Parse JSON body into DeleteCommentInput

     

       47
       47
       +
       	var input DeleteCommentInput

     

       48
       48
       +
       	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {

     

       49
       49
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "Invalid request body")

     

       50
       50
       +
       		return

     

       51
       51
       +
       	}

     

       52
       52
       +
       

     

       53
       53
       +
       	// 4. Get OAuth session from context (injected by auth middleware)

     

       54
       54
       +
       	session := middleware.GetOAuthSession(r)

     

       55
       55
       +
       	if session == nil {

     

       56
       56
       +
       		writeError(w, http.StatusUnauthorized, "AuthRequired", "Authentication required")

     

       57
       57
       +
       		return

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

       60
       60
       +
       	// 5. Convert input to DeleteCommentRequest

     

       61
       61
       +
       	req := comments.DeleteCommentRequest{

     

       62
       62
       +
       		URI: input.URI,

     

       63
       63
       +
       	}

     

       64
       64
       +
       

     

       65
       65
       +
       	// 6. Call service to delete comment

     

       66
       66
       +
       	err := h.service.DeleteComment(r.Context(), session, req)

     

       67
       67
       +
       	if err != nil {

     

       68
       68
       +
       		handleServiceError(w, err)

     

       69
       69
       +
       		return

     

       70
       70
       +
       	}

     

       71
       71
       +
       

     

       72
       72
       +
       	// 7. Return empty JSON object per lexicon specification

     

       73
       73
       +
       	output := DeleteCommentOutput{}

     

       74
       74
       +
       

     

       75
       75
       +
       	w.Header().Set("Content-Type", "application/json")

     

       76
       76
       +
       	w.WriteHeader(http.StatusOK)

     

       77
       77
       +
       	if err := json.NewEncoder(w).Encode(output); err != nil {

     

       78
       78
       +
       		log.Printf("Failed to encode response: %v", err)

     

       79
       79
       +
       	}

     

       80
       80
       +
       }

+34 -2

internal/api/handlers/comments/errors.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"Coves/internal/core/comments"

     

       5
       5
        
       	"encoding/json"

     

       6
       6
       +
       	"errors"

     

       6
       7
        
       	"log"

     

       7
       8
        
       	"net/http"

     

       8
       9
        
       )

     
···

       30
       31
        
       func handleServiceError(w http.ResponseWriter, err error) {

     

       31
       32
        
       	switch {

     

       32
       33
        
       	case comments.IsNotFound(err):

     

       33
       33
       -
       		writeError(w, http.StatusNotFound, "NotFound", err.Error())

     

       34
       34
       +
       		// Map specific not found errors to appropriate messages

     

       35
       35
       +
       		switch {

     

       36
       36
       +
       		case errors.Is(err, comments.ErrCommentNotFound):

     

       37
       37
       +
       			writeError(w, http.StatusNotFound, "CommentNotFound", "Comment not found")

     

       38
       38
       +
       		case errors.Is(err, comments.ErrParentNotFound):

     

       39
       39
       +
       			writeError(w, http.StatusNotFound, "ParentNotFound", "Parent post or comment not found")

     

       40
       40
       +
       		case errors.Is(err, comments.ErrRootNotFound):

     

       41
       41
       +
       			writeError(w, http.StatusNotFound, "RootNotFound", "Root post not found")

     

       42
       42
       +
       		default:

     

       43
       43
       +
       			writeError(w, http.StatusNotFound, "NotFound", err.Error())

     

       44
       44
       +
       		}

     

       34
       45
        
       

     

       35
       46
        
       	case comments.IsValidationError(err):

     

       36
       36
       -
       		writeError(w, http.StatusBadRequest, "InvalidRequest", err.Error())

     

       47
       47
       +
       		// Map specific validation errors to appropriate messages

     

       48
       48
       +
       		switch {

     

       49
       49
       +
       		case errors.Is(err, comments.ErrInvalidReply):

     

       50
       50
       +
       			writeError(w, http.StatusBadRequest, "InvalidReply", "The reply reference is invalid or malformed")

     

       51
       51
       +
       		case errors.Is(err, comments.ErrContentTooLong):

     

       52
       52
       +
       			writeError(w, http.StatusBadRequest, "ContentTooLong", "Comment content exceeds 10000 graphemes")

     

       53
       53
       +
       		case errors.Is(err, comments.ErrContentEmpty):

     

       54
       54
       +
       			writeError(w, http.StatusBadRequest, "ContentEmpty", "Comment content is required")

     

       55
       55
       +
       		default:

     

       56
       56
       +
       			writeError(w, http.StatusBadRequest, "InvalidRequest", err.Error())

     

       57
       57
       +
       		}

     

       58
       58
       +
       

     

       59
       59
       +
       	case errors.Is(err, comments.ErrNotAuthorized):

     

       60
       60
       +
       		writeError(w, http.StatusForbidden, "NotAuthorized", "User is not authorized to perform this action")

     

       61
       61
       +
       

     

       62
       62
       +
       	case errors.Is(err, comments.ErrBanned):

     

       63
       63
       +
       		writeError(w, http.StatusForbidden, "Banned", "User is banned from this community")

     

       64
       64
       +
       

     

       65
       65
       +
       	// NOTE: IsConflict case removed - the PDS handles duplicate detection via CreateRecord,

     

       66
       66
       +
       	// so ErrCommentAlreadyExists is never returned from the service layer. If the PDS rejects

     

       67
       67
       +
       	// a duplicate record, it returns an auth/validation error which is handled by other cases.

     

       68
       68
       +
       	// Keeping this code would be dead code that never executes.

     

       37
       69
        
       

     

       38
       70
        
       	default:

     

       39
       71
        
       		// Don't leak internal error details to clients

+112

internal/api/handlers/comments/update_comment.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/api/middleware"

     

       5
       5
       +
       	"Coves/internal/core/comments"

     

       6
       6
       +
       	"encoding/json"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"net/http"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // UpdateCommentHandler handles comment update requests

     

       12
       12
       +
       type UpdateCommentHandler struct {

     

       13
       13
       +
       	service comments.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // NewUpdateCommentHandler creates a new handler for updating comments

     

       17
       17
       +
       func NewUpdateCommentHandler(service comments.Service) *UpdateCommentHandler {

     

       18
       18
       +
       	return &UpdateCommentHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       // UpdateCommentInput matches the lexicon input schema for social.coves.community.comment.update

     

       24
       24
       +
       type UpdateCommentInput struct {

     

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

     

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

     

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

     

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

     

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

     

       30
       30
       +
       	Labels  interface{}   `json:"labels,omitempty"`

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       // UpdateCommentOutput matches the lexicon output schema

     

       34
       34
       +
       type UpdateCommentOutput struct {

     

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

     

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

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       // HandleUpdate handles comment update requests

     

       40
       40
       +
       // POST /xrpc/social.coves.community.comment.update

     

       41
       41
       +
       //

     

       42
       42
       +
       // Request body: { "uri": "at://...", "content": "..." }

     

       43
       43
       +
       // Response: { "uri": "at://...", "cid": "..." }

     

       44
       44
       +
       func (h *UpdateCommentHandler) HandleUpdate(w http.ResponseWriter, r *http.Request) {

     

       45
       45
       +
       	// 1. Check method is POST

     

       46
       46
       +
       	if r.Method != http.MethodPost {

     

       47
       47
       +
       		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)

     

       48
       48
       +
       		return

     

       49
       49
       +
       	}

     

       50
       50
       +
       

     

       51
       51
       +
       	// 2. Limit request body size to prevent DoS attacks (100KB should be plenty for comments)

     

       52
       52
       +
       	r.Body = http.MaxBytesReader(w, r.Body, 100*1024)

     

       53
       53
       +
       

     

       54
       54
       +
       	// 3. Parse JSON body into UpdateCommentInput

     

       55
       55
       +
       	var input UpdateCommentInput

     

       56
       56
       +
       	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {

     

       57
       57
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "Invalid request body")

     

       58
       58
       +
       		return

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       	// 4. Get OAuth session from context (injected by auth middleware)

     

       62
       62
       +
       	session := middleware.GetOAuthSession(r)

     

       63
       63
       +
       	if session == nil {

     

       64
       64
       +
       		writeError(w, http.StatusUnauthorized, "AuthRequired", "Authentication required")

     

       65
       65
       +
       		return

     

       66
       66
       +
       	}

     

       67
       67
       +
       

     

       68
       68
       +
       	// 5. Convert labels interface{} to *comments.SelfLabels if provided

     

       69
       69
       +
       	var labels *comments.SelfLabels

     

       70
       70
       +
       	if input.Labels != nil {

     

       71
       71
       +
       		labelsJSON, err := json.Marshal(input.Labels)

     

       72
       72
       +
       		if err != nil {

     

       73
       73
       +
       			writeError(w, http.StatusBadRequest, "InvalidLabels", "Invalid labels format")

     

       74
       74
       +
       			return

     

       75
       75
       +
       		}

     

       76
       76
       +
       		var selfLabels comments.SelfLabels

     

       77
       77
       +
       		if err := json.Unmarshal(labelsJSON, &selfLabels); err != nil {

     

       78
       78
       +
       			writeError(w, http.StatusBadRequest, "InvalidLabels", "Invalid labels structure")

     

       79
       79
       +
       			return

     

       80
       80
       +
       		}

     

       81
       81
       +
       		labels = &selfLabels

     

       82
       82
       +
       	}

     

       83
       83
       +
       

     

       84
       84
       +
       	// 6. Convert input to UpdateCommentRequest

     

       85
       85
       +
       	req := comments.UpdateCommentRequest{

     

       86
       86
       +
       		URI:     input.URI,

     

       87
       87
       +
       		Content: input.Content,

     

       88
       88
       +
       		Facets:  input.Facets,

     

       89
       89
       +
       		Embed:   input.Embed,

     

       90
       90
       +
       		Langs:   input.Langs,

     

       91
       91
       +
       		Labels:  labels,

     

       92
       92
       +
       	}

     

       93
       93
       +
       

     

       94
       94
       +
       	// 7. Call service to update comment

     

       95
       95
       +
       	response, err := h.service.UpdateComment(r.Context(), session, req)

     

       96
       96
       +
       	if err != nil {

     

       97
       97
       +
       		handleServiceError(w, err)

     

       98
       98
       +
       		return

     

       99
       99
       +
       	}

     

       100
       100
       +
       

     

       101
       101
       +
       	// 8. Return JSON response with URI and CID

     

       102
       102
       +
       	output := UpdateCommentOutput{

     

       103
       103
       +
       		URI: response.URI,

     

       104
       104
       +
       		CID: response.CID,

     

       105
       105
       +
       	}

     

       106
       106
       +
       

     

       107
       107
       +
       	w.Header().Set("Content-Type", "application/json")

     

       108
       108
       +
       	w.WriteHeader(http.StatusOK)

     

       109
       109
       +
       	if err := json.NewEncoder(w).Encode(output); err != nil {

     

       110
       110
       +
       		log.Printf("Failed to encode response: %v", err)

     

       111
       111
       +
       	}

     

       112
       112
       +
       }

+35

internal/api/routes/comment.go

···

       1
       1
       +
       package routes

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/api/handlers/comments"

     

       5
       5
       +
       	"Coves/internal/api/middleware"

     

       6
       6
       +
       	commentsCore "Coves/internal/core/comments"

     

       7
       7
       +
       

     

       8
       8
       +
       	"github.com/go-chi/chi/v5"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // RegisterCommentRoutes registers comment-related XRPC endpoints on the router

     

       12
       12
       +
       // Implements social.coves.community.comment.* lexicon endpoints

     

       13
       13
       +
       // All write operations (create, update, delete) require authentication

     

       14
       14
       +
       func RegisterCommentRoutes(r chi.Router, service commentsCore.Service, authMiddleware *middleware.OAuthAuthMiddleware) {

     

       15
       15
       +
       	// Initialize handlers

     

       16
       16
       +
       	createHandler := comments.NewCreateCommentHandler(service)

     

       17
       17
       +
       	updateHandler := comments.NewUpdateCommentHandler(service)

     

       18
       18
       +
       	deleteHandler := comments.NewDeleteCommentHandler(service)

     

       19
       19
       +
       

     

       20
       20
       +
       	// Procedure endpoints (POST) - require authentication

     

       21
       21
       +
       	// social.coves.community.comment.create - create a new comment on a post or another comment

     

       22
       22
       +
       	r.With(authMiddleware.RequireAuth).Post(

     

       23
       23
       +
       		"/xrpc/social.coves.community.comment.create",

     

       24
       24
       +
       		createHandler.HandleCreate)

     

       25
       25
       +
       

     

       26
       26
       +
       	// social.coves.community.comment.update - update an existing comment's content

     

       27
       27
       +
       	r.With(authMiddleware.RequireAuth).Post(

     

       28
       28
       +
       		"/xrpc/social.coves.community.comment.update",

     

       29
       29
       +
       		updateHandler.HandleUpdate)

     

       30
       30
       +
       

     

       31
       31
       +
       	// social.coves.community.comment.delete - soft delete a comment

     

       32
       32
       +
       	r.With(authMiddleware.RequireAuth).Post(

     

       33
       33
       +
       		"/xrpc/social.coves.community.comment.delete",

     

       34
       34
       +
       		deleteHandler.HandleDelete)

     

       35
       35
       +
       }

+4 -2

tests/integration/comment_query_test.go

···

       785
       785
        
       	postRepo := postgres.NewPostRepository(db)

     

       786
       786
        
       	userRepo := postgres.NewUserRepository(db)

     

       787
       787
        
       	communityRepo := postgres.NewCommunityRepository(db)

     

       788
       788
       -
       	return comments.NewCommentService(commentRepo, userRepo, postRepo, communityRepo)

     

       788
       788
       +
       	// Use factory constructor with nil factory - these tests only use the read path (GetComments)

     

       789
       789
       +
       	return comments.NewCommentServiceWithPDSFactory(commentRepo, userRepo, postRepo, communityRepo, nil, nil)

     

       789
       790
        
       }

     

       790
       791
        
       

     

       791
       792
        
       // Helper: createTestCommentWithScore creates a comment with specific vote counts

     
···

       871
       872
        
       	postRepo := postgres.NewPostRepository(db)

     

       872
       873
        
       	userRepo := postgres.NewUserRepository(db)

     

       873
       874
        
       	communityRepo := postgres.NewCommunityRepository(db)

     

       874
       874
       -
       	service := comments.NewCommentService(commentRepo, userRepo, postRepo, communityRepo)

     

       875
       875
       +
       	// Use factory constructor with nil factory - these tests only use the read path (GetComments)

     

       876
       876
       +
       	service := comments.NewCommentServiceWithPDSFactory(commentRepo, userRepo, postRepo, communityRepo, nil, nil)

     

       875
       877
        
       	return &testCommentServiceAdapter{service: service}

     

       876
       878
        
       }

     

       877
       879

+6 -3

tests/integration/comment_vote_test.go

···

       417
       417
        
       		}

     

       418
       418
        
       

     

       419
       419
        
       		// Query comments with viewer authentication

     

       420
       420
       -
       		commentService := comments.NewCommentService(commentRepo, userRepo, postRepo, communityRepo)

     

       420
       420
       +
       		// Use factory constructor with nil factory - this test only uses the read path (GetComments)

     

       421
       421
       +
       		commentService := comments.NewCommentServiceWithPDSFactory(commentRepo, userRepo, postRepo, communityRepo, nil, nil)

     

       421
       422
        
       		response, err := commentService.GetComments(ctx, &comments.GetCommentsRequest{

     

       422
       423
        
       			PostURI:   testPostURI,

     

       423
       424
        
       			Sort:      "new",

     
···

       499
       500
        
       		}

     

       500
       501
        
       

     

       501
       502
        
       		// Query with authentication but no vote

     

       502
       502
       -
       		commentService := comments.NewCommentService(commentRepo, userRepo, postRepo, communityRepo)

     

       503
       503
       +
       		// Use factory constructor with nil factory - this test only uses the read path (GetComments)

     

       504
       504
       +
       		commentService := comments.NewCommentServiceWithPDSFactory(commentRepo, userRepo, postRepo, communityRepo, nil, nil)

     

       503
       505
        
       		response, err := commentService.GetComments(ctx, &comments.GetCommentsRequest{

     

       504
       506
        
       			PostURI:   testPostURI,

     

       505
       507
        
       			Sort:      "new",

     
···

       542
       544
        
       

     

       543
       545
        
       	t.Run("Unauthenticated request has no viewer state", func(t *testing.T) {

     

       544
       546
        
       		// Query without authentication

     

       545
       545
       -
       		commentService := comments.NewCommentService(commentRepo, userRepo, postRepo, communityRepo)

     

       547
       547
       +
       		// Use factory constructor with nil factory - this test only uses the read path (GetComments)

     

       548
       548
       +
       		commentService := comments.NewCommentServiceWithPDSFactory(commentRepo, userRepo, postRepo, communityRepo, nil, nil)

     

       546
       549
        
       		response, err := commentService.GetComments(ctx, &comments.GetCommentsRequest{

     

       547
       550
        
       			PostURI:   testPostURI,

     

       548
       551
        
       			Sort:      "new",

+2 -1

tests/integration/concurrent_scenarios_test.go

···

       454
       454
        
       		}

     

       455
       455
        
       

     

       456
       456
        
       		// Verify all comments are retrievable via service

     

       457
       457
       -
       		commentService := comments.NewCommentService(commentRepo, userRepo, postRepo, communityRepo)

     

       457
       457
       +
       		// Use factory constructor with nil factory - this test only uses the read path (GetComments)

     

       458
       458
       +
       		commentService := comments.NewCommentServiceWithPDSFactory(commentRepo, userRepo, postRepo, communityRepo, nil, nil)

     

       458
       459
        
       		response, err := commentService.GetComments(ctx, &comments.GetCommentsRequest{

     

       459
       460
        
       			PostURI:   postURI,

     

       460
       461
        
       			Sort:      "new",

+1 -1

go.mod

···

       72
       72
        
       	github.com/prometheus/client_model v0.5.0 // indirect

     

       73
       73
        
       	github.com/prometheus/common v0.45.0 // indirect

     

       74
       74
        
       	github.com/prometheus/procfs v0.12.0 // indirect

     

       75
       75
       -
       	github.com/rivo/uniseg v0.1.0 // indirect

     

       75
       75
       +
       	github.com/rivo/uniseg v0.4.7 // indirect

     

       76
       76
        
       	github.com/segmentio/asm v1.2.0 // indirect

     

       77
       77
        
       	github.com/sethvargo/go-retry v0.3.0 // indirect

     

       78
       78
        
       	github.com/spaolacci/murmur3 v1.1.0 // indirect

go.sum

···

       159
       159
        
       github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=

     

       160
       160
        
       github.com/rivo/uniseg v0.1.0 h1:+2KBaVoUmb9XzDsrx/Ct0W/EYOSFf/nWTauy++DprtY=

     

       161
       161
        
       github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=

     

       162
       162
       +
       github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=

     

       163
       163
       +
       github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=

     

       162
       164
        
       github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=

     

       163
       165
        
       github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=

     

       164
       166
        
       github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=

+66

internal/db/migrations/021_add_comment_deletion_metadata.sql

···

       1
       1
       +
       -- +goose Up

     

       2
       2
       +
       -- Add deletion reason tracking to preserve thread structure while respecting privacy

     

       3
       3
       +
       -- When comments are deleted, we blank content but keep the record for threading

     

       4
       4
       +
       

     

       5
       5
       +
       -- Create enum type for deletion reasons

     

       6
       6
       +
       CREATE TYPE deletion_reason AS ENUM ('author', 'moderator');

     

       7
       7
       +
       

     

       8
       8
       +
       -- Add new columns to comments table

     

       9
       9
       +
       ALTER TABLE comments ADD COLUMN deletion_reason deletion_reason;

     

       10
       10
       +
       ALTER TABLE comments ADD COLUMN deleted_by TEXT;

     

       11
       11
       +
       

     

       12
       12
       +
       -- Add comments for new columns

     

       13
       13
       +
       COMMENT ON COLUMN comments.deletion_reason IS 'Reason for deletion: author (user deleted), moderator (community mod removed)';

     

       14
       14
       +
       COMMENT ON COLUMN comments.deleted_by IS 'DID of the actor who performed the deletion';

     

       15
       15
       +
       

     

       16
       16
       +
       -- Backfill existing deleted comments as author-deleted

     

       17
       17
       +
       -- This handles existing soft-deleted comments gracefully

     

       18
       18
       +
       UPDATE comments

     

       19
       19
       +
       SET deletion_reason = 'author',

     

       20
       20
       +
           deleted_by = commenter_did

     

       21
       21
       +
       WHERE deleted_at IS NOT NULL AND deletion_reason IS NULL;

     

       22
       22
       +
       

     

       23
       23
       +
       -- Modify existing indexes to NOT filter deleted_at IS NULL

     

       24
       24
       +
       -- This allows deleted comments to appear in thread queries for structure preservation

     

       25
       25
       +
       -- Note: We drop and recreate to change the partial index condition

     

       26
       26
       +
       

     

       27
       27
       +
       -- Drop old partial indexes that exclude deleted comments

     

       28
       28
       +
       DROP INDEX IF EXISTS idx_comments_root;

     

       29
       29
       +
       DROP INDEX IF EXISTS idx_comments_parent;

     

       30
       30
       +
       DROP INDEX IF EXISTS idx_comments_parent_score;

     

       31
       31
       +
       DROP INDEX IF EXISTS idx_comments_uri_active;

     

       32
       32
       +
       

     

       33
       33
       +
       -- Recreate indexes without the deleted_at filter (include all comments for threading)

     

       34
       34
       +
       CREATE INDEX idx_comments_root ON comments(root_uri, created_at DESC);

     

       35
       35
       +
       CREATE INDEX idx_comments_parent ON comments(parent_uri, created_at DESC);

     

       36
       36
       +
       CREATE INDEX idx_comments_parent_score ON comments(parent_uri, score DESC, created_at DESC);

     

       37
       37
       +
       CREATE INDEX idx_comments_uri_lookup ON comments(uri);

     

       38
       38
       +
       

     

       39
       39
       +
       -- Add index for querying by deletion_reason (for moderation dashboard)

     

       40
       40
       +
       CREATE INDEX idx_comments_deleted_reason ON comments(deletion_reason, deleted_at DESC)

     

       41
       41
       +
       WHERE deleted_at IS NOT NULL;

     

       42
       42
       +
       

     

       43
       43
       +
       -- Add index for querying by deleted_by (for moderation audit/filtering)

     

       44
       44
       +
       CREATE INDEX idx_comments_deleted_by ON comments(deleted_by, deleted_at DESC)

     

       45
       45
       +
       WHERE deleted_at IS NOT NULL;

     

       46
       46
       +
       

     

       47
       47
       +
       -- +goose Down

     

       48
       48
       +
       -- Remove deletion metadata columns and restore original indexes

     

       49
       49
       +
       

     

       50
       50
       +
       DROP INDEX IF EXISTS idx_comments_deleted_by;

     

       51
       51
       +
       DROP INDEX IF EXISTS idx_comments_deleted_reason;

     

       52
       52
       +
       DROP INDEX IF EXISTS idx_comments_uri_lookup;

     

       53
       53
       +
       DROP INDEX IF EXISTS idx_comments_parent_score;

     

       54
       54
       +
       DROP INDEX IF EXISTS idx_comments_parent;

     

       55
       55
       +
       DROP INDEX IF EXISTS idx_comments_root;

     

       56
       56
       +
       

     

       57
       57
       +
       -- Restore original partial indexes (excluding deleted comments)

     

       58
       58
       +
       CREATE INDEX idx_comments_root ON comments(root_uri, created_at DESC) WHERE deleted_at IS NULL;

     

       59
       59
       +
       CREATE INDEX idx_comments_parent ON comments(parent_uri, created_at DESC) WHERE deleted_at IS NULL;

     

       60
       60
       +
       CREATE INDEX idx_comments_parent_score ON comments(parent_uri, score DESC, created_at DESC) WHERE deleted_at IS NULL;

     

       61
       61
       +
       CREATE INDEX idx_comments_uri_active ON comments(uri) WHERE deleted_at IS NULL;

     

       62
       62
       +
       

     

       63
       63
       +
       ALTER TABLE comments DROP COLUMN IF EXISTS deleted_by;

     

       64
       64
       +
       ALTER TABLE comments DROP COLUMN IF EXISTS deletion_reason;

     

       65
       65
       +
       

     

       66
       66
       +
       DROP TYPE IF EXISTS deletion_reason;

+17 -13

internal/core/comments/view_models.go

···

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

     

       8
       8
        
       // Matches social.coves.community.comment.getComments#commentView lexicon

     

       9
       9
        
       // Used in thread views and get endpoints

     

       10
       10
       +
       // For deleted comments, IsDeleted=true and content-related fields are empty/nil

     

       10
       11
        
       type CommentView struct {

     

       11
       11
       -
       	Embed         interface{}         `json:"embed,omitempty"`

     

       12
       12
       -
       	Record        interface{}         `json:"record"`

     

       13
       13
       -
       	Viewer        *CommentViewerState `json:"viewer,omitempty"`

     

       14
       14
       -
       	Author        *posts.AuthorView   `json:"author"`

     

       15
       15
       -
       	Post          *CommentRef         `json:"post"`

     

       16
       16
       -
       	Parent        *CommentRef         `json:"parent,omitempty"`

     

       17
       17
       -
       	Stats         *CommentStats       `json:"stats"`

     

       18
       18
       -
       	Content       string              `json:"content"`

     

       19
       19
       -
       	CreatedAt     string              `json:"createdAt"`

     

       20
       20
       -
       	IndexedAt     string              `json:"indexedAt"`

     

       21
       21
       -
       	URI           string              `json:"uri"`

     

       22
       22
       -
       	CID           string              `json:"cid"`

     

       23
       23
       -
       	ContentFacets []interface{}       `json:"contentFacets,omitempty"`

     

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

     

       13
       13
       +
       	Record         interface{}         `json:"record"`

     

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

     

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

     

       16
       16
       +
       	Post           *CommentRef         `json:"post"`

     

       17
       17
       +
       	Parent         *CommentRef         `json:"parent,omitempty"`

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       25
       25
       +
       	IsDeleted      bool                `json:"isDeleted,omitempty"`

     

       26
       26
       +
       	DeletionReason *string             `json:"deletionReason,omitempty"`

     

       27
       27
       +
       	DeletedAt      *string             `json:"deletedAt,omitempty"`

     

       24
       28
        
       }

     

       25
       29
        
       

     

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

+23 -1

internal/core/comments/interfaces.go

···

       1
       1
        
       package comments

     

       2
       2
        
       

     

       3
       3
       -
       import "context"

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"database/sql"

     

       6
       6
       +
       )

     

       4
       7
        
       

     

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

     

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

     
···

       25
       28
        
       

     

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

     

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

     

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

     

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

     

       29
       33
        
       

     

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

     

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

     

       36
       36
       +
       	// reason: "author" (user deleted) or "moderator" (mod removed)

     

       37
       37
       +
       	// deletedByDID: DID of the actor who performed the deletion

     

       38
       38
       +
       	SoftDeleteWithReason(ctx context.Context, uri, reason, deletedByDID string) error

     

       39
       39
       +
       

     

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

     

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

     

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

     
···

       76
       86
        
       		limitPerParent int,

     

       77
       87
        
       	) (map[string][]*Comment, error)

     

       78
       88
        
       }

     

       89
       89
       +
       

     

       90
       90
       +
       // RepositoryTx provides transaction-aware operations for consumers that need atomicity

     

       91
       91
       +
       // Used by Jetstream consumer to perform atomic delete + count updates

     

       92
       92
       +
       // Implementations that support transactions should also implement this interface

     

       93
       93
       +
       type RepositoryTx interface {

     

       94
       94
       +
       	// SoftDeleteWithReasonTx performs a soft delete within a transaction

     

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

     

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

     

       97
       97
       +
       	// reason: must be DeletionReasonAuthor or DeletionReasonModerator

     

       98
       98
       +
       	// deletedByDID: DID of the actor who performed the deletion

     

       99
       99
       +
       	SoftDeleteWithReasonTx(ctx context.Context, tx *sql.Tx, uri, reason, deletedByDID string) (int64, error)

     

       100
       100
       +
       }

+87 -27

internal/db/postgres/comment_repo.go

···

       120
       120
        
       			id, uri, cid, rkey, commenter_did,

     

       121
       121
        
       			root_uri, root_cid, parent_uri, parent_cid,

     

       122
       122
        
       			content, content_facets, embed, content_labels, langs,

     

       123
       123
       -
       			created_at, indexed_at, deleted_at,

     

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

     

       124
       124
        
       			upvote_count, downvote_count, score, reply_count

     

       125
       125
        
       		FROM comments

     

       126
       126
        
       		WHERE uri = $1

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       138
       138
        
       	)

     

       139
       139
        
       

     
···

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

     

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

     

       154
       154
        
       // Idempotent: Returns success if comment already deleted

     

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

     

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

     

       156
       157
        
       	query := `

     

       157
       158
        
       		UPDATE comments

     
···

       177
       178
        
       	return nil

     

       178
       179
        
       }

     

       179
       180
        
       

     

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

     

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

     

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

     

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

     

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

     

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

     

       186
       186
       +
       	// Validate deletion reason

     

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

     

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

     

       189
       189
       +
       	}

     

       190
       190
       +
       

     

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

     

       192
       192
       +
       	return err

     

       193
       193
       +
       }

     

       194
       194
       +
       

     

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

     

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

     

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

     

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

     

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

     

       200
       200
       +
       	query := `

     

       201
       201
       +
       		UPDATE comments

     

       202
       202
       +
       		SET

     

       203
       203
       +
       			content = '',

     

       204
       204
       +
       			content_facets = NULL,

     

       205
       205
       +
       			embed = NULL,

     

       206
       206
       +
       			content_labels = NULL,

     

       207
       207
       +
       			deleted_at = NOW(),

     

       208
       208
       +
       			deletion_reason = $2,

     

       209
       209
       +
       			deleted_by = $3

     

       210
       210
       +
       		WHERE uri = $1 AND deleted_at IS NULL

     

       211
       211
       +
       	`

     

       212
       212
       +
       

     

       213
       213
       +
       	var result sql.Result

     

       214
       214
       +
       	var err error

     

       215
       215
       +
       

     

       216
       216
       +
       	if tx != nil {

     

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

     

       218
       218
       +
       	} else {

     

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

     

       220
       220
       +
       	}

     

       221
       221
       +
       

     

       222
       222
       +
       	if err != nil {

     

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

     

       224
       224
       +
       	}

     

       225
       225
       +
       

     

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

     

       227
       227
       +
       	if err != nil {

     

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

     

       229
       229
       +
       	}

     

       230
       230
       +
       

     

       231
       231
       +
       	return rowsAffected, nil

     

       232
       232
       +
       }

     

       233
       233
       +
       

     

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

     

       181
       235
        
       // Used for fetching entire comment threads on posts

     

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

     

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

     

       183
       238
        
       	query := `

     

       184
       239
        
       		SELECT

     

       185
       240
        
       			id, uri, cid, rkey, commenter_did,

     

       186
       241
        
       			root_uri, root_cid, parent_uri, parent_cid,

     

       187
       242
        
       			content, content_facets, embed, content_labels, langs,

     

       188
       188
       -
       			created_at, indexed_at, deleted_at,

     

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

     

       189
       244
        
       			upvote_count, downvote_count, score, reply_count

     

       190
       245
        
       		FROM comments

     

       191
       191
       -
       		WHERE root_uri = $1 AND deleted_at IS NULL

     

       246
       246
       +
       		WHERE root_uri = $1

     

       192
       247
        
       		ORDER BY created_at ASC

     

       193
       248
        
       		LIMIT $2 OFFSET $3

     

       194
       249
        
       	`

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       217
       272
        
       		)

     

       218
       273
        
       		if err != nil {

     
···

       230
       285
        
       	return result, nil

     

       231
       286
        
       }

     

       232
       287
        
       

     

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

     

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

     

       234
       289
        
       // Used for building nested/threaded comment views

     

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

     

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

     

       236
       292
        
       	query := `

     

       237
       293
        
       		SELECT

     

       238
       294
        
       			id, uri, cid, rkey, commenter_did,

     

       239
       295
        
       			root_uri, root_cid, parent_uri, parent_cid,

     

       240
       296
        
       			content, content_facets, embed, content_labels, langs,

     

       241
       241
       -
       			created_at, indexed_at, deleted_at,

     

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

     

       242
       298
        
       			upvote_count, downvote_count, score, reply_count

     

       243
       299
        
       		FROM comments

     

       244
       244
       -
       		WHERE parent_uri = $1 AND deleted_at IS NULL

     

       300
       300
       +
       		WHERE parent_uri = $1

     

       245
       301
        
       		ORDER BY created_at ASC

     

       246
       302
        
       		LIMIT $2 OFFSET $3

     

       247
       303
        
       	`

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       270
       326
        
       		)

     

       271
       327
        
       		if err != nil {

     
···

       302
       358
        
       }

     

       303
       359
        
       

     

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

     

       305
       305
       -
       // Future: Used for user comment history

     

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

     

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

     

       307
       363
        
       	query := `

     

       308
       364
        
       		SELECT

     

       309
       365
        
       			id, uri, cid, rkey, commenter_did,

     

       310
       366
        
       			root_uri, root_cid, parent_uri, parent_cid,

     

       311
       367
        
       			content, content_facets, embed, content_labels, langs,

     

       312
       312
       -
       			created_at, indexed_at, deleted_at,

     

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

     

       313
       369
        
       			upvote_count, downvote_count, score, reply_count

     

       314
       370
        
       		FROM comments

     

       315
       371
        
       		WHERE commenter_did = $1 AND deleted_at IS NULL

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       341
       397
        
       		)

     

       342
       398
        
       		if err != nil {

     
···

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       407
       463
        
       			NULL::numeric as hot_rank,

     

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

     
···

       411
       467
        
       

     

       412
       468
        
       	// Build complete query with JOINs and filters

     

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

     

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

     

       414
       471
        
       	query := fmt.Sprintf(`

     

       415
       472
        
       		%s

     

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

     

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

     

       474
       474
       +
       		WHERE c.parent_uri = $1

     

       418
       475
        
       			%s

     

       419
       476
        
       			%s

     

       420
       477
        
       		ORDER BY %s

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       454
       511
        
       			&hotRank, &authorHandle,

     

       455
       512
        
       		)

     
···

       687
       744
        
       

     

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

     

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

     

       747
       747
       +
       // Includes deleted comments to preserve thread structure

     

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

     

       691
       749
        
       	if len(uris) == 0 {

     

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

     
···

       694
       752
        
       

     

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

     

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

     

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

     

       697
       756
        
       	query := `

     

       698
       757
        
       		SELECT

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       705
       764
        
       		FROM comments c

     

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

     

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

     

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

     

       708
       767
        
       	`

     

       709
       768
        
       

     

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

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       732
       791
        
       			&authorHandle,

     

       733
       792
        
       		)

     
···

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       785
       844
        
       			NULL::numeric as hot_rank,

     

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

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       795
       854
        
       			NULL::numeric as hot_rank,

     

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

     
···

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     
···

       812
       871
        
       	// Use window function to limit results per parent

     

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

     

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

     

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

     

       815
       875
        
       	query := fmt.Sprintf(`

     

       816
       876
        
       		WITH ranked_comments AS (

     

       817
       877
        
       			SELECT

     
···

       822
       882
        
       				) as rn

     

       823
       883
        
       			FROM comments c

     

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

     

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

     

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

     

       826
       886
        
       		)

     

       827
       887
        
       		SELECT

     

       828
       888
        
       			id, uri, cid, rkey, commenter_did,

     

       829
       889
        
       			root_uri, root_cid, parent_uri, parent_cid,

     

       830
       890
        
       			content, content_facets, embed, content_labels, langs,

     

       831
       831
       -
       			created_at, indexed_at, deleted_at,

     

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

     

       832
       892
        
       			upvote_count, downvote_count, score, reply_count,

     

       833
       893
        
       			hot_rank, author_handle

     

       834
       894
        
       		FROM ranked_comments

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       863
       923
        
       			&hotRank, &authorHandle,

     

       864
       924
        
       		)

+33

internal/atproto/pds/client.go

···

       31
       31
        
       	// GetRecord retrieves a single record by collection and rkey.

     

       32
       32
        
       	GetRecord(ctx context.Context, collection string, rkey string) (*RecordResponse, error)

     

       33
       33
        
       

     

       34
       34
       +
       	// PutRecord creates or updates a record with optional optimistic locking.

     

       35
       35
       +
       	// If swapRecord CID is provided, the operation fails if the current CID doesn't match.

     

       36
       36
       +
       	PutRecord(ctx context.Context, collection string, rkey string, record any, swapRecord string) (uri string, cid string, err error)

     

       37
       37
       +
       

     

       34
       38
        
       	// DID returns the authenticated user's DID.

     

       35
       39
        
       	DID() string

     

       36
       40
        
       

     
···

       89
       93
        
       			return fmt.Errorf("%s: %w: %s", operation, ErrForbidden, apiErr.Message)

     

       90
       94
        
       		case 404:

     

       91
       95
        
       			return fmt.Errorf("%s: %w: %s", operation, ErrNotFound, apiErr.Message)

     

       96
       96
       +
       		case 409:

     

       97
       97
       +
       			return fmt.Errorf("%s: %w: %s", operation, ErrConflict, apiErr.Message)

     

       92
       98
        
       		}

     

       93
       99
        
       	}

     

       94
       100
        
       

     
···

       218
       224
        
       		Value: result.Value,

     

       219
       225
        
       	}, nil

     

       220
       226
        
       }

     

       227
       227
       +
       

     

       228
       228
       +
       // PutRecord creates or updates a record with optional optimistic locking.

     

       229
       229
       +
       func (c *client) PutRecord(ctx context.Context, collection string, rkey string, record any, swapRecord string) (string, string, error) {

     

       230
       230
       +
       	payload := map[string]any{

     

       231
       231
       +
       		"repo":       c.did,

     

       232
       232
       +
       		"collection": collection,

     

       233
       233
       +
       		"rkey":       rkey,

     

       234
       234
       +
       		"record":     record,

     

       235
       235
       +
       	}

     

       236
       236
       +
       

     

       237
       237
       +
       	// Optional: optimistic locking via CID swap check

     

       238
       238
       +
       	if swapRecord != "" {

     

       239
       239
       +
       		payload["swapRecord"] = swapRecord

     

       240
       240
       +
       	}

     

       241
       241
       +
       

     

       242
       242
       +
       	var result struct {

     

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

     

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

     

       245
       245
       +
       	}

     

       246
       246
       +
       

     

       247
       247
       +
       	err := c.apiClient.Post(ctx, syntax.NSID("com.atproto.repo.putRecord"), payload, &result)

     

       248
       248
       +
       	if err != nil {

     

       249
       249
       +
       		return "", "", wrapAPIError(err, "putRecord")

     

       250
       250
       +
       	}

     

       251
       251
       +
       

     

       252
       252
       +
       	return result.URI, result.CID, nil

     

       253
       253
       +
       }

+231

internal/atproto/pds/client_test.go

···

       958
       958
        
       			operation: "createRecord",

     

       959
       959
        
       			wantTyped: ErrBadRequest,

     

       960
       960
        
       		},

     

       961
       961
       +
       		{

     

       962
       962
       +
       			name:      "409 maps to ErrConflict",

     

       963
       963
       +
       			err:       &atclient.APIError{StatusCode: 409, Name: "InvalidSwap", Message: "Record CID mismatch"},

     

       964
       964
       +
       			operation: "putRecord",

     

       965
       965
       +
       			wantTyped: ErrConflict,

     

       966
       966
       +
       		},

     

       961
       967
        
       		{

     

       962
       968
        
       			name:      "500 wraps without typed error",

     

       963
       969
        
       			err:       &atclient.APIError{StatusCode: 500, Name: "InternalError", Message: "Server error"},

     
···

       1172
       1178
        
       		})

     

       1173
       1179
        
       	}

     

       1174
       1180
        
       }

     

       1181
       1181
       +
       

     

       1182
       1182
       +
       // TestClient_PutRecord tests the PutRecord method with a mock server.

     

       1183
       1183
       +
       func TestClient_PutRecord(t *testing.T) {

     

       1184
       1184
       +
       	tests := []struct {

     

       1185
       1185
       +
       		name           string

     

       1186
       1186
       +
       		collection     string

     

       1187
       1187
       +
       		rkey           string

     

       1188
       1188
       +
       		record         map[string]any

     

       1189
       1189
       +
       		swapRecord     string

     

       1190
       1190
       +
       		serverResponse map[string]any

     

       1191
       1191
       +
       		serverStatus   int

     

       1192
       1192
       +
       		wantURI        string

     

       1193
       1193
       +
       		wantCID        string

     

       1194
       1194
       +
       		wantErr        bool

     

       1195
       1195
       +
       	}{

     

       1196
       1196
       +
       		{

     

       1197
       1197
       +
       			name:       "successful put with swapRecord",

     

       1198
       1198
       +
       			collection: "social.coves.comment",

     

       1199
       1199
       +
       			rkey:       "3kjzl5kcb2s2v",

     

       1200
       1200
       +
       			record: map[string]any{

     

       1201
       1201
       +
       				"$type":   "social.coves.comment",

     

       1202
       1202
       +
       				"content": "Updated comment content",

     

       1203
       1203
       +
       			},

     

       1204
       1204
       +
       			swapRecord: "bafyreigbtj4x7ip5legnfznufuopl4sg4knzc2cof6duas4b3q2fy6swua",

     

       1205
       1205
       +
       			serverResponse: map[string]any{

     

       1206
       1206
       +
       				"uri": "at://did:plc:test/social.coves.comment/3kjzl5kcb2s2v",

     

       1207
       1207
       +
       				"cid": "bafyreihd4q3yqcfvnv5zlp6n4fqzh6z4p4m3mwc7vvr6k2j6y6v2a3b4c5",

     

       1208
       1208
       +
       			},

     

       1209
       1209
       +
       			serverStatus: http.StatusOK,

     

       1210
       1210
       +
       			wantURI:      "at://did:plc:test/social.coves.comment/3kjzl5kcb2s2v",

     

       1211
       1211
       +
       			wantCID:      "bafyreihd4q3yqcfvnv5zlp6n4fqzh6z4p4m3mwc7vvr6k2j6y6v2a3b4c5",

     

       1212
       1212
       +
       			wantErr:      false,

     

       1213
       1213
       +
       		},

     

       1214
       1214
       +
       		{

     

       1215
       1215
       +
       			name:       "successful put without swapRecord",

     

       1216
       1216
       +
       			collection: "social.coves.comment",

     

       1217
       1217
       +
       			rkey:       "3kjzl5kcb2s2v",

     

       1218
       1218
       +
       			record: map[string]any{

     

       1219
       1219
       +
       				"$type":   "social.coves.comment",

     

       1220
       1220
       +
       				"content": "Updated comment",

     

       1221
       1221
       +
       			},

     

       1222
       1222
       +
       			swapRecord: "",

     

       1223
       1223
       +
       			serverResponse: map[string]any{

     

       1224
       1224
       +
       				"uri": "at://did:plc:test/social.coves.comment/3kjzl5kcb2s2v",

     

       1225
       1225
       +
       				"cid": "bafyreihd4q3yqcfvnv5zlp6n4fqzh6z4p4m3mwc7vvr6k2j6y6v2a3b4c5",

     

       1226
       1226
       +
       			},

     

       1227
       1227
       +
       			serverStatus: http.StatusOK,

     

       1228
       1228
       +
       			wantURI:      "at://did:plc:test/social.coves.comment/3kjzl5kcb2s2v",

     

       1229
       1229
       +
       			wantCID:      "bafyreihd4q3yqcfvnv5zlp6n4fqzh6z4p4m3mwc7vvr6k2j6y6v2a3b4c5",

     

       1230
       1230
       +
       			wantErr:      false,

     

       1231
       1231
       +
       		},

     

       1232
       1232
       +
       		{

     

       1233
       1233
       +
       			name:       "conflict error (409)",

     

       1234
       1234
       +
       			collection: "social.coves.comment",

     

       1235
       1235
       +
       			rkey:       "test",

     

       1236
       1236
       +
       			record:     map[string]any{"$type": "social.coves.comment"},

     

       1237
       1237
       +
       			swapRecord: "bafyreigbtj4x7ip5legnfznufuopl4sg4knzc2cof6duas4b3q2fy6swua",

     

       1238
       1238
       +
       			serverResponse: map[string]any{

     

       1239
       1239
       +
       				"error":   "InvalidSwap",

     

       1240
       1240
       +
       				"message": "Record CID does not match",

     

       1241
       1241
       +
       			},

     

       1242
       1242
       +
       			serverStatus: http.StatusConflict,

     

       1243
       1243
       +
       			wantErr:      true,

     

       1244
       1244
       +
       		},

     

       1245
       1245
       +
       		{

     

       1246
       1246
       +
       			name:       "server error",

     

       1247
       1247
       +
       			collection: "social.coves.comment",

     

       1248
       1248
       +
       			rkey:       "test",

     

       1249
       1249
       +
       			record:     map[string]any{"$type": "social.coves.comment"},

     

       1250
       1250
       +
       			swapRecord: "",

     

       1251
       1251
       +
       			serverResponse: map[string]any{

     

       1252
       1252
       +
       				"error":   "InvalidRequest",

     

       1253
       1253
       +
       				"message": "Invalid record",

     

       1254
       1254
       +
       			},

     

       1255
       1255
       +
       			serverStatus: http.StatusBadRequest,

     

       1256
       1256
       +
       			wantErr:      true,

     

       1257
       1257
       +
       		},

     

       1258
       1258
       +
       	}

     

       1259
       1259
       +
       

     

       1260
       1260
       +
       	for _, tt := range tests {

     

       1261
       1261
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       1262
       1262
       +
       			// Create mock server

     

       1263
       1263
       +
       			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       1264
       1264
       +
       				// Verify method

     

       1265
       1265
       +
       				if r.Method != http.MethodPost {

     

       1266
       1266
       +
       					t.Errorf("expected POST request, got %s", r.Method)

     

       1267
       1267
       +
       				}

     

       1268
       1268
       +
       

     

       1269
       1269
       +
       				// Verify path

     

       1270
       1270
       +
       				expectedPath := "/xrpc/com.atproto.repo.putRecord"

     

       1271
       1271
       +
       				if r.URL.Path != expectedPath {

     

       1272
       1272
       +
       					t.Errorf("path = %q, want %q", r.URL.Path, expectedPath)

     

       1273
       1273
       +
       				}

     

       1274
       1274
       +
       

     

       1275
       1275
       +
       				// Verify request body

     

       1276
       1276
       +
       				var payload map[string]any

     

       1277
       1277
       +
       				if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {

     

       1278
       1278
       +
       					t.Fatalf("failed to decode request body: %v", err)

     

       1279
       1279
       +
       				}

     

       1280
       1280
       +
       

     

       1281
       1281
       +
       				// Check required fields

     

       1282
       1282
       +
       				if payload["collection"] != tt.collection {

     

       1283
       1283
       +
       					t.Errorf("collection = %v, want %v", payload["collection"], tt.collection)

     

       1284
       1284
       +
       				}

     

       1285
       1285
       +
       				if payload["rkey"] != tt.rkey {

     

       1286
       1286
       +
       					t.Errorf("rkey = %v, want %v", payload["rkey"], tt.rkey)

     

       1287
       1287
       +
       				}

     

       1288
       1288
       +
       

     

       1289
       1289
       +
       				// Check swapRecord inclusion

     

       1290
       1290
       +
       				if tt.swapRecord != "" {

     

       1291
       1291
       +
       					if payload["swapRecord"] != tt.swapRecord {

     

       1292
       1292
       +
       						t.Errorf("swapRecord = %v, want %v", payload["swapRecord"], tt.swapRecord)

     

       1293
       1293
       +
       					}

     

       1294
       1294
       +
       				} else {

     

       1295
       1295
       +
       					if _, exists := payload["swapRecord"]; exists {

     

       1296
       1296
       +
       						t.Error("swapRecord should not be included when empty")

     

       1297
       1297
       +
       					}

     

       1298
       1298
       +
       				}

     

       1299
       1299
       +
       

     

       1300
       1300
       +
       				// Send response

     

       1301
       1301
       +
       				w.Header().Set("Content-Type", "application/json")

     

       1302
       1302
       +
       				w.WriteHeader(tt.serverStatus)

     

       1303
       1303
       +
       				json.NewEncoder(w).Encode(tt.serverResponse)

     

       1304
       1304
       +
       			}))

     

       1305
       1305
       +
       			defer server.Close()

     

       1306
       1306
       +
       

     

       1307
       1307
       +
       			// Create client

     

       1308
       1308
       +
       			apiClient := atclient.NewAPIClient(server.URL)

     

       1309
       1309
       +
       			apiClient.Auth = &bearerAuth{token: "test-token"}

     

       1310
       1310
       +
       

     

       1311
       1311
       +
       			c := &client{

     

       1312
       1312
       +
       				apiClient: apiClient,

     

       1313
       1313
       +
       				did:       "did:plc:test",

     

       1314
       1314
       +
       				host:      server.URL,

     

       1315
       1315
       +
       			}

     

       1316
       1316
       +
       

     

       1317
       1317
       +
       			// Execute PutRecord

     

       1318
       1318
       +
       			ctx := context.Background()

     

       1319
       1319
       +
       			uri, cid, err := c.PutRecord(ctx, tt.collection, tt.rkey, tt.record, tt.swapRecord)

     

       1320
       1320
       +
       

     

       1321
       1321
       +
       			if tt.wantErr {

     

       1322
       1322
       +
       				if err == nil {

     

       1323
       1323
       +
       					t.Fatal("expected error, got nil")

     

       1324
       1324
       +
       				}

     

       1325
       1325
       +
       				return

     

       1326
       1326
       +
       			}

     

       1327
       1327
       +
       

     

       1328
       1328
       +
       			if err != nil {

     

       1329
       1329
       +
       				t.Fatalf("unexpected error: %v", err)

     

       1330
       1330
       +
       			}

     

       1331
       1331
       +
       

     

       1332
       1332
       +
       			if uri != tt.wantURI {

     

       1333
       1333
       +
       				t.Errorf("uri = %q, want %q", uri, tt.wantURI)

     

       1334
       1334
       +
       			}

     

       1335
       1335
       +
       

     

       1336
       1336
       +
       			if cid != tt.wantCID {

     

       1337
       1337
       +
       				t.Errorf("cid = %q, want %q", cid, tt.wantCID)

     

       1338
       1338
       +
       			}

     

       1339
       1339
       +
       		})

     

       1340
       1340
       +
       	}

     

       1341
       1341
       +
       }

     

       1342
       1342
       +
       

     

       1343
       1343
       +
       // TestClient_TypedErrors_PutRecord tests that PutRecord returns typed errors.

     

       1344
       1344
       +
       func TestClient_TypedErrors_PutRecord(t *testing.T) {

     

       1345
       1345
       +
       	tests := []struct {

     

       1346
       1346
       +
       		name         string

     

       1347
       1347
       +
       		serverStatus int

     

       1348
       1348
       +
       		wantErr      error

     

       1349
       1349
       +
       	}{

     

       1350
       1350
       +
       		{

     

       1351
       1351
       +
       			name:         "401 returns ErrUnauthorized",

     

       1352
       1352
       +
       			serverStatus: http.StatusUnauthorized,

     

       1353
       1353
       +
       			wantErr:      ErrUnauthorized,

     

       1354
       1354
       +
       		},

     

       1355
       1355
       +
       		{

     

       1356
       1356
       +
       			name:         "403 returns ErrForbidden",

     

       1357
       1357
       +
       			serverStatus: http.StatusForbidden,

     

       1358
       1358
       +
       			wantErr:      ErrForbidden,

     

       1359
       1359
       +
       		},

     

       1360
       1360
       +
       		{

     

       1361
       1361
       +
       			name:         "409 returns ErrConflict",

     

       1362
       1362
       +
       			serverStatus: http.StatusConflict,

     

       1363
       1363
       +
       			wantErr:      ErrConflict,

     

       1364
       1364
       +
       		},

     

       1365
       1365
       +
       		{

     

       1366
       1366
       +
       			name:         "400 returns ErrBadRequest",

     

       1367
       1367
       +
       			serverStatus: http.StatusBadRequest,

     

       1368
       1368
       +
       			wantErr:      ErrBadRequest,

     

       1369
       1369
       +
       		},

     

       1370
       1370
       +
       	}

     

       1371
       1371
       +
       

     

       1372
       1372
       +
       	for _, tt := range tests {

     

       1373
       1373
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       1374
       1374
       +
       			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       1375
       1375
       +
       				w.Header().Set("Content-Type", "application/json")

     

       1376
       1376
       +
       				w.WriteHeader(tt.serverStatus)

     

       1377
       1377
       +
       				json.NewEncoder(w).Encode(map[string]any{

     

       1378
       1378
       +
       					"error":   "TestError",

     

       1379
       1379
       +
       					"message": "Test error message",

     

       1380
       1380
       +
       				})

     

       1381
       1381
       +
       			}))

     

       1382
       1382
       +
       			defer server.Close()

     

       1383
       1383
       +
       

     

       1384
       1384
       +
       			apiClient := atclient.NewAPIClient(server.URL)

     

       1385
       1385
       +
       			apiClient.Auth = &bearerAuth{token: "test-token"}

     

       1386
       1386
       +
       

     

       1387
       1387
       +
       			c := &client{

     

       1388
       1388
       +
       				apiClient: apiClient,

     

       1389
       1389
       +
       				did:       "did:plc:test",

     

       1390
       1390
       +
       				host:      server.URL,

     

       1391
       1391
       +
       			}

     

       1392
       1392
       +
       

     

       1393
       1393
       +
       			ctx := context.Background()

     

       1394
       1394
       +
       			_, _, err := c.PutRecord(ctx, "test.collection", "rkey", map[string]any{}, "")

     

       1395
       1395
       +
       

     

       1396
       1396
       +
       			if err == nil {

     

       1397
       1397
       +
       				t.Fatal("expected error, got nil")

     

       1398
       1398
       +
       			}

     

       1399
       1399
       +
       

     

       1400
       1400
       +
       			if !errors.Is(err, tt.wantErr) {

     

       1401
       1401
       +
       				t.Errorf("expected errors.Is(%v, %v) to be true", err, tt.wantErr)

     

       1402
       1402
       +
       			}

     

       1403
       1403
       +
       		})

     

       1404
       1404
       +
       	}

     

       1405
       1405
       +
       }

internal/atproto/pds/errors.go

···

       17
       17
        
       

     

       18
       18
        
       	// ErrBadRequest indicates the request was malformed or invalid (HTTP 400).

     

       19
       19
        
       	ErrBadRequest = errors.New("bad request")

     

       20
       20
       +
       

     

       21
       21
       +
       	// ErrConflict indicates the record was modified by another operation (HTTP 409).

     

       22
       22
       +
       	ErrConflict = errors.New("record was modified by another operation")

     

       20
       23
        
       )

     

       21
       24
        
       

     

       22
       25
        
       // IsAuthError returns true if the error is an authentication/authorization error.

+5 -6

internal/core/comments/comment_service.go

···

       750
       750
        
       		CreatedAt: createdAt, // Preserve original timestamp

     

       751
       751
        
       	}

     

       752
       752
        
       

     

       753
       753
       -
       	// Update the record on PDS (putRecord)

     

       754
       754
       -
       	// Note: This creates a new CID even though the URI stays the same

     

       755
       755
       -
       	// TODO: Use PutRecord instead of CreateRecord for proper update semantics with optimistic locking.

     

       756
       756
       -
       	// PutRecord should accept the existing CID (existingRecord.CID) to ensure concurrent updates are detected.

     

       757
       757
       -
       	// However, PutRecord is not yet implemented in internal/atproto/pds/client.go.

     

       758
       758
       -
       	uri, cid, err := pdsClient.CreateRecord(ctx, commentCollection, rkey, updatedRecord)

     

       753
       753
       +
       	// Update the record on PDS with optimistic locking via swapRecord CID

     

       754
       754
       +
       	uri, cid, err := pdsClient.PutRecord(ctx, commentCollection, rkey, updatedRecord, existingRecord.CID)

     

       759
       755
        
       	if err != nil {

     

       760
       756
        
       		s.logger.Error("failed to update comment on PDS",

     

       761
       757
        
       			"error", err,

     
···

       764
       760
        
       		if pds.IsAuthError(err) {

     

       765
       761
        
       			return nil, ErrNotAuthorized

     

       766
       762
        
       		}

     

       763
       763
       +
       		if errors.Is(err, pds.ErrConflict) {

     

       764
       764
       +
       			return nil, ErrConcurrentModification

     

       765
       765
       +
       		}

     

       767
       766
        
       		return nil, fmt.Errorf("failed to update comment: %w", err)

     

       768
       767
        
       	}

     

       769
       768

+73

internal/api/handlers/common/viewer_state.go

···

       1
       1
       +
       package common

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/api/middleware"

     

       5
       5
       +
       	"Coves/internal/core/posts"

     

       6
       6
       +
       	"Coves/internal/core/votes"

     

       7
       7
       +
       	"context"

     

       8
       8
       +
       	"log"

     

       9
       9
       +
       	"net/http"

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       // FeedPostProvider is implemented by any feed post wrapper that contains a PostView.

     

       13
       13
       +
       // This allows the helper to work with different feed post types (discover, timeline, communityFeed).

     

       14
       14
       +
       type FeedPostProvider interface {

     

       15
       15
       +
       	GetPost() *posts.PostView

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       // PopulateViewerVoteState enriches feed posts with the authenticated user's vote state.

     

       19
       19
       +
       // This is a no-op if voteService is nil or the request is unauthenticated.

     

       20
       20
       +
       //

     

       21
       21
       +
       // Parameters:

     

       22
       22
       +
       //   - ctx: Request context for PDS calls

     

       23
       23
       +
       //   - r: HTTP request (used to extract OAuth session)

     

       24
       24
       +
       //   - voteService: Vote service for cache lookup (may be nil)

     

       25
       25
       +
       //   - feedPosts: Posts to enrich with viewer state (must implement FeedPostProvider)

     

       26
       26
       +
       //

     

       27
       27
       +
       // The function logs but does not fail on errors - viewer state is optional enrichment.

     

       28
       28
       +
       func PopulateViewerVoteState[T FeedPostProvider](

     

       29
       29
       +
       	ctx context.Context,

     

       30
       30
       +
       	r *http.Request,

     

       31
       31
       +
       	voteService votes.Service,

     

       32
       32
       +
       	feedPosts []T,

     

       33
       33
       +
       ) {

     

       34
       34
       +
       	if voteService == nil {

     

       35
       35
       +
       		return

     

       36
       36
       +
       	}

     

       37
       37
       +
       

     

       38
       38
       +
       	session := middleware.GetOAuthSession(r)

     

       39
       39
       +
       	if session == nil {

     

       40
       40
       +
       		return

     

       41
       41
       +
       	}

     

       42
       42
       +
       

     

       43
       43
       +
       	userDID := middleware.GetUserDID(r)

     

       44
       44
       +
       

     

       45
       45
       +
       	// Ensure vote cache is populated from PDS

     

       46
       46
       +
       	if err := voteService.EnsureCachePopulated(ctx, session); err != nil {

     

       47
       47
       +
       		log.Printf("Warning: failed to populate vote cache: %v", err)

     

       48
       48
       +
       		return

     

       49
       49
       +
       	}

     

       50
       50
       +
       

     

       51
       51
       +
       	// Collect post URIs to batch lookup

     

       52
       52
       +
       	postURIs := make([]string, 0, len(feedPosts))

     

       53
       53
       +
       	for _, feedPost := range feedPosts {

     

       54
       54
       +
       		if post := feedPost.GetPost(); post != nil {

     

       55
       55
       +
       			postURIs = append(postURIs, post.URI)

     

       56
       56
       +
       		}

     

       57
       57
       +
       	}

     

       58
       58
       +
       

     

       59
       59
       +
       	// Get viewer votes for all posts

     

       60
       60
       +
       	viewerVotes := voteService.GetViewerVotesForSubjects(userDID, postURIs)

     

       61
       61
       +
       

     

       62
       62
       +
       	// Populate viewer state on each post

     

       63
       63
       +
       	for _, feedPost := range feedPosts {

     

       64
       64
       +
       		if post := feedPost.GetPost(); post != nil {

     

       65
       65
       +
       			if vote, exists := viewerVotes[post.URI]; exists {

     

       66
       66
       +
       				post.Viewer = &posts.ViewerState{

     

       67
       67
       +
       					Vote:    &vote.Direction,

     

       68
       68
       +
       					VoteURI: &vote.URI,

     

       69
       69
       +
       				}

     

       70
       70
       +
       			}

     

       71
       71
       +
       		}

     

       72
       72
       +
       	}

     

       73
       73
       +
       }

+3 -36

internal/api/handlers/communityFeed/get_community.go

···

       1
       1
        
       package communityFeed

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"Coves/internal/api/middleware"

     

       4
       4
       +
       	"Coves/internal/api/handlers/common"

     

       5
       5
        
       	"Coves/internal/core/communityFeeds"

     

       6
       6
        
       	"Coves/internal/core/posts"

     

       7
       7
        
       	"Coves/internal/core/votes"

     
···

       47
       47
        
       		return

     

       48
       48
        
       	}

     

       49
       49
        
       

     

       50
       50
       -
       	// Populate viewer vote state if authenticated and vote service available

     

       51
       51
       -
       	if h.voteService != nil {

     

       52
       52
       -
       		session := middleware.GetOAuthSession(r)

     

       53
       53
       -
       		if session != nil {

     

       54
       54
       -
       			userDID := middleware.GetUserDID(r)

     

       55
       55
       -
       			// Ensure vote cache is populated from PDS

     

       56
       56
       -
       			if err := h.voteService.EnsureCachePopulated(r.Context(), session); err != nil {

     

       57
       57
       -
       				// Log but don't fail - viewer state is optional

     

       58
       58
       -
       				log.Printf("Warning: failed to populate vote cache: %v", err)

     

       59
       59
       -
       			} else {

     

       60
       60
       -
       				// Collect post URIs to batch lookup

     

       61
       61
       -
       				postURIs := make([]string, 0, len(response.Feed))

     

       62
       62
       -
       				for _, feedPost := range response.Feed {

     

       63
       63
       -
       					if feedPost.Post != nil {

     

       64
       64
       -
       						postURIs = append(postURIs, feedPost.Post.URI)

     

       65
       65
       -
       					}

     

       66
       66
       -
       				}

     

       67
       67
       -
       

     

       68
       68
       -
       				// Get viewer votes for all posts

     

       69
       69
       -
       				viewerVotes := h.voteService.GetViewerVotesForSubjects(userDID, postURIs)

     

       70
       70
       -
       

     

       71
       71
       -
       				// Populate viewer state on each post

     

       72
       72
       -
       				for _, feedPost := range response.Feed {

     

       73
       73
       -
       					if feedPost.Post != nil {

     

       74
       74
       -
       						if vote, exists := viewerVotes[feedPost.Post.URI]; exists {

     

       75
       75
       -
       							feedPost.Post.Viewer = &posts.ViewerState{

     

       76
       76
       -
       								Vote:    &vote.Direction,

     

       77
       77
       -
       								VoteURI: &vote.URI,

     

       78
       78
       -
       							}

     

       79
       79
       -
       						}

     

       80
       80
       -
       					}

     

       81
       81
       -
       				}

     

       82
       82
       -
       			}

     

       83
       83
       -
       		}

     

       84
       84
       -
       	}

     

       50
       50
       +
       	// Populate viewer vote state if authenticated

     

       51
       51
       +
       	common.PopulateViewerVoteState(r.Context(), r, h.voteService, response.Feed)

     

       85
       52
        
       

     

       86
       53
        
       	// Transform blob refs to URLs for all posts

     

       87
       54
        
       	for _, feedPost := range response.Feed {

+11 -4

internal/api/handlers/discover/get_discover.go

···

       1
       1
        
       package discover

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/api/handlers/common"

     

       4
       5
        
       	"Coves/internal/core/discover"

     

       5
       6
        
       	"Coves/internal/core/posts"

     

       7
       7
       +
       	"Coves/internal/core/votes"

     

       6
       8
        
       	"encoding/json"

     

       7
       9
        
       	"log"

     

       8
       10
        
       	"net/http"

     
···

       11
       13
        
       

     

       12
       14
        
       // GetDiscoverHandler handles discover feed retrieval

     

       13
       15
        
       type GetDiscoverHandler struct {

     

       14
       14
       -
       	service discover.Service

     

       16
       16
       +
       	service     discover.Service

     

       17
       17
       +
       	voteService votes.Service

     

       15
       18
        
       }

     

       16
       19
        
       

     

       17
       20
        
       // NewGetDiscoverHandler creates a new discover handler

     

       18
       18
       -
       func NewGetDiscoverHandler(service discover.Service) *GetDiscoverHandler {

     

       21
       21
       +
       func NewGetDiscoverHandler(service discover.Service, voteService votes.Service) *GetDiscoverHandler {

     

       19
       22
        
       	return &GetDiscoverHandler{

     

       20
       20
       -
       		service: service,

     

       23
       23
       +
       		service:     service,

     

       24
       24
       +
       		voteService: voteService,

     

       21
       25
        
       	}

     

       22
       26
        
       }

     

       23
       27
        
       

     

       24
       28
        
       // HandleGetDiscover retrieves posts from all communities (public feed)

     

       25
       29
        
       // GET /xrpc/social.coves.feed.getDiscover?sort=hot&limit=15&cursor=...

     

       26
       26
       -
       // Public endpoint - no authentication required

     

       30
       30
       +
       // Public endpoint with optional auth - if authenticated, includes viewer vote state

     

       27
       31
        
       func (h *GetDiscoverHandler) HandleGetDiscover(w http.ResponseWriter, r *http.Request) {

     

       28
       32
        
       	if r.Method != http.MethodGet {

     

       29
       33
        
       		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)

     
···

       40
       44
        
       		return

     

       41
       45
        
       	}

     

       42
       46
        
       

     

       47
       47
       +
       	// Populate viewer vote state if authenticated

     

       48
       48
       +
       	common.PopulateViewerVoteState(r.Context(), r, h.voteService, response.Feed)

     

       49
       49
       +
       

     

       43
       50
        
       	// Transform blob refs to URLs for all posts

     

       44
       51
        
       	for _, feedPost := range response.Feed {

     

       45
       52
        
       		if feedPost.Post != nil {

+3 -34

internal/api/handlers/timeline/get_timeline.go

···

       1
       1
        
       package timeline

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/api/handlers/common"

     

       4
       5
        
       	"Coves/internal/api/middleware"

     

       5
       6
        
       	"Coves/internal/core/posts"

     

       6
       7
        
       	"Coves/internal/core/timeline"

     
···

       56
       57
        
       		return

     

       57
       58
        
       	}

     

       58
       59
        
       

     

       59
       59
       -
       	// Populate viewer vote state if authenticated and vote service available

     

       60
       60
       -
       	if h.voteService != nil {

     

       61
       61
       -
       		session := middleware.GetOAuthSession(r)

     

       62
       62
       -
       		if session != nil {

     

       63
       63
       -
       			// Ensure vote cache is populated from PDS

     

       64
       64
       -
       			if err := h.voteService.EnsureCachePopulated(r.Context(), session); err != nil {

     

       65
       65
       -
       				// Log but don't fail - viewer state is optional

     

       66
       66
       -
       				log.Printf("Warning: failed to populate vote cache: %v", err)

     

       67
       67
       -
       			} else {

     

       68
       68
       -
       				// Collect post URIs to batch lookup

     

       69
       69
       -
       				postURIs := make([]string, 0, len(response.Feed))

     

       70
       70
       -
       				for _, feedPost := range response.Feed {

     

       71
       71
       -
       					if feedPost.Post != nil {

     

       72
       72
       -
       						postURIs = append(postURIs, feedPost.Post.URI)

     

       73
       73
       -
       					}

     

       74
       74
       -
       				}

     

       75
       75
       -
       

     

       76
       76
       -
       				// Get viewer votes for all posts

     

       77
       77
       -
       				viewerVotes := h.voteService.GetViewerVotesForSubjects(userDID, postURIs)

     

       78
       78
       -
       

     

       79
       79
       -
       				// Populate viewer state on each post

     

       80
       80
       -
       				for _, feedPost := range response.Feed {

     

       81
       81
       -
       					if feedPost.Post != nil {

     

       82
       82
       -
       						if vote, exists := viewerVotes[feedPost.Post.URI]; exists {

     

       83
       83
       -
       							feedPost.Post.Viewer = &posts.ViewerState{

     

       84
       84
       -
       								Vote:    &vote.Direction,

     

       85
       85
       -
       								VoteURI: &vote.URI,

     

       86
       86
       -
       							}

     

       87
       87
       -
       						}

     

       88
       88
       -
       					}

     

       89
       89
       -
       				}

     

       90
       90
       -
       			}

     

       91
       91
       -
       		}

     

       92
       92
       -
       	}

     

       60
       60
       +
       	// Populate viewer vote state if authenticated

     

       61
       61
       +
       	common.PopulateViewerVoteState(r.Context(), r, h.voteService, response.Feed)

     

       93
       62
        
       

     

       94
       63
        
       	// Transform blob refs to URLs for all posts

     

       95
       64
        
       	for _, feedPost := range response.Feed {

+9 -4

internal/api/routes/discover.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"Coves/internal/api/handlers/discover"

     

       5
       5
       +
       	"Coves/internal/api/middleware"

     

       5
       6
        
       	discoverCore "Coves/internal/core/discover"

     

       7
       7
       +
       	"Coves/internal/core/votes"

     

       6
       8
        
       

     

       7
       9
        
       	"github.com/go-chi/chi/v5"

     

       8
       10
        
       )

     
···

       10
       12
        
       // RegisterDiscoverRoutes registers discover-related XRPC endpoints

     

       11
       13
        
       //

     

       12
       14
        
       // SECURITY & RATE LIMITING:

     

       13
       13
       -
       // - Discover feed is PUBLIC (no authentication required)

     

       15
       15
       +
       // - Discover feed is PUBLIC (works without authentication)

     

       16
       16
       +
       // - Optional auth: if authenticated, includes viewer vote state on posts

     

       14
       17
        
       // - Protected by global rate limiter: 100 requests/minute per IP (main.go:84)

     

       15
       18
        
       // - Query timeout enforced via context (prevents long-running queries)

     

       16
       19
        
       // - Result limit capped at 50 posts per request (validated in service layer)

     
···

       18
       21
        
       func RegisterDiscoverRoutes(

     

       19
       22
        
       	r chi.Router,

     

       20
       23
        
       	discoverService discoverCore.Service,

     

       24
       24
       +
       	voteService votes.Service,

     

       25
       25
       +
       	authMiddleware *middleware.OAuthAuthMiddleware,

     

       21
       26
        
       ) {

     

       22
       27
        
       	// Create handlers

     

       23
       23
       -
       	getDiscoverHandler := discover.NewGetDiscoverHandler(discoverService)

     

       28
       28
       +
       	getDiscoverHandler := discover.NewGetDiscoverHandler(discoverService, voteService)

     

       24
       29
        
       

     

       25
       30
        
       	// GET /xrpc/social.coves.feed.getDiscover

     

       26
       26
       -
       	// Public endpoint - no authentication required

     

       31
       31
       +
       	// Public endpoint with optional auth for viewer-specific state (vote state)

     

       27
       32
        
       	// Shows posts from ALL communities (not personalized)

     

       28
       33
        
       	// Rate limited: 100 req/min per IP via global middleware

     

       29
       29
       -
       	r.Get("/xrpc/social.coves.feed.getDiscover", getDiscoverHandler.HandleGetDiscover)

     

       34
       34
       +
       	r.With(authMiddleware.OptionalAuth).Get("/xrpc/social.coves.feed.getDiscover", getDiscoverHandler.HandleGetDiscover)

     

       30
       35
        
       }

internal/core/communityFeeds/types.go

···

       31
       31
        
       	Reply  *ReplyRef       `json:"reply,omitempty"`  // Reply context

     

       32
       32
        
       }

     

       33
       33
        
       

     

       34
       34
       +
       // GetPost returns the underlying PostView for viewer state enrichment

     

       35
       35
       +
       func (f *FeedViewPost) GetPost() *posts.PostView {

     

       36
       36
       +
       	return f.Post

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       34
       39
        
       // FeedReason is a union type for feed context

     

       35
       40
        
       // Can be reasonRepost or reasonPin

     

       36
       41
        
       type FeedReason struct {

internal/core/discover/types.go

···

       39
       39
        
       	Reply  *ReplyRef       `json:"reply,omitempty"`

     

       40
       40
        
       }

     

       41
       41
        
       

     

       42
       42
       +
       // GetPost returns the underlying PostView for viewer state enrichment

     

       43
       43
       +
       func (f *FeedViewPost) GetPost() *posts.PostView {

     

       44
       44
       +
       	return f.Post

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       42
       47
        
       // FeedReason is a union type for feed context

     

       43
       48
        
       type FeedReason struct {

     

       44
       49
        
       	Repost    *ReasonRepost    `json:"-"`

internal/core/timeline/types.go

···

       42
       42
        
       	Reply  *ReplyRef       `json:"reply,omitempty"`  // Reply context

     

       43
       43
        
       }

     

       44
       44
        
       

     

       45
       45
       +
       // GetPost returns the underlying PostView for viewer state enrichment

     

       46
       46
       +
       func (f *FeedViewPost) GetPost() *posts.PostView {

     

       47
       47
       +
       	return f.Post

     

       48
       48
       +
       }

     

       49
       49
       +
       

     

       45
       50
        
       // FeedReason is a union type for feed context

     

       46
       51
        
       // Future: Can be reasonRepost or reasonCommunity

     

       47
       52
        
       type FeedReason struct {

+193 -5

tests/integration/discover_test.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"Coves/internal/api/handlers/discover"

     

       5
       5
       +
       	"Coves/internal/api/middleware"

     

       6
       6
       +
       	"Coves/internal/core/votes"

     

       5
       7
        
       	"Coves/internal/db/postgres"

     

       6
       8
        
       	"context"

     

       7
       9
        
       	"encoding/json"

     
···

       13
       15
        
       

     

       14
       16
        
       	discoverCore "Coves/internal/core/discover"

     

       15
       17
        
       

     

       18
       18
       +
       	oauthlib "github.com/bluesky-social/indigo/atproto/auth/oauth"

     

       19
       19
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       16
       20
        
       	"github.com/stretchr/testify/assert"

     

       17
       21
        
       	"github.com/stretchr/testify/require"

     

       18
       22
        
       )

     

       19
       23
        
       

     

       24
       24
       +
       // mockVoteService implements votes.Service for testing viewer vote state

     

       25
       25
       +
       type mockVoteService struct {

     

       26
       26
       +
       	cachedVotes map[string]*votes.CachedVote // userDID:subjectURI -> vote

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       func newMockVoteService() *mockVoteService {

     

       30
       30
       +
       	return &mockVoteService{

     

       31
       31
       +
       		cachedVotes: make(map[string]*votes.CachedVote),

     

       32
       32
       +
       	}

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       func (m *mockVoteService) AddVote(userDID, subjectURI, direction, voteURI string) {

     

       36
       36
       +
       	key := userDID + ":" + subjectURI

     

       37
       37
       +
       	m.cachedVotes[key] = &votes.CachedVote{

     

       38
       38
       +
       		Direction: direction,

     

       39
       39
       +
       		URI:       voteURI,

     

       40
       40
       +
       	}

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       func (m *mockVoteService) CreateVote(_ context.Context, _ *oauthlib.ClientSessionData, _ votes.CreateVoteRequest) (*votes.CreateVoteResponse, error) {

     

       44
       44
       +
       	return &votes.CreateVoteResponse{}, nil

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       func (m *mockVoteService) DeleteVote(_ context.Context, _ *oauthlib.ClientSessionData, _ votes.DeleteVoteRequest) error {

     

       48
       48
       +
       	return nil

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       func (m *mockVoteService) EnsureCachePopulated(_ context.Context, _ *oauthlib.ClientSessionData) error {

     

       52
       52
       +
       	return nil // Mock always succeeds - votes pre-populated via AddVote

     

       53
       53
       +
       }

     

       54
       54
       +
       

     

       55
       55
       +
       func (m *mockVoteService) GetViewerVote(userDID, subjectURI string) *votes.CachedVote {

     

       56
       56
       +
       	key := userDID + ":" + subjectURI

     

       57
       57
       +
       	return m.cachedVotes[key]

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       func (m *mockVoteService) GetViewerVotesForSubjects(userDID string, subjectURIs []string) map[string]*votes.CachedVote {

     

       61
       61
       +
       	result := make(map[string]*votes.CachedVote)

     

       62
       62
       +
       	for _, uri := range subjectURIs {

     

       63
       63
       +
       		key := userDID + ":" + uri

     

       64
       64
       +
       		if vote, exists := m.cachedVotes[key]; exists {

     

       65
       65
       +
       			result[uri] = vote

     

       66
       66
       +
       		}

     

       67
       67
       +
       	}

     

       68
       68
       +
       	return result

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       20
       71
        
       // TestGetDiscover_ShowsAllCommunities tests discover feed shows posts from ALL communities

     

       21
       72
        
       func TestGetDiscover_ShowsAllCommunities(t *testing.T) {

     

       22
       73
        
       	if testing.Short() {

     
···

       29
       80
        
       	// Setup services

     

       30
       81
        
       	discoverRepo := postgres.NewDiscoverRepository(db, "test-cursor-secret")

     

       31
       82
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       32
       32
       -
       	handler := discover.NewGetDiscoverHandler(discoverService)

     

       83
       83
       +
       	handler := discover.NewGetDiscoverHandler(discoverService, nil) // nil vote service - tests don't need vote state

     

       33
       84
        
       

     

       34
       85
        
       	ctx := context.Background()

     

       35
       86
        
       	testID := time.Now().UnixNano()

     
···

       100
       151
        
       	// Setup services

     

       101
       152
        
       	discoverRepo := postgres.NewDiscoverRepository(db, "test-cursor-secret")

     

       102
       153
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       103
       103
       -
       	handler := discover.NewGetDiscoverHandler(discoverService)

     

       154
       154
       +
       	handler := discover.NewGetDiscoverHandler(discoverService, nil) // nil vote service - tests don't need vote state

     

       104
       155
        
       

     

       105
       156
        
       	ctx := context.Background()

     

       106
       157
        
       	testID := time.Now().UnixNano()

     
···

       147
       198
        
       	// Setup services

     

       148
       199
        
       	discoverRepo := postgres.NewDiscoverRepository(db, "test-cursor-secret")

     

       149
       200
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       150
       150
       -
       	handler := discover.NewGetDiscoverHandler(discoverService)

     

       201
       201
       +
       	handler := discover.NewGetDiscoverHandler(discoverService, nil)

     

       151
       202
        
       

     

       152
       203
        
       	ctx := context.Background()

     

       153
       204
        
       	testID := time.Now().UnixNano()

     
···

       197
       248
        
       	// Setup services

     

       198
       249
        
       	discoverRepo := postgres.NewDiscoverRepository(db, "test-cursor-secret")

     

       199
       250
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       200
       200
       -
       	handler := discover.NewGetDiscoverHandler(discoverService)

     

       251
       251
       +
       	handler := discover.NewGetDiscoverHandler(discoverService, nil)

     

       201
       252
        
       

     

       202
       253
        
       	ctx := context.Background()

     

       203
       254
        
       	testID := time.Now().UnixNano()

     
···

       254
       305
        
       	// Setup services

     

       255
       306
        
       	discoverRepo := postgres.NewDiscoverRepository(db, "test-cursor-secret")

     

       256
       307
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       257
       257
       -
       	handler := discover.NewGetDiscoverHandler(discoverService)

     

       308
       308
       +
       	handler := discover.NewGetDiscoverHandler(discoverService, nil)

     

       258
       309
        
       

     

       259
       310
        
       	t.Run("Limit exceeds maximum", func(t *testing.T) {

     

       260
       311
        
       		req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.feed.getDiscover?sort=new&limit=100", nil)

     
···

       271
       322
        
       		assert.Contains(t, errorResp["message"], "limit")

     

       272
       323
        
       	})

     

       273
       324
        
       }

     

       325
       325
       +
       

     

       326
       326
       +
       // TestGetDiscover_ViewerVoteState tests that authenticated users see their vote state on posts

     

       327
       327
       +
       func TestGetDiscover_ViewerVoteState(t *testing.T) {

     

       328
       328
       +
       	if testing.Short() {

     

       329
       329
       +
       		t.Skip("Skipping integration test in short mode")

     

       330
       330
       +
       	}

     

       331
       331
       +
       

     

       332
       332
       +
       	db := setupTestDB(t)

     

       333
       333
       +
       	t.Cleanup(func() { _ = db.Close() })

     

       334
       334
       +
       

     

       335
       335
       +
       	ctx := context.Background()

     

       336
       336
       +
       	testID := time.Now().UnixNano()

     

       337
       337
       +
       

     

       338
       338
       +
       	// Create community and posts

     

       339
       339
       +
       	communityDID, err := createFeedTestCommunity(db, ctx, fmt.Sprintf("votes-%d", testID), fmt.Sprintf("alice-%d.test", testID))

     

       340
       340
       +
       	require.NoError(t, err)

     

       341
       341
       +
       

     

       342
       342
       +
       	post1URI := createTestPost(t, db, communityDID, "did:plc:author1", "Post with upvote", 10, time.Now().Add(-1*time.Hour))

     

       343
       343
       +
       	post2URI := createTestPost(t, db, communityDID, "did:plc:author2", "Post with downvote", 5, time.Now().Add(-2*time.Hour))

     

       344
       344
       +
       	_ = createTestPost(t, db, communityDID, "did:plc:author3", "Post without vote", 3, time.Now().Add(-3*time.Hour))

     

       345
       345
       +
       

     

       346
       346
       +
       	// Setup mock vote service with pre-populated votes

     

       347
       347
       +
       	viewerDID := "did:plc:viewer123"

     

       348
       348
       +
       	mockVotes := newMockVoteService()

     

       349
       349
       +
       	mockVotes.AddVote(viewerDID, post1URI, "up", "at://"+viewerDID+"/social.coves.vote/vote1")

     

       350
       350
       +
       	mockVotes.AddVote(viewerDID, post2URI, "down", "at://"+viewerDID+"/social.coves.vote/vote2")

     

       351
       351
       +
       

     

       352
       352
       +
       	// Setup handler with mock vote service

     

       353
       353
       +
       	discoverRepo := postgres.NewDiscoverRepository(db, "test-cursor-secret")

     

       354
       354
       +
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       355
       355
       +
       	handler := discover.NewGetDiscoverHandler(discoverService, mockVotes)

     

       356
       356
       +
       

     

       357
       357
       +
       	// Create request with authenticated user context

     

       358
       358
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.feed.getDiscover?sort=new&limit=50", nil)

     

       359
       359
       +
       

     

       360
       360
       +
       	// Inject OAuth session into context (simulates OptionalAuth middleware)

     

       361
       361
       +
       	did, _ := syntax.ParseDID(viewerDID)

     

       362
       362
       +
       	session := &oauthlib.ClientSessionData{

     

       363
       363
       +
       		AccountDID:  did,

     

       364
       364
       +
       		AccessToken: "test_token",

     

       365
       365
       +
       	}

     

       366
       366
       +
       	reqCtx := context.WithValue(req.Context(), middleware.UserDIDKey, viewerDID)

     

       367
       367
       +
       	reqCtx = context.WithValue(reqCtx, middleware.OAuthSessionKey, session)

     

       368
       368
       +
       	req = req.WithContext(reqCtx)

     

       369
       369
       +
       

     

       370
       370
       +
       	rec := httptest.NewRecorder()

     

       371
       371
       +
       	handler.HandleGetDiscover(rec, req)

     

       372
       372
       +
       

     

       373
       373
       +
       	// Assertions

     

       374
       374
       +
       	assert.Equal(t, http.StatusOK, rec.Code)

     

       375
       375
       +
       

     

       376
       376
       +
       	var response discoverCore.DiscoverResponse

     

       377
       377
       +
       	err = json.Unmarshal(rec.Body.Bytes(), &response)

     

       378
       378
       +
       	require.NoError(t, err)

     

       379
       379
       +
       

     

       380
       380
       +
       	// Find our test posts and verify vote state

     

       381
       381
       +
       	var foundPost1, foundPost2, foundPost3 bool

     

       382
       382
       +
       	for _, feedPost := range response.Feed {

     

       383
       383
       +
       		switch feedPost.Post.URI {

     

       384
       384
       +
       		case post1URI:

     

       385
       385
       +
       			foundPost1 = true

     

       386
       386
       +
       			require.NotNil(t, feedPost.Post.Viewer, "Post1 should have viewer state")

     

       387
       387
       +
       			require.NotNil(t, feedPost.Post.Viewer.Vote, "Post1 should have vote direction")

     

       388
       388
       +
       			assert.Equal(t, "up", *feedPost.Post.Viewer.Vote, "Post1 should show upvote")

     

       389
       389
       +
       			require.NotNil(t, feedPost.Post.Viewer.VoteURI, "Post1 should have vote URI")

     

       390
       390
       +
       			assert.Contains(t, *feedPost.Post.Viewer.VoteURI, "vote1", "Post1 should have correct vote URI")

     

       391
       391
       +
       

     

       392
       392
       +
       		case post2URI:

     

       393
       393
       +
       			foundPost2 = true

     

       394
       394
       +
       			require.NotNil(t, feedPost.Post.Viewer, "Post2 should have viewer state")

     

       395
       395
       +
       			require.NotNil(t, feedPost.Post.Viewer.Vote, "Post2 should have vote direction")

     

       396
       396
       +
       			assert.Equal(t, "down", *feedPost.Post.Viewer.Vote, "Post2 should show downvote")

     

       397
       397
       +
       			require.NotNil(t, feedPost.Post.Viewer.VoteURI, "Post2 should have vote URI")

     

       398
       398
       +
       

     

       399
       399
       +
       		default:

     

       400
       400
       +
       			// Posts without votes should have nil Viewer or nil Vote

     

       401
       401
       +
       			if feedPost.Post.Viewer != nil && feedPost.Post.Viewer.Vote != nil {

     

       402
       402
       +
       				// This post has a vote from our viewer - it's not post3

     

       403
       403
       +
       				continue

     

       404
       404
       +
       			}

     

       405
       405
       +
       			foundPost3 = true

     

       406
       406
       +
       		}

     

       407
       407
       +
       	}

     

       408
       408
       +
       

     

       409
       409
       +
       	assert.True(t, foundPost1, "Should find post1 with upvote")

     

       410
       410
       +
       	assert.True(t, foundPost2, "Should find post2 with downvote")

     

       411
       411
       +
       	assert.True(t, foundPost3, "Should find post3 without vote")

     

       412
       412
       +
       }

     

       413
       413
       +
       

     

       414
       414
       +
       // TestGetDiscover_NoViewerStateWithoutAuth tests that unauthenticated users don't get viewer state

     

       415
       415
       +
       func TestGetDiscover_NoViewerStateWithoutAuth(t *testing.T) {

     

       416
       416
       +
       	if testing.Short() {

     

       417
       417
       +
       		t.Skip("Skipping integration test in short mode")

     

       418
       418
       +
       	}

     

       419
       419
       +
       

     

       420
       420
       +
       	db := setupTestDB(t)

     

       421
       421
       +
       	t.Cleanup(func() { _ = db.Close() })

     

       422
       422
       +
       

     

       423
       423
       +
       	ctx := context.Background()

     

       424
       424
       +
       	testID := time.Now().UnixNano()

     

       425
       425
       +
       

     

       426
       426
       +
       	// Create community and post

     

       427
       427
       +
       	communityDID, err := createFeedTestCommunity(db, ctx, fmt.Sprintf("noauth-%d", testID), fmt.Sprintf("alice-%d.test", testID))

     

       428
       428
       +
       	require.NoError(t, err)

     

       429
       429
       +
       

     

       430
       430
       +
       	postURI := createTestPost(t, db, communityDID, "did:plc:author", "Some post", 10, time.Now())

     

       431
       431
       +
       

     

       432
       432
       +
       	// Setup mock vote service with a vote (but request will be unauthenticated)

     

       433
       433
       +
       	mockVotes := newMockVoteService()

     

       434
       434
       +
       	mockVotes.AddVote("did:plc:someuser", postURI, "up", "at://did:plc:someuser/social.coves.vote/vote1")

     

       435
       435
       +
       

     

       436
       436
       +
       	// Setup handler with mock vote service

     

       437
       437
       +
       	discoverRepo := postgres.NewDiscoverRepository(db, "test-cursor-secret")

     

       438
       438
       +
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       439
       439
       +
       	handler := discover.NewGetDiscoverHandler(discoverService, mockVotes)

     

       440
       440
       +
       

     

       441
       441
       +
       	// Create request WITHOUT auth context

     

       442
       442
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.feed.getDiscover?sort=new&limit=50", nil)

     

       443
       443
       +
       	rec := httptest.NewRecorder()

     

       444
       444
       +
       	handler.HandleGetDiscover(rec, req)

     

       445
       445
       +
       

     

       446
       446
       +
       	// Should succeed

     

       447
       447
       +
       	assert.Equal(t, http.StatusOK, rec.Code)

     

       448
       448
       +
       

     

       449
       449
       +
       	var response discoverCore.DiscoverResponse

     

       450
       450
       +
       	err = json.Unmarshal(rec.Body.Bytes(), &response)

     

       451
       451
       +
       	require.NoError(t, err)

     

       452
       452
       +
       

     

       453
       453
       +
       	// Find our post and verify NO viewer state (unauthenticated)

     

       454
       454
       +
       	for _, feedPost := range response.Feed {

     

       455
       455
       +
       		if feedPost.Post.URI == postURI {

     

       456
       456
       +
       			assert.Nil(t, feedPost.Post.Viewer, "Unauthenticated request should not have viewer state")

     

       457
       457
       +
       			return

     

       458
       458
       +
       		}

     

       459
       459
       +
       	}

     

       460
       460
       +
       	t.Fatal("Test post not found in response")

     

       461
       461
       +
       }

+11 -11

tests/integration/feed_test.go

···

       37
       37
        
       		nil,

     

       38
       38
        
       	)

     

       39
       39
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       40
       40
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       40
       40
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       41
       41
        
       

     

       42
       42
        
       	// Setup test data: community, users, and posts

     

       43
       43
        
       	ctx := context.Background()

     
···

       114
       114
        
       		nil,

     

       115
       115
        
       	)

     

       116
       116
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       117
       117
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       117
       117
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       118
       118
        
       

     

       119
       119
        
       	// Setup test data

     

       120
       120
        
       	ctx := context.Background()

     
···

       190
       190
        
       		nil,

     

       191
       191
        
       	)

     

       192
       192
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       193
       193
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       193
       193
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       194
       194
        
       

     

       195
       195
        
       	// Setup test data

     

       196
       196
        
       	ctx := context.Background()

     
···

       246
       246
        
       		nil,

     

       247
       247
        
       	)

     

       248
       248
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       249
       249
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       249
       249
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       250
       250
        
       

     

       251
       251
        
       	// Setup test data with many posts

     

       252
       252
        
       	ctx := context.Background()

     
···

       337
       337
        
       		nil,

     

       338
       338
        
       	)

     

       339
       339
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       340
       340
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       340
       340
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       341
       341
        
       

     

       342
       342
        
       	// Request feed for non-existent community

     

       343
       343
        
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.communityFeed.getCommunity?community=did:plc:nonexistent&sort=hot&limit=10", nil)

     
···

       373
       373
        
       		nil,

     

       374
       374
        
       	)

     

       375
       375
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       376
       376
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       376
       376
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       377
       377
        
       

     

       378
       378
        
       	// Setup test community

     

       379
       379
        
       	ctx := context.Background()

     
···

       429
       429
        
       		nil,

     

       430
       430
        
       	)

     

       431
       431
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       432
       432
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       432
       432
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       433
       433
        
       

     

       434
       434
        
       	// Create community with no posts

     

       435
       435
        
       	ctx := context.Background()

     
···

       473
       473
        
       		nil,

     

       474
       474
        
       	)

     

       475
       475
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       476
       476
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       476
       476
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       477
       477
        
       

     

       478
       478
        
       	// Setup test community

     

       479
       479
        
       	ctx := context.Background()

     
···

       526
       526
        
       		nil,

     

       527
       527
        
       	)

     

       528
       528
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       529
       529
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       529
       529
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       530
       530
        
       

     

       531
       531
        
       	// Setup test data

     

       532
       532
        
       	ctx := context.Background()

     
···

       627
       627
        
       		nil,

     

       628
       628
        
       	)

     

       629
       629
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       630
       630
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       630
       630
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       631
       631
        
       

     

       632
       632
        
       	// Setup test data

     

       633
       633
        
       	ctx := context.Background()

     
···

       720
       720
        
       		nil,

     

       721
       721
        
       	)

     

       722
       722
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       723
       723
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       723
       723
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       724
       724
        
       

     

       725
       725
        
       	// Setup test data

     

       726
       726
        
       	ctx := context.Background()

+7 -7

tests/integration/timeline_test.go

···

       30
       30
        
       	// Setup services

     

       31
       31
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       32
       32
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       33
       33
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       33
       33
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       34
       34
        
       

     

       35
       35
        
       	ctx := context.Background()

     

       36
       36
        
       	testID := time.Now().UnixNano()

     
···

       119
       119
        
       	// Setup services

     

       120
       120
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       121
       121
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       122
       122
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       122
       122
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       123
       123
        
       

     

       124
       124
        
       	ctx := context.Background()

     

       125
       125
        
       	testID := time.Now().UnixNano()

     
···

       190
       190
        
       	// Setup services

     

       191
       191
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       192
       192
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       193
       193
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       193
       193
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       194
       194
        
       

     

       195
       195
        
       	ctx := context.Background()

     

       196
       196
        
       	testID := time.Now().UnixNano()

     
···

       266
       266
        
       	// Setup services

     

       267
       267
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       268
       268
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       269
       269
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       269
       269
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       270
       270
        
       

     

       271
       271
        
       	ctx := context.Background()

     

       272
       272
        
       	testID := time.Now().UnixNano()

     
···

       308
       308
        
       	// Setup services

     

       309
       309
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       310
       310
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       311
       311
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       311
       311
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       312
       312
        
       

     

       313
       313
        
       	// Request timeline WITHOUT auth context

     

       314
       314
        
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.feed.getTimeline?sort=new&limit=10", nil)

     
···

       337
       337
        
       	// Setup services

     

       338
       338
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       339
       339
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       340
       340
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       340
       340
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       341
       341
        
       

     

       342
       342
        
       	ctx := context.Background()

     

       343
       343
        
       	testID := time.Now().UnixNano()

     
···

       388
       388
        
       	// Setup services

     

       389
       389
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       390
       390
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       391
       391
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       391
       391
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       392
       392
        
       

     

       393
       393
        
       	ctx := context.Background()

     

       394
       394
        
       	testID := time.Now().UnixNano()

+1 -1

tests/integration/user_journey_e2e_test.go

···

       143
       143
        
       	r := chi.NewRouter()

     

       144
       144
        
       	routes.RegisterCommunityRoutes(r, communityService, e2eAuth.OAuthAuthMiddleware, nil) // nil = allow all community creators

     

       145
       145
        
       	routes.RegisterPostRoutes(r, postService, e2eAuth.OAuthAuthMiddleware)

     

       146
       146
       -
       	routes.RegisterTimelineRoutes(r, timelineService, e2eAuth.OAuthAuthMiddleware)

     

       146
       146
       +
       	routes.RegisterTimelineRoutes(r, timelineService, nil, e2eAuth.OAuthAuthMiddleware)

     

       147
       147
        
       	httpServer := httptest.NewServer(r)

     

       148
       148
        
       	defer httpServer.Close()

     

       149
       149

Compare changes