bretton.dev
A community based topic aggregation platform built on atproto
feat(actor): implement social.coves.actor.getPosts endpoint
Add complete implementation for retrieving a user's posts by DID or handle:
- New XRPC endpoint: GET /xrpc/social.coves.actor.getPosts
- Handle resolution with local DB fallback (faster for indexed users)
- Filters: posts_with_replies, posts_no_replies, posts_with_media
- Community-scoped filtering
- Cursor-based pagination with proper duplicate prevention
- Viewer vote state population (when authenticated)
- Bluesky post embed resolution
Key improvements:
- ResolveHandleToDID now checks local DB first before external DNS/HTTPS
- Proper error distinction: actorNotFoundError vs resolutionFailedError
- Infrastructure failures (DB down, DNS errors) return 500, not 404
Includes comprehensive E2E tests against live PDS infrastructure.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+4
cmd/server/main.go
+4
cmd/server/main.go
···
630
630
routes.RegisterDiscoverRoutes(r, discoverService, voteService, blueskyService, authMiddleware)
631
631
log.Println("Discover XRPC endpoints registered (public with optional auth for viewer vote state)")
632
632
633
+
routes.RegisterActorRoutes(r, postService, userService, voteService, blueskyService, authMiddleware)
634
+
log.Println("Actor XRPC endpoints registered (public with optional auth for viewer vote state)")
635
+
log.Println(" - GET /xrpc/social.coves.actor.getPosts")
636
+
633
637
routes.RegisterAggregatorRoutes(r, aggregatorService, communityService, userService, identityResolver)
634
638
log.Println("Aggregator XRPC endpoints registered (query endpoints public, registration endpoint public)")
635
639
+94
internal/api/handlers/actor/errors.go
+94
internal/api/handlers/actor/errors.go
···
1
+
package actor
2
+
3
+
import (
4
+
"encoding/json"
5
+
"errors"
6
+
"fmt"
7
+
"log"
8
+
"net/http"
9
+
10
+
"Coves/internal/core/posts"
11
+
)
12
+
13
+
// ErrorResponse represents an XRPC error response
14
+
type ErrorResponse struct {
15
+
Error string `json:"error"`
16
+
Message string `json:"message"`
17
+
}
18
+
19
+
// writeError writes a JSON error response
20
+
func writeError(w http.ResponseWriter, statusCode int, errorType, message string) {
21
+
w.Header().Set("Content-Type", "application/json")
22
+
w.WriteHeader(statusCode)
23
+
if err := json.NewEncoder(w).Encode(ErrorResponse{
24
+
Error: errorType,
25
+
Message: message,
26
+
}); err != nil {
27
+
// Log encoding errors but can't send error response (headers already sent)
28
+
log.Printf("ERROR: Failed to encode error response: %v", err)
29
+
}
30
+
}
31
+
32
+
// handleServiceError maps service errors to HTTP responses
33
+
func handleServiceError(w http.ResponseWriter, err error) {
34
+
// Check for handler-level errors first
35
+
var actorNotFound *actorNotFoundError
36
+
if errors.As(err, &actorNotFound) {
37
+
writeError(w, http.StatusNotFound, "ActorNotFound", "Actor not found")
38
+
return
39
+
}
40
+
41
+
// Check for service-level errors
42
+
switch {
43
+
case errors.Is(err, posts.ErrNotFound):
44
+
writeError(w, http.StatusNotFound, "ActorNotFound", "Actor not found")
45
+
46
+
case errors.Is(err, posts.ErrActorNotFound):
47
+
writeError(w, http.StatusNotFound, "ActorNotFound", "Actor not found")
48
+
49
+
case errors.Is(err, posts.ErrCommunityNotFound):
50
+
writeError(w, http.StatusNotFound, "CommunityNotFound", "Community not found")
51
+
52
+
case errors.Is(err, posts.ErrInvalidCursor):
53
+
writeError(w, http.StatusBadRequest, "InvalidCursor", "Invalid pagination cursor")
54
+
55
+
case posts.IsValidationError(err):
56
+
// Extract message from ValidationError for cleaner response
57
+
var valErr *posts.ValidationError
58
+
if errors.As(err, &valErr) {
59
+
writeError(w, http.StatusBadRequest, "InvalidRequest", valErr.Message)
60
+
} else {
61
+
writeError(w, http.StatusBadRequest, "InvalidRequest", err.Error())
62
+
}
63
+
64
+
default:
65
+
// Internal server error - don't leak details
66
+
log.Printf("ERROR: Actor posts service error: %v", err)
67
+
writeError(w, http.StatusInternalServerError, "InternalServerError", "An internal error occurred")
68
+
}
69
+
}
70
+
71
+
// actorNotFoundError represents an actor not found error
72
+
type actorNotFoundError struct {
73
+
actor string
74
+
}
75
+
76
+
func (e *actorNotFoundError) Error() string {
77
+
return fmt.Sprintf("actor not found: %s", e.actor)
78
+
}
79
+
80
+
// resolutionFailedError represents an infrastructure failure during resolution
81
+
// (database down, DNS failures, TLS errors, etc.)
82
+
// This is distinct from actorNotFoundError to avoid masking real problems as "not found"
83
+
type resolutionFailedError struct {
84
+
actor string
85
+
cause error
86
+
}
87
+
88
+
func (e *resolutionFailedError) Error() string {
89
+
return fmt.Sprintf("failed to resolve actor %s: %v", e.actor, e.cause)
90
+
}
91
+
92
+
func (e *resolutionFailedError) Unwrap() error {
93
+
return e.cause
94
+
}
+185
internal/api/handlers/actor/get_posts.go
+185
internal/api/handlers/actor/get_posts.go
···
1
+
package actor
2
+
3
+
import (
4
+
"encoding/json"
5
+
"errors"
6
+
"log"
7
+
"net/http"
8
+
"strconv"
9
+
"strings"
10
+
11
+
"Coves/internal/api/handlers/common"
12
+
"Coves/internal/api/middleware"
13
+
"Coves/internal/core/blueskypost"
14
+
"Coves/internal/core/posts"
15
+
"Coves/internal/core/users"
16
+
"Coves/internal/core/votes"
17
+
)
18
+
19
+
// GetPostsHandler handles actor post retrieval
20
+
type GetPostsHandler struct {
21
+
postService posts.Service
22
+
userService users.UserService
23
+
voteService votes.Service
24
+
blueskyService blueskypost.Service
25
+
}
26
+
27
+
// NewGetPostsHandler creates a new actor posts handler
28
+
func NewGetPostsHandler(
29
+
postService posts.Service,
30
+
userService users.UserService,
31
+
voteService votes.Service,
32
+
blueskyService blueskypost.Service,
33
+
) *GetPostsHandler {
34
+
if blueskyService == nil {
35
+
log.Printf("[ACTOR-HANDLER] WARNING: blueskyService is nil - Bluesky post embeds will not be resolved")
36
+
}
37
+
return &GetPostsHandler{
38
+
postService: postService,
39
+
userService: userService,
40
+
voteService: voteService,
41
+
blueskyService: blueskyService,
42
+
}
43
+
}
44
+
45
+
// HandleGetPosts retrieves posts by an actor (user)
46
+
// GET /xrpc/social.coves.actor.getPosts?actor={did_or_handle}&filter=posts_with_replies&community=...&limit=50&cursor=...
47
+
func (h *GetPostsHandler) HandleGetPosts(w http.ResponseWriter, r *http.Request) {
48
+
if r.Method != http.MethodGet {
49
+
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
50
+
return
51
+
}
52
+
53
+
// Parse query parameters
54
+
req, err := h.parseRequest(r)
55
+
if err != nil {
56
+
// Check if it's an actor not found error (from handle resolution)
57
+
var actorNotFound *actorNotFoundError
58
+
if errors.As(err, &actorNotFound) {
59
+
writeError(w, http.StatusNotFound, "ActorNotFound", "Actor not found")
60
+
return
61
+
}
62
+
writeError(w, http.StatusBadRequest, "InvalidRequest", err.Error())
63
+
return
64
+
}
65
+
66
+
// Get viewer DID for populating viewer state (optional)
67
+
viewerDID := middleware.GetUserDID(r)
68
+
req.ViewerDID = viewerDID
69
+
70
+
// Get actor posts from service
71
+
response, err := h.postService.GetAuthorPosts(r.Context(), req)
72
+
if err != nil {
73
+
handleServiceError(w, err)
74
+
return
75
+
}
76
+
77
+
// Populate viewer vote state if authenticated
78
+
common.PopulateViewerVoteState(r.Context(), r, h.voteService, response.Feed)
79
+
80
+
// Transform blob refs to URLs and resolve post embeds for all posts
81
+
for _, feedPost := range response.Feed {
82
+
if feedPost.Post != nil {
83
+
posts.TransformBlobRefsToURLs(feedPost.Post)
84
+
posts.TransformPostEmbeds(r.Context(), feedPost.Post, h.blueskyService)
85
+
}
86
+
}
87
+
88
+
// Pre-encode response to buffer before writing headers
89
+
// This ensures we can return a proper error if encoding fails
90
+
responseBytes, err := json.Marshal(response)
91
+
if err != nil {
92
+
log.Printf("ERROR: Failed to encode actor posts response: %v", err)
93
+
writeError(w, http.StatusInternalServerError, "InternalServerError", "Failed to encode response")
94
+
return
95
+
}
96
+
97
+
// Return feed
98
+
w.Header().Set("Content-Type", "application/json")
99
+
w.WriteHeader(http.StatusOK)
100
+
if _, err := w.Write(responseBytes); err != nil {
101
+
log.Printf("ERROR: Failed to write actor posts response: %v", err)
102
+
}
103
+
}
104
+
105
+
// parseRequest parses query parameters into GetAuthorPostsRequest
106
+
func (h *GetPostsHandler) parseRequest(r *http.Request) (posts.GetAuthorPostsRequest, error) {
107
+
req := posts.GetAuthorPostsRequest{}
108
+
109
+
// Required: actor (handle or DID)
110
+
actor := r.URL.Query().Get("actor")
111
+
if actor == "" {
112
+
return req, posts.NewValidationError("actor", "actor parameter is required")
113
+
}
114
+
// Validate actor length to prevent DoS via massive strings
115
+
// Max DID length is ~2048 chars (did:plc: is 8 + 24 base32 = 32, but did:web: can be longer)
116
+
// Max handle length is 253 chars (DNS limit)
117
+
const maxActorLength = 2048
118
+
if len(actor) > maxActorLength {
119
+
return req, posts.NewValidationError("actor", "actor parameter exceeds maximum length")
120
+
}
121
+
122
+
// Resolve actor to DID if it's a handle
123
+
actorDID, err := h.resolveActor(r, actor)
124
+
if err != nil {
125
+
return req, err
126
+
}
127
+
req.ActorDID = actorDID
128
+
129
+
// Optional: filter (default: posts_with_replies)
130
+
req.Filter = r.URL.Query().Get("filter")
131
+
132
+
// Optional: community (handle or DID)
133
+
req.Community = r.URL.Query().Get("community")
134
+
135
+
// Optional: limit (default: 50, max: 100)
136
+
if limitStr := r.URL.Query().Get("limit"); limitStr != "" {
137
+
limit, err := strconv.Atoi(limitStr)
138
+
if err != nil {
139
+
return req, posts.NewValidationError("limit", "limit must be a valid integer")
140
+
}
141
+
req.Limit = limit
142
+
}
143
+
144
+
// Optional: cursor
145
+
if cursor := r.URL.Query().Get("cursor"); cursor != "" {
146
+
req.Cursor = &cursor
147
+
}
148
+
149
+
return req, nil
150
+
}
151
+
152
+
// resolveActor converts an actor identifier (handle or DID) to a DID
153
+
func (h *GetPostsHandler) resolveActor(r *http.Request, actor string) (string, error) {
154
+
// If it's already a DID, return it
155
+
if strings.HasPrefix(actor, "did:") {
156
+
return actor, nil
157
+
}
158
+
159
+
// It's a handle - resolve to DID using user service
160
+
did, err := h.userService.ResolveHandleToDID(r.Context(), actor)
161
+
if err != nil {
162
+
// Check for context errors (timeouts, cancellation) - these are infrastructure errors
163
+
if r.Context().Err() != nil {
164
+
log.Printf("WARN: Handle resolution failed due to context error for %s: %v", actor, err)
165
+
return "", &resolutionFailedError{actor: actor, cause: r.Context().Err()}
166
+
}
167
+
168
+
// Check for common "not found" patterns in error message
169
+
errStr := err.Error()
170
+
isNotFound := strings.Contains(errStr, "not found") ||
171
+
strings.Contains(errStr, "no rows") ||
172
+
strings.Contains(errStr, "unable to resolve")
173
+
174
+
if isNotFound {
175
+
return "", &actorNotFoundError{actor: actor}
176
+
}
177
+
178
+
// For other errors (network, database, DNS failures), return infrastructure error
179
+
// This ensures users see "internal error" not "actor not found" for real problems
180
+
log.Printf("WARN: Handle resolution infrastructure failure for %s: %v", actor, err)
181
+
return "", &resolutionFailedError{actor: actor, cause: err}
182
+
}
183
+
184
+
return did, nil
185
+
}
+331
internal/api/handlers/actor/get_posts_test.go
+331
internal/api/handlers/actor/get_posts_test.go
···
1
+
package actor
2
+
3
+
import (
4
+
"context"
5
+
"encoding/json"
6
+
"net/http"
7
+
"net/http/httptest"
8
+
"testing"
9
+
10
+
"Coves/internal/core/blueskypost"
11
+
"Coves/internal/core/posts"
12
+
"Coves/internal/core/users"
13
+
"Coves/internal/core/votes"
14
+
15
+
oauthlib "github.com/bluesky-social/indigo/atproto/auth/oauth"
16
+
)
17
+
18
+
// mockPostService implements posts.Service for testing
19
+
type mockPostService struct {
20
+
getAuthorPostsFunc func(ctx context.Context, req posts.GetAuthorPostsRequest) (*posts.GetAuthorPostsResponse, error)
21
+
}
22
+
23
+
func (m *mockPostService) GetAuthorPosts(ctx context.Context, req posts.GetAuthorPostsRequest) (*posts.GetAuthorPostsResponse, error) {
24
+
if m.getAuthorPostsFunc != nil {
25
+
return m.getAuthorPostsFunc(ctx, req)
26
+
}
27
+
return &posts.GetAuthorPostsResponse{
28
+
Feed: []*posts.FeedViewPost{},
29
+
Cursor: nil,
30
+
}, nil
31
+
}
32
+
33
+
func (m *mockPostService) CreatePost(ctx context.Context, req posts.CreatePostRequest) (*posts.CreatePostResponse, error) {
34
+
return nil, nil
35
+
}
36
+
37
+
// mockUserService implements users.UserService for testing
38
+
type mockUserService struct {
39
+
resolveHandleToDIDFunc func(ctx context.Context, handle string) (string, error)
40
+
}
41
+
42
+
func (m *mockUserService) CreateUser(ctx context.Context, req users.CreateUserRequest) (*users.User, error) {
43
+
return nil, nil
44
+
}
45
+
46
+
func (m *mockUserService) GetUserByDID(ctx context.Context, did string) (*users.User, error) {
47
+
return nil, nil
48
+
}
49
+
50
+
func (m *mockUserService) GetUserByHandle(ctx context.Context, handle string) (*users.User, error) {
51
+
return nil, nil
52
+
}
53
+
54
+
func (m *mockUserService) UpdateHandle(ctx context.Context, did, newHandle string) (*users.User, error) {
55
+
return nil, nil
56
+
}
57
+
58
+
func (m *mockUserService) ResolveHandleToDID(ctx context.Context, handle string) (string, error) {
59
+
if m.resolveHandleToDIDFunc != nil {
60
+
return m.resolveHandleToDIDFunc(ctx, handle)
61
+
}
62
+
return "did:plc:testuser", nil
63
+
}
64
+
65
+
func (m *mockUserService) RegisterAccount(ctx context.Context, req users.RegisterAccountRequest) (*users.RegisterAccountResponse, error) {
66
+
return nil, nil
67
+
}
68
+
69
+
func (m *mockUserService) IndexUser(ctx context.Context, did, handle, pdsURL string) error {
70
+
return nil
71
+
}
72
+
73
+
// mockVoteService implements votes.Service for testing
74
+
type mockVoteService struct{}
75
+
76
+
func (m *mockVoteService) CreateVote(ctx context.Context, session *oauthlib.ClientSessionData, req votes.CreateVoteRequest) (*votes.CreateVoteResponse, error) {
77
+
return nil, nil
78
+
}
79
+
80
+
func (m *mockVoteService) DeleteVote(ctx context.Context, session *oauthlib.ClientSessionData, req votes.DeleteVoteRequest) error {
81
+
return nil
82
+
}
83
+
84
+
func (m *mockVoteService) EnsureCachePopulated(ctx context.Context, session *oauthlib.ClientSessionData) error {
85
+
return nil
86
+
}
87
+
88
+
func (m *mockVoteService) GetViewerVote(userDID, subjectURI string) *votes.CachedVote {
89
+
return nil
90
+
}
91
+
92
+
func (m *mockVoteService) GetViewerVotesForSubjects(userDID string, subjectURIs []string) map[string]*votes.CachedVote {
93
+
return nil
94
+
}
95
+
96
+
// mockBlueskyService implements blueskypost.Service for testing
97
+
type mockBlueskyService struct{}
98
+
99
+
func (m *mockBlueskyService) ResolvePost(ctx context.Context, atURI string) (*blueskypost.BlueskyPostResult, error) {
100
+
return nil, nil
101
+
}
102
+
103
+
func (m *mockBlueskyService) ParseBlueskyURL(ctx context.Context, url string) (string, error) {
104
+
return "", nil
105
+
}
106
+
107
+
func (m *mockBlueskyService) IsBlueskyURL(url string) bool {
108
+
return false
109
+
}
110
+
111
+
func TestGetPostsHandler_Success(t *testing.T) {
112
+
mockPosts := &mockPostService{
113
+
getAuthorPostsFunc: func(ctx context.Context, req posts.GetAuthorPostsRequest) (*posts.GetAuthorPostsResponse, error) {
114
+
return &posts.GetAuthorPostsResponse{
115
+
Feed: []*posts.FeedViewPost{
116
+
{
117
+
Post: &posts.PostView{
118
+
URI: "at://did:plc:testuser/social.coves.community.post/abc123",
119
+
CID: "bafytest123",
120
+
},
121
+
},
122
+
},
123
+
}, nil
124
+
},
125
+
}
126
+
mockUsers := &mockUserService{}
127
+
mockVotes := &mockVoteService{}
128
+
mockBluesky := &mockBlueskyService{}
129
+
130
+
handler := NewGetPostsHandler(mockPosts, mockUsers, mockVotes, mockBluesky)
131
+
132
+
req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getPosts?actor=did:plc:testuser", nil)
133
+
rec := httptest.NewRecorder()
134
+
135
+
handler.HandleGetPosts(rec, req)
136
+
137
+
if rec.Code != http.StatusOK {
138
+
t.Errorf("Expected status 200, got %d", rec.Code)
139
+
}
140
+
141
+
var response posts.GetAuthorPostsResponse
142
+
if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {
143
+
t.Fatalf("Failed to decode response: %v", err)
144
+
}
145
+
146
+
if len(response.Feed) != 1 {
147
+
t.Errorf("Expected 1 post in feed, got %d", len(response.Feed))
148
+
}
149
+
}
150
+
151
+
func TestGetPostsHandler_MissingActorParameter(t *testing.T) {
152
+
handler := NewGetPostsHandler(&mockPostService{}, &mockUserService{}, &mockVoteService{}, &mockBlueskyService{})
153
+
154
+
req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getPosts", nil)
155
+
rec := httptest.NewRecorder()
156
+
157
+
handler.HandleGetPosts(rec, req)
158
+
159
+
if rec.Code != http.StatusBadRequest {
160
+
t.Errorf("Expected status 400, got %d", rec.Code)
161
+
}
162
+
163
+
var response ErrorResponse
164
+
if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {
165
+
t.Fatalf("Failed to decode response: %v", err)
166
+
}
167
+
168
+
if response.Error != "InvalidRequest" {
169
+
t.Errorf("Expected error 'InvalidRequest', got '%s'", response.Error)
170
+
}
171
+
}
172
+
173
+
func TestGetPostsHandler_InvalidLimitParameter(t *testing.T) {
174
+
handler := NewGetPostsHandler(&mockPostService{}, &mockUserService{}, &mockVoteService{}, &mockBlueskyService{})
175
+
176
+
req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getPosts?actor=did:plc:test&limit=abc", nil)
177
+
rec := httptest.NewRecorder()
178
+
179
+
handler.HandleGetPosts(rec, req)
180
+
181
+
if rec.Code != http.StatusBadRequest {
182
+
t.Errorf("Expected status 400, got %d", rec.Code)
183
+
}
184
+
185
+
var response ErrorResponse
186
+
if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {
187
+
t.Fatalf("Failed to decode response: %v", err)
188
+
}
189
+
190
+
if response.Error != "InvalidRequest" {
191
+
t.Errorf("Expected error 'InvalidRequest', got '%s'", response.Error)
192
+
}
193
+
}
194
+
195
+
func TestGetPostsHandler_ActorNotFound(t *testing.T) {
196
+
mockUsers := &mockUserService{
197
+
resolveHandleToDIDFunc: func(ctx context.Context, handle string) (string, error) {
198
+
return "", posts.ErrActorNotFound
199
+
},
200
+
}
201
+
202
+
handler := NewGetPostsHandler(&mockPostService{}, mockUsers, &mockVoteService{}, &mockBlueskyService{})
203
+
204
+
req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getPosts?actor=nonexistent.user", nil)
205
+
rec := httptest.NewRecorder()
206
+
207
+
handler.HandleGetPosts(rec, req)
208
+
209
+
if rec.Code != http.StatusNotFound {
210
+
t.Errorf("Expected status 404, got %d", rec.Code)
211
+
}
212
+
}
213
+
214
+
func TestGetPostsHandler_ActorLengthExceedsMax(t *testing.T) {
215
+
handler := NewGetPostsHandler(&mockPostService{}, &mockUserService{}, &mockVoteService{}, &mockBlueskyService{})
216
+
217
+
// Create an actor parameter that exceeds 2048 characters using valid URL characters
218
+
longActorBytes := make([]byte, 2100)
219
+
for i := range longActorBytes {
220
+
longActorBytes[i] = 'a'
221
+
}
222
+
longActor := "did:plc:" + string(longActorBytes)
223
+
req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getPosts?actor="+longActor, nil)
224
+
rec := httptest.NewRecorder()
225
+
226
+
handler.HandleGetPosts(rec, req)
227
+
228
+
if rec.Code != http.StatusBadRequest {
229
+
t.Errorf("Expected status 400, got %d", rec.Code)
230
+
}
231
+
}
232
+
233
+
func TestGetPostsHandler_InvalidCursor(t *testing.T) {
234
+
mockPosts := &mockPostService{
235
+
getAuthorPostsFunc: func(ctx context.Context, req posts.GetAuthorPostsRequest) (*posts.GetAuthorPostsResponse, error) {
236
+
return nil, posts.ErrInvalidCursor
237
+
},
238
+
}
239
+
240
+
handler := NewGetPostsHandler(mockPosts, &mockUserService{}, &mockVoteService{}, &mockBlueskyService{})
241
+
242
+
req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getPosts?actor=did:plc:test&cursor=invalid", nil)
243
+
rec := httptest.NewRecorder()
244
+
245
+
handler.HandleGetPosts(rec, req)
246
+
247
+
if rec.Code != http.StatusBadRequest {
248
+
t.Errorf("Expected status 400, got %d", rec.Code)
249
+
}
250
+
251
+
var response ErrorResponse
252
+
if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {
253
+
t.Fatalf("Failed to decode response: %v", err)
254
+
}
255
+
256
+
if response.Error != "InvalidCursor" {
257
+
t.Errorf("Expected error 'InvalidCursor', got '%s'", response.Error)
258
+
}
259
+
}
260
+
261
+
func TestGetPostsHandler_MethodNotAllowed(t *testing.T) {
262
+
handler := NewGetPostsHandler(&mockPostService{}, &mockUserService{}, &mockVoteService{}, &mockBlueskyService{})
263
+
264
+
req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.getPosts", nil)
265
+
rec := httptest.NewRecorder()
266
+
267
+
handler.HandleGetPosts(rec, req)
268
+
269
+
if rec.Code != http.StatusMethodNotAllowed {
270
+
t.Errorf("Expected status 405, got %d", rec.Code)
271
+
}
272
+
}
273
+
274
+
func TestGetPostsHandler_HandleResolution(t *testing.T) {
275
+
resolvedDID := ""
276
+
mockPosts := &mockPostService{
277
+
getAuthorPostsFunc: func(ctx context.Context, req posts.GetAuthorPostsRequest) (*posts.GetAuthorPostsResponse, error) {
278
+
resolvedDID = req.ActorDID
279
+
return &posts.GetAuthorPostsResponse{Feed: []*posts.FeedViewPost{}}, nil
280
+
},
281
+
}
282
+
mockUsers := &mockUserService{
283
+
resolveHandleToDIDFunc: func(ctx context.Context, handle string) (string, error) {
284
+
if handle == "test.user" {
285
+
return "did:plc:resolveduser123", nil
286
+
}
287
+
return "", posts.ErrActorNotFound
288
+
},
289
+
}
290
+
291
+
handler := NewGetPostsHandler(mockPosts, mockUsers, &mockVoteService{}, &mockBlueskyService{})
292
+
293
+
req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getPosts?actor=test.user", nil)
294
+
rec := httptest.NewRecorder()
295
+
296
+
handler.HandleGetPosts(rec, req)
297
+
298
+
if rec.Code != http.StatusOK {
299
+
t.Errorf("Expected status 200, got %d", rec.Code)
300
+
}
301
+
302
+
if resolvedDID != "did:plc:resolveduser123" {
303
+
t.Errorf("Expected resolved DID 'did:plc:resolveduser123', got '%s'", resolvedDID)
304
+
}
305
+
}
306
+
307
+
func TestGetPostsHandler_DirectDIDPassthrough(t *testing.T) {
308
+
receivedDID := ""
309
+
mockPosts := &mockPostService{
310
+
getAuthorPostsFunc: func(ctx context.Context, req posts.GetAuthorPostsRequest) (*posts.GetAuthorPostsResponse, error) {
311
+
receivedDID = req.ActorDID
312
+
return &posts.GetAuthorPostsResponse{Feed: []*posts.FeedViewPost{}}, nil
313
+
},
314
+
}
315
+
316
+
handler := NewGetPostsHandler(mockPosts, &mockUserService{}, &mockVoteService{}, &mockBlueskyService{})
317
+
318
+
// When actor is already a DID, it should pass through without resolution
319
+
req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getPosts?actor=did:plc:directuser", nil)
320
+
rec := httptest.NewRecorder()
321
+
322
+
handler.HandleGetPosts(rec, req)
323
+
324
+
if rec.Code != http.StatusOK {
325
+
t.Errorf("Expected status 200, got %d", rec.Code)
326
+
}
327
+
328
+
if receivedDID != "did:plc:directuser" {
329
+
t.Errorf("Expected DID 'did:plc:directuser', got '%s'", receivedDID)
330
+
}
331
+
}
+29
internal/api/routes/actor.go
+29
internal/api/routes/actor.go
···
1
+
package routes
2
+
3
+
import (
4
+
"Coves/internal/api/handlers/actor"
5
+
"Coves/internal/api/middleware"
6
+
"Coves/internal/core/blueskypost"
7
+
"Coves/internal/core/posts"
8
+
"Coves/internal/core/users"
9
+
"Coves/internal/core/votes"
10
+
11
+
"github.com/go-chi/chi/v5"
12
+
)
13
+
14
+
// RegisterActorRoutes registers actor-related XRPC endpoints
15
+
func RegisterActorRoutes(
16
+
r chi.Router,
17
+
postService posts.Service,
18
+
userService users.UserService,
19
+
voteService votes.Service,
20
+
blueskyService blueskypost.Service,
21
+
authMiddleware *middleware.OAuthAuthMiddleware,
22
+
) {
23
+
// Create handlers
24
+
getPostsHandler := actor.NewGetPostsHandler(postService, userService, voteService, blueskyService)
25
+
26
+
// GET /xrpc/social.coves.actor.getPosts
27
+
// Public endpoint with optional auth for viewer-specific state (vote state)
28
+
r.With(authMiddleware.OptionalAuth).Get("/xrpc/social.coves.actor.getPosts", getPostsHandler.HandleGetPosts)
29
+
}
+5
internal/core/comments/comment_service_test.go
+5
internal/core/comments/comment_service_test.go
···
212
212
return nil, posts.NewNotFoundError("post", uri)
213
213
}
214
214
215
+
func (m *mockPostRepo) GetByAuthor(ctx context.Context, req posts.GetAuthorPostsRequest) ([]*posts.PostView, *string, error) {
216
+
// Mock implementation - returns empty for tests
217
+
return nil, nil, nil
218
+
}
219
+
215
220
// mockCommunityRepo is a mock implementation of the communities.Repository interface
216
221
type mockCommunityRepo struct {
217
222
communities map[string]*communities.Community
+6
internal/core/posts/errors.go
+6
internal/core/posts/errors.go
···
25
25
26
26
// ErrRateLimitExceeded is returned when an aggregator exceeds rate limits
27
27
ErrRateLimitExceeded = errors.New("rate limit exceeded")
28
+
29
+
// ErrInvalidCursor is returned when a pagination cursor is malformed
30
+
ErrInvalidCursor = errors.New("invalid pagination cursor")
31
+
32
+
// ErrActorNotFound is returned when the requested actor does not exist
33
+
ErrActorNotFound = errors.New("actor not found")
28
34
)
29
35
30
36
// ValidationError represents a validation error with field context
+10
internal/core/posts/interfaces.go
+10
internal/core/posts/interfaces.go
···
16
16
// AppView indexing happens asynchronously via Jetstream consumer
17
17
CreatePost(ctx context.Context, req CreatePostRequest) (*CreatePostResponse, error)
18
18
19
+
// GetAuthorPosts retrieves posts authored by a specific user for their profile page
20
+
// Supports filtering by post type (with/without replies, media only) and community
21
+
// Returns paginated feed with cursor
22
+
GetAuthorPosts(ctx context.Context, req GetAuthorPostsRequest) (*GetAuthorPostsResponse, error)
23
+
19
24
// Future methods (Beta):
20
25
// GetPost(ctx context.Context, uri string, viewerDID *string) (*Post, error)
21
26
// UpdatePost(ctx context.Context, req UpdatePostRequest) (*Post, error)
···
33
38
// GetByURI retrieves a post by its AT-URI
34
39
// Used for E2E test verification and future GET endpoint
35
40
GetByURI(ctx context.Context, uri string) (*Post, error)
41
+
42
+
// GetByAuthor retrieves posts authored by a specific user
43
+
// Supports filtering by post type and community
44
+
// Returns posts, cursor for pagination, and error
45
+
GetByAuthor(ctx context.Context, req GetAuthorPostsRequest) ([]*PostView, *string, error)
36
46
37
47
// Future methods (Beta):
38
48
// Update(ctx context.Context, post *Post) error
+71
internal/core/posts/post.go
+71
internal/core/posts/post.go
···
143
143
Tags []string `json:"tags,omitempty"`
144
144
Saved bool `json:"saved"`
145
145
}
146
+
147
+
// Filter constants for GetAuthorPosts
148
+
const (
149
+
FilterPostsWithReplies = "posts_with_replies"
150
+
FilterPostsNoReplies = "posts_no_replies"
151
+
FilterPostsWithMedia = "posts_with_media"
152
+
)
153
+
154
+
// GetAuthorPostsRequest represents input for fetching author's posts
155
+
// Matches social.coves.actor.getPosts lexicon input
156
+
type GetAuthorPostsRequest struct {
157
+
ActorDID string // Resolved DID from actor param (handle or DID)
158
+
Filter string // FilterPostsWithReplies, FilterPostsNoReplies, FilterPostsWithMedia
159
+
Community string // Optional community DID filter
160
+
Limit int // Number of posts to return (1-100, default 50)
161
+
Cursor *string // Pagination cursor
162
+
ViewerDID string // Viewer's DID for enriching viewer state
163
+
}
164
+
165
+
// GetAuthorPostsResponse represents author posts response
166
+
// Matches social.coves.actor.getPosts lexicon output
167
+
type GetAuthorPostsResponse struct {
168
+
Feed []*FeedViewPost `json:"feed"`
169
+
Cursor *string `json:"cursor,omitempty"`
170
+
}
171
+
172
+
// FeedViewPost matches social.coves.feed.defs#feedViewPost
173
+
// Wraps a post with optional context about why it appears in a feed
174
+
type FeedViewPost struct {
175
+
Post *PostView `json:"post"`
176
+
Reason *FeedReason `json:"reason,omitempty"` // Context for why post appears in feed
177
+
Reply *ReplyRef `json:"reply,omitempty"` // Reply context if post is a reply
178
+
}
179
+
180
+
// GetPost returns the underlying PostView for viewer state enrichment
181
+
func (f *FeedViewPost) GetPost() *PostView {
182
+
return f.Post
183
+
}
184
+
185
+
// FeedReason represents the reason a post appears in a feed
186
+
// Matches social.coves.feed.defs union type for feed context
187
+
type FeedReason struct {
188
+
Type string `json:"$type"`
189
+
Repost *ReasonRepost `json:"repost,omitempty"`
190
+
Pin *ReasonPin `json:"pin,omitempty"`
191
+
}
192
+
193
+
// ReasonRepost indicates the post was reposted by another user
194
+
type ReasonRepost struct {
195
+
By *AuthorView `json:"by"`
196
+
IndexedAt string `json:"indexedAt"`
197
+
}
198
+
199
+
// ReasonPin indicates the post is pinned by the community
200
+
type ReasonPin struct {
201
+
Community *CommunityRef `json:"community"`
202
+
}
203
+
204
+
// ReplyRef contains context about post replies
205
+
// Matches social.coves.feed.defs#replyRef
206
+
type ReplyRef struct {
207
+
Root *PostRef `json:"root"`
208
+
Parent *PostRef `json:"parent"`
209
+
}
210
+
211
+
// PostRef is a minimal reference to a post (URI + CID)
212
+
// Matches social.coves.feed.defs#postRef
213
+
type PostRef struct {
214
+
URI string `json:"uri"`
215
+
CID string `json:"cid"`
216
+
}
+122
internal/core/posts/service.go
+122
internal/core/posts/service.go
···
558
558
log.Printf("[POST-CREATE] Converted Bluesky URL to post embed: %s (cid: %s)", result.URI, result.CID)
559
559
return true
560
560
}
561
+
562
+
// GetAuthorPosts retrieves posts by a specific author with optional filtering
563
+
// Supports filtering by: posts_with_replies, posts_no_replies, posts_with_media
564
+
// Optionally filter to a specific community
565
+
func (s *postService) GetAuthorPosts(ctx context.Context, req GetAuthorPostsRequest) (*GetAuthorPostsResponse, error) {
566
+
// 1. Validate request
567
+
if err := s.validateGetAuthorPostsRequest(&req); err != nil {
568
+
return nil, err
569
+
}
570
+
571
+
// 2. If community is provided, resolve it to DID
572
+
if req.Community != "" {
573
+
communityDID, err := s.communityService.ResolveCommunityIdentifier(ctx, req.Community)
574
+
if err != nil {
575
+
if communities.IsNotFound(err) {
576
+
return nil, ErrCommunityNotFound
577
+
}
578
+
if communities.IsValidationError(err) {
579
+
return nil, NewValidationError("community", err.Error())
580
+
}
581
+
return nil, fmt.Errorf("failed to resolve community identifier: %w", err)
582
+
}
583
+
req.Community = communityDID
584
+
}
585
+
586
+
// 3. Fetch posts from repository
587
+
postViews, cursor, err := s.repo.GetByAuthor(ctx, req)
588
+
if err != nil {
589
+
return nil, fmt.Errorf("failed to get author posts: %w", err)
590
+
}
591
+
592
+
// 4. Wrap PostViews in FeedViewPost
593
+
feed := make([]*FeedViewPost, len(postViews))
594
+
for i, postView := range postViews {
595
+
feed[i] = &FeedViewPost{
596
+
Post: postView,
597
+
}
598
+
}
599
+
600
+
// 5. Return response
601
+
return &GetAuthorPostsResponse{
602
+
Feed: feed,
603
+
Cursor: cursor,
604
+
}, nil
605
+
}
606
+
607
+
// validateGetAuthorPostsRequest validates the GetAuthorPosts request
608
+
func (s *postService) validateGetAuthorPostsRequest(req *GetAuthorPostsRequest) error {
609
+
// Validate actor DID is set
610
+
if req.ActorDID == "" {
611
+
return NewValidationError("actor", "actor is required")
612
+
}
613
+
614
+
// Validate DID format - AT Protocol supports did:plc and did:web
615
+
if err := validateDIDFormat(req.ActorDID); err != nil {
616
+
return NewValidationError("actor", err.Error())
617
+
}
618
+
619
+
// Validate and set defaults for filter
620
+
validFilters := map[string]bool{
621
+
FilterPostsWithReplies: true,
622
+
FilterPostsNoReplies: true,
623
+
FilterPostsWithMedia: true,
624
+
}
625
+
if req.Filter == "" {
626
+
req.Filter = FilterPostsWithReplies // Default
627
+
}
628
+
if !validFilters[req.Filter] {
629
+
return NewValidationError("filter", "filter must be one of: posts_with_replies, posts_no_replies, posts_with_media")
630
+
}
631
+
632
+
// Validate and set defaults for limit
633
+
if req.Limit <= 0 {
634
+
req.Limit = 50 // Default
635
+
}
636
+
if req.Limit > 100 {
637
+
req.Limit = 100 // Max
638
+
}
639
+
640
+
return nil
641
+
}
642
+
643
+
// validateDIDFormat validates that a string is a properly formatted DID
644
+
// Supports did:plc: (24 char base32 identifier) and did:web: (domain-based)
645
+
func validateDIDFormat(did string) error {
646
+
const maxDIDLength = 2048
647
+
648
+
if len(did) > maxDIDLength {
649
+
return fmt.Errorf("DID exceeds maximum length")
650
+
}
651
+
652
+
switch {
653
+
case strings.HasPrefix(did, "did:plc:"):
654
+
// did:plc: format - identifier is 24 lowercase alphanumeric chars
655
+
identifier := strings.TrimPrefix(did, "did:plc:")
656
+
if len(identifier) == 0 {
657
+
return fmt.Errorf("invalid did:plc format: missing identifier")
658
+
}
659
+
// Base32 uses lowercase a-z and 2-7
660
+
for _, c := range identifier {
661
+
if !((c >= 'a' && c <= 'z') || (c >= '2' && c <= '7')) {
662
+
return fmt.Errorf("invalid did:plc format: identifier contains invalid characters")
663
+
}
664
+
}
665
+
return nil
666
+
667
+
case strings.HasPrefix(did, "did:web:"):
668
+
// did:web: format - domain-based identifier
669
+
domain := strings.TrimPrefix(did, "did:web:")
670
+
if len(domain) == 0 {
671
+
return fmt.Errorf("invalid did:web format: missing domain")
672
+
}
673
+
// Basic domain validation - must contain at least one dot or be localhost
674
+
if !strings.Contains(domain, ".") && domain != "localhost" {
675
+
return fmt.Errorf("invalid did:web format: invalid domain")
676
+
}
677
+
return nil
678
+
679
+
default:
680
+
return fmt.Errorf("unsupported DID method: must be did:plc or did:web")
681
+
}
682
+
}
+11
-2
internal/core/users/service.go
+11
-2
internal/core/users/service.go
···
133
133
134
134
// ResolveHandleToDID resolves a handle to a DID
135
135
// This is critical for login: users enter their handle, we resolve to DID
136
-
// Uses DNS TXT record lookup and HTTPS .well-known/atproto-did resolution
136
+
// First checks local database for indexed users (fast path), then falls back
137
+
// to external DNS TXT record lookup and HTTPS .well-known/atproto-did resolution
137
138
func (s *userService) ResolveHandleToDID(ctx context.Context, handle string) (string, error) {
138
139
handle = strings.TrimSpace(strings.ToLower(handle))
139
140
if handle == "" {
140
141
return "", fmt.Errorf("handle is required")
141
142
}
142
143
143
-
// Use identity resolver to resolve handle to DID
144
+
// Fast path: check local database first for users we've already indexed
145
+
// This avoids external network calls for known users
146
+
user, err := s.userRepo.GetByHandle(ctx, handle)
147
+
if err == nil && user != nil {
148
+
return user.DID, nil
149
+
}
150
+
// If not found locally, fall through to external resolution
151
+
152
+
// Slow path: use identity resolver for external DNS/HTTPS resolution
144
153
did, _, err := s.identityResolver.ResolveHandle(ctx, handle)
145
154
if err != nil {
146
155
return "", fmt.Errorf("failed to resolve handle %s: %w", handle, err)
+285
internal/db/postgres/post_repo.go
+285
internal/db/postgres/post_repo.go
···
4
4
"Coves/internal/core/posts"
5
5
"context"
6
6
"database/sql"
7
+
"encoding/base64"
8
+
"encoding/json"
7
9
"fmt"
10
+
"log"
8
11
"strings"
12
+
"time"
9
13
)
10
14
11
15
type postgresPostRepo struct {
···
128
132
129
133
return &post, nil
130
134
}
135
+
136
+
// GetByAuthor retrieves posts by author with filtering and pagination
137
+
// Supports filter options: posts_with_replies (default), posts_no_replies, posts_with_media
138
+
// Uses cursor-based pagination with created_at + uri for stable ordering
139
+
// Returns []*PostView, next cursor, and error
140
+
func (r *postgresPostRepo) GetByAuthor(ctx context.Context, req posts.GetAuthorPostsRequest) ([]*posts.PostView, *string, error) {
141
+
// Build WHERE clauses based on filters
142
+
whereConditions := []string{
143
+
"p.author_did = $1",
144
+
"p.deleted_at IS NULL",
145
+
}
146
+
args := []interface{}{req.ActorDID}
147
+
paramIndex := 2
148
+
149
+
// Optional community filter
150
+
if req.Community != "" {
151
+
whereConditions = append(whereConditions, fmt.Sprintf("p.community_did = $%d", paramIndex))
152
+
args = append(args, req.Community)
153
+
paramIndex++
154
+
}
155
+
156
+
// Filter by post type
157
+
// Design note: Coves architecture separates posts from comments (unlike Bluesky where
158
+
// posts can be replies to other posts). The posts_no_replies filter exists for API
159
+
// compatibility with Bluesky's getAuthorFeed, but is intentionally a no-op in Coves
160
+
// since all Coves posts are top-level (comments are stored in a separate table).
161
+
switch req.Filter {
162
+
case posts.FilterPostsWithMedia:
163
+
whereConditions = append(whereConditions, "p.embed IS NOT NULL")
164
+
case posts.FilterPostsNoReplies:
165
+
// No-op: All Coves posts are top-level; comments are in the comments table.
166
+
// This filter exists for Bluesky API compatibility.
167
+
case posts.FilterPostsWithReplies, "":
168
+
// Default: return all posts (no additional filter needed)
169
+
}
170
+
171
+
// Build cursor filter for pagination
172
+
cursorFilter, cursorArgs, cursorErr := r.parseAuthorPostsCursor(req.Cursor, paramIndex)
173
+
if cursorErr != nil {
174
+
return nil, nil, cursorErr
175
+
}
176
+
if cursorFilter != "" {
177
+
whereConditions = append(whereConditions, cursorFilter)
178
+
args = append(args, cursorArgs...)
179
+
paramIndex += len(cursorArgs)
180
+
}
181
+
182
+
// Add limit to args
183
+
limit := req.Limit
184
+
if limit <= 0 {
185
+
limit = 50 // default
186
+
}
187
+
if limit > 100 {
188
+
limit = 100 // max
189
+
}
190
+
args = append(args, limit+1) // +1 to check for next page
191
+
192
+
whereClause := strings.Join(whereConditions, " AND ")
193
+
194
+
query := fmt.Sprintf(`
195
+
SELECT
196
+
p.uri, p.cid, p.rkey,
197
+
p.author_did, u.handle as author_handle,
198
+
p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar, c.pds_url as community_pds_url,
199
+
p.title, p.content, p.content_facets, p.embed, p.content_labels,
200
+
p.created_at, p.edited_at, p.indexed_at,
201
+
p.upvote_count, p.downvote_count, p.score, p.comment_count
202
+
FROM posts p
203
+
INNER JOIN users u ON p.author_did = u.did
204
+
INNER JOIN communities c ON p.community_did = c.did
205
+
WHERE %s
206
+
ORDER BY p.created_at DESC, p.uri DESC
207
+
LIMIT $%d
208
+
`, whereClause, paramIndex)
209
+
210
+
// Execute query
211
+
rows, err := r.db.QueryContext(ctx, query, args...)
212
+
if err != nil {
213
+
return nil, nil, fmt.Errorf("failed to query author posts: %w", err)
214
+
}
215
+
defer func() {
216
+
if err := rows.Close(); err != nil {
217
+
log.Printf("WARN: failed to close rows: %v", err)
218
+
}
219
+
}()
220
+
221
+
// Scan results
222
+
var postViews []*posts.PostView
223
+
for rows.Next() {
224
+
postView, err := r.scanAuthorPost(rows)
225
+
if err != nil {
226
+
return nil, nil, fmt.Errorf("failed to scan author post: %w", err)
227
+
}
228
+
postViews = append(postViews, postView)
229
+
}
230
+
231
+
if err := rows.Err(); err != nil {
232
+
return nil, nil, fmt.Errorf("error iterating author posts results: %w", err)
233
+
}
234
+
235
+
// Handle pagination cursor
236
+
var cursor *string
237
+
if len(postViews) > limit && limit > 0 {
238
+
postViews = postViews[:limit]
239
+
lastPost := postViews[len(postViews)-1]
240
+
cursorStr := r.buildAuthorPostsCursor(lastPost)
241
+
cursor = &cursorStr
242
+
}
243
+
244
+
return postViews, cursor, nil
245
+
}
246
+
247
+
// parseAuthorPostsCursor decodes pagination cursor for author posts
248
+
// Cursor format: base64(created_at|uri)
249
+
// Uses simple | delimiter since this is an internal cursor (not signed like feed cursors)
250
+
// Returns filter clause, arguments, and error. Error is returned for malformed cursors
251
+
// to provide clear feedback rather than silently returning the first page.
252
+
func (r *postgresPostRepo) parseAuthorPostsCursor(cursor *string, paramOffset int) (string, []interface{}, error) {
253
+
if cursor == nil || *cursor == "" {
254
+
return "", nil, nil
255
+
}
256
+
257
+
// Validate cursor size to prevent DoS via massive base64 strings
258
+
const maxCursorSize = 512
259
+
if len(*cursor) > maxCursorSize {
260
+
return "", nil, fmt.Errorf("%w: cursor exceeds maximum length", posts.ErrInvalidCursor)
261
+
}
262
+
263
+
// Decode base64 cursor
264
+
decoded, err := base64.URLEncoding.DecodeString(*cursor)
265
+
if err != nil {
266
+
return "", nil, fmt.Errorf("%w: invalid base64 encoding", posts.ErrInvalidCursor)
267
+
}
268
+
269
+
// Parse cursor: created_at|uri
270
+
parts := strings.Split(string(decoded), "|")
271
+
if len(parts) != 2 {
272
+
return "", nil, fmt.Errorf("%w: malformed cursor format", posts.ErrInvalidCursor)
273
+
}
274
+
275
+
createdAt := parts[0]
276
+
uri := parts[1]
277
+
278
+
// Validate timestamp format
279
+
if _, err := time.Parse(time.RFC3339Nano, createdAt); err != nil {
280
+
return "", nil, fmt.Errorf("%w: invalid timestamp in cursor", posts.ErrInvalidCursor)
281
+
}
282
+
283
+
// Validate URI format (must be AT-URI)
284
+
if !strings.HasPrefix(uri, "at://") {
285
+
return "", nil, fmt.Errorf("%w: invalid URI format in cursor", posts.ErrInvalidCursor)
286
+
}
287
+
288
+
// Use composite key comparison for stable cursor pagination
289
+
// (created_at, uri) < (cursor_created_at, cursor_uri)
290
+
filter := fmt.Sprintf("(p.created_at < $%d OR (p.created_at = $%d AND p.uri < $%d))",
291
+
paramOffset, paramOffset, paramOffset+1)
292
+
return filter, []interface{}{createdAt, uri}, nil
293
+
}
294
+
295
+
// buildAuthorPostsCursor creates pagination cursor from last post
296
+
// Cursor format: base64(created_at|uri)
297
+
func (r *postgresPostRepo) buildAuthorPostsCursor(post *posts.PostView) string {
298
+
cursorStr := fmt.Sprintf("%s|%s", post.CreatedAt.Format(time.RFC3339Nano), post.URI)
299
+
return base64.URLEncoding.EncodeToString([]byte(cursorStr))
300
+
}
301
+
302
+
// scanAuthorPost scans a database row into a PostView for author posts query
303
+
func (r *postgresPostRepo) scanAuthorPost(rows *sql.Rows) (*posts.PostView, error) {
304
+
var (
305
+
postView posts.PostView
306
+
authorView posts.AuthorView
307
+
communityRef posts.CommunityRef
308
+
title, content sql.NullString
309
+
facets, embed sql.NullString
310
+
labelsJSON sql.NullString
311
+
editedAt sql.NullTime
312
+
communityHandle sql.NullString
313
+
communityAvatar sql.NullString
314
+
communityPDSURL sql.NullString
315
+
)
316
+
317
+
err := rows.Scan(
318
+
&postView.URI, &postView.CID, &postView.RKey,
319
+
&authorView.DID, &authorView.Handle,
320
+
&communityRef.DID, &communityHandle, &communityRef.Name, &communityAvatar, &communityPDSURL,
321
+
&title, &content, &facets, &embed, &labelsJSON,
322
+
&postView.CreatedAt, &editedAt, &postView.IndexedAt,
323
+
&postView.UpvoteCount, &postView.DownvoteCount, &postView.Score, &postView.CommentCount,
324
+
)
325
+
if err != nil {
326
+
return nil, err
327
+
}
328
+
329
+
// Build author view
330
+
postView.Author = &authorView
331
+
332
+
// Build community ref
333
+
if communityHandle.Valid {
334
+
communityRef.Handle = communityHandle.String
335
+
}
336
+
if communityAvatar.Valid {
337
+
communityRef.Avatar = &communityAvatar.String
338
+
}
339
+
if communityPDSURL.Valid {
340
+
communityRef.PDSURL = communityPDSURL.String
341
+
}
342
+
postView.Community = &communityRef
343
+
344
+
// Set optional fields
345
+
if title.Valid {
346
+
postView.Title = &title.String
347
+
}
348
+
if content.Valid {
349
+
postView.Text = &content.String
350
+
}
351
+
if editedAt.Valid {
352
+
postView.EditedAt = &editedAt.Time
353
+
}
354
+
355
+
// Parse facets JSON
356
+
if facets.Valid {
357
+
var facetArray []interface{}
358
+
if err := json.Unmarshal([]byte(facets.String), &facetArray); err != nil {
359
+
return nil, fmt.Errorf("failed to parse facets JSON for post %s: %w", postView.URI, err)
360
+
}
361
+
postView.TextFacets = facetArray
362
+
}
363
+
364
+
// Parse embed JSON
365
+
if embed.Valid {
366
+
var embedData interface{}
367
+
if err := json.Unmarshal([]byte(embed.String), &embedData); err != nil {
368
+
return nil, fmt.Errorf("failed to parse embed JSON for post %s: %w", postView.URI, err)
369
+
}
370
+
postView.Embed = embedData
371
+
}
372
+
373
+
// Build stats
374
+
postView.Stats = &posts.PostStats{
375
+
Upvotes: postView.UpvoteCount,
376
+
Downvotes: postView.DownvoteCount,
377
+
Score: postView.Score,
378
+
CommentCount: postView.CommentCount,
379
+
}
380
+
381
+
// Build the record (required by lexicon)
382
+
record := map[string]interface{}{
383
+
"$type": "social.coves.community.post",
384
+
"community": communityRef.DID,
385
+
"author": authorView.DID,
386
+
"createdAt": postView.CreatedAt.Format(time.RFC3339),
387
+
}
388
+
389
+
// Add optional fields to record if present
390
+
if title.Valid {
391
+
record["title"] = title.String
392
+
}
393
+
if content.Valid {
394
+
record["content"] = content.String
395
+
}
396
+
// Reuse already-parsed facets and embed from PostView to avoid double parsing
397
+
if facets.Valid {
398
+
record["facets"] = postView.TextFacets
399
+
}
400
+
if embed.Valid {
401
+
record["embed"] = postView.Embed
402
+
}
403
+
if labelsJSON.Valid {
404
+
// Labels are stored as JSONB containing full com.atproto.label.defs#selfLabels structure
405
+
var selfLabels posts.SelfLabels
406
+
if err := json.Unmarshal([]byte(labelsJSON.String), &selfLabels); err != nil {
407
+
return nil, fmt.Errorf("failed to parse labels JSON for post %s: %w", postView.URI, err)
408
+
}
409
+
record["labels"] = selfLabels
410
+
}
411
+
412
+
postView.Record = record
413
+
414
+
return &postView, nil
415
+
}
+244
internal/db/postgres/post_repo_cursor_test.go
+244
internal/db/postgres/post_repo_cursor_test.go
···
1
+
package postgres
2
+
3
+
import (
4
+
"context"
5
+
"database/sql"
6
+
"encoding/base64"
7
+
"testing"
8
+
"time"
9
+
10
+
"Coves/internal/core/posts"
11
+
)
12
+
13
+
func TestParseAuthorPostsCursor(t *testing.T) {
14
+
repo := &postgresPostRepo{db: nil} // db not needed for cursor parsing
15
+
16
+
// Helper to create a valid cursor
17
+
makeCursor := func(timestamp, uri string) string {
18
+
return base64.URLEncoding.EncodeToString([]byte(timestamp + "|" + uri))
19
+
}
20
+
21
+
validTimestamp := time.Now().Format(time.RFC3339Nano)
22
+
validURI := "at://did:plc:test123/social.coves.community.post/abc123"
23
+
24
+
tests := []struct {
25
+
name string
26
+
cursor *string
27
+
wantFilter bool
28
+
wantErr bool
29
+
errMsg string
30
+
}{
31
+
{
32
+
name: "nil cursor returns empty filter",
33
+
cursor: nil,
34
+
wantFilter: false,
35
+
wantErr: false,
36
+
},
37
+
{
38
+
name: "empty cursor returns empty filter",
39
+
cursor: strPtr(""),
40
+
wantFilter: false,
41
+
wantErr: false,
42
+
},
43
+
{
44
+
name: "valid cursor",
45
+
cursor: strPtr(makeCursor(validTimestamp, validURI)),
46
+
wantFilter: true,
47
+
wantErr: false,
48
+
},
49
+
{
50
+
name: "cursor too long",
51
+
cursor: strPtr(makeCursor(validTimestamp, string(make([]byte, 600)))),
52
+
wantFilter: false,
53
+
wantErr: true,
54
+
errMsg: "exceeds maximum length",
55
+
},
56
+
{
57
+
name: "invalid base64",
58
+
cursor: strPtr("not-valid-base64!!!"),
59
+
wantFilter: false,
60
+
wantErr: true,
61
+
errMsg: "invalid base64",
62
+
},
63
+
{
64
+
name: "missing pipe delimiter",
65
+
cursor: strPtr(base64.URLEncoding.EncodeToString([]byte("no-pipe-here"))),
66
+
wantFilter: false,
67
+
wantErr: true,
68
+
errMsg: "malformed cursor format",
69
+
},
70
+
{
71
+
name: "invalid timestamp",
72
+
cursor: strPtr(base64.URLEncoding.EncodeToString([]byte("not-a-timestamp|" + validURI))),
73
+
wantFilter: false,
74
+
wantErr: true,
75
+
errMsg: "invalid timestamp",
76
+
},
77
+
{
78
+
name: "invalid URI format",
79
+
cursor: strPtr(base64.URLEncoding.EncodeToString([]byte(validTimestamp + "|not-an-at-uri"))),
80
+
wantFilter: false,
81
+
wantErr: true,
82
+
errMsg: "invalid URI format",
83
+
},
84
+
}
85
+
86
+
for _, tt := range tests {
87
+
t.Run(tt.name, func(t *testing.T) {
88
+
filter, args, err := repo.parseAuthorPostsCursor(tt.cursor, 1)
89
+
90
+
if tt.wantErr {
91
+
if err == nil {
92
+
t.Errorf("parseAuthorPostsCursor() = nil error, want error containing %q", tt.errMsg)
93
+
} else if !posts.IsValidationError(err) && err != posts.ErrInvalidCursor {
94
+
// Check if error wraps ErrInvalidCursor
95
+
if tt.errMsg != "" && !containsStr(err.Error(), tt.errMsg) {
96
+
t.Errorf("parseAuthorPostsCursor() error = %v, want error containing %q", err, tt.errMsg)
97
+
}
98
+
}
99
+
} else {
100
+
if err != nil {
101
+
t.Errorf("parseAuthorPostsCursor() = %v, want nil error", err)
102
+
}
103
+
}
104
+
105
+
if tt.wantFilter {
106
+
if filter == "" {
107
+
t.Error("parseAuthorPostsCursor() filter = empty, want non-empty filter")
108
+
}
109
+
if len(args) == 0 {
110
+
t.Error("parseAuthorPostsCursor() args = empty, want non-empty args")
111
+
}
112
+
} else if !tt.wantErr {
113
+
if filter != "" {
114
+
t.Errorf("parseAuthorPostsCursor() filter = %q, want empty", filter)
115
+
}
116
+
}
117
+
})
118
+
}
119
+
}
120
+
121
+
func TestBuildAuthorPostsCursor(t *testing.T) {
122
+
repo := &postgresPostRepo{db: nil}
123
+
124
+
now := time.Now()
125
+
post := &posts.PostView{
126
+
URI: "at://did:plc:test123/social.coves.community.post/abc123",
127
+
CreatedAt: now,
128
+
}
129
+
130
+
cursor := repo.buildAuthorPostsCursor(post)
131
+
132
+
// Decode and verify cursor
133
+
decoded, err := base64.URLEncoding.DecodeString(cursor)
134
+
if err != nil {
135
+
t.Fatalf("Failed to decode cursor: %v", err)
136
+
}
137
+
138
+
// Should contain timestamp|uri
139
+
decodedStr := string(decoded)
140
+
if !containsStr(decodedStr, "|") {
141
+
t.Errorf("Cursor should contain '|' delimiter, got %q", decodedStr)
142
+
}
143
+
if !containsStr(decodedStr, post.URI) {
144
+
t.Errorf("Cursor should contain URI, got %q", decodedStr)
145
+
}
146
+
if !containsStr(decodedStr, now.Format(time.RFC3339Nano)) {
147
+
t.Errorf("Cursor should contain timestamp, got %q", decodedStr)
148
+
}
149
+
}
150
+
151
+
func TestBuildAndParseCursorRoundTrip(t *testing.T) {
152
+
repo := &postgresPostRepo{db: nil}
153
+
154
+
now := time.Now()
155
+
post := &posts.PostView{
156
+
URI: "at://did:plc:test123/social.coves.community.post/abc123",
157
+
CreatedAt: now,
158
+
}
159
+
160
+
// Build cursor
161
+
cursor := repo.buildAuthorPostsCursor(post)
162
+
163
+
// Parse it back
164
+
filter, args, err := repo.parseAuthorPostsCursor(&cursor, 1)
165
+
166
+
if err != nil {
167
+
t.Fatalf("Failed to parse cursor: %v", err)
168
+
}
169
+
170
+
if filter == "" {
171
+
t.Error("Expected non-empty filter")
172
+
}
173
+
174
+
if len(args) != 2 {
175
+
t.Errorf("Expected 2 args, got %d", len(args))
176
+
}
177
+
178
+
// First arg should be timestamp string
179
+
if ts, ok := args[0].(string); ok {
180
+
parsedTime, err := time.Parse(time.RFC3339Nano, ts)
181
+
if err != nil {
182
+
t.Errorf("First arg is not a valid timestamp: %v", err)
183
+
}
184
+
if !parsedTime.Equal(now) {
185
+
t.Errorf("Timestamp mismatch: got %v, want %v", parsedTime, now)
186
+
}
187
+
} else {
188
+
t.Errorf("First arg should be string, got %T", args[0])
189
+
}
190
+
191
+
// Second arg should be URI
192
+
if uri, ok := args[1].(string); ok {
193
+
if uri != post.URI {
194
+
t.Errorf("URI mismatch: got %q, want %q", uri, post.URI)
195
+
}
196
+
} else {
197
+
t.Errorf("Second arg should be string, got %T", args[1])
198
+
}
199
+
}
200
+
201
+
// Helper functions
202
+
func strPtr(s string) *string {
203
+
return &s
204
+
}
205
+
206
+
func containsStr(s, substr string) bool {
207
+
for i := 0; i <= len(s)-len(substr); i++ {
208
+
if s[i:i+len(substr)] == substr {
209
+
return true
210
+
}
211
+
}
212
+
return false
213
+
}
214
+
215
+
// Ensure the mock repository satisfies the interface
216
+
var _ posts.Repository = (*mockPostRepository)(nil)
217
+
218
+
type mockPostRepository struct {
219
+
db *sql.DB
220
+
}
221
+
222
+
func (m *mockPostRepository) Create(ctx context.Context, post *posts.Post) error {
223
+
return nil
224
+
}
225
+
226
+
func (m *mockPostRepository) GetByURI(ctx context.Context, uri string) (*posts.Post, error) {
227
+
return nil, nil
228
+
}
229
+
230
+
func (m *mockPostRepository) GetByAuthor(ctx context.Context, req posts.GetAuthorPostsRequest) ([]*posts.PostView, *string, error) {
231
+
return nil, nil, nil
232
+
}
233
+
234
+
func (m *mockPostRepository) SoftDelete(ctx context.Context, uri string) error {
235
+
return nil
236
+
}
237
+
238
+
func (m *mockPostRepository) Update(ctx context.Context, post *posts.Post) error {
239
+
return nil
240
+
}
241
+
242
+
func (m *mockPostRepository) UpdateVoteCounts(ctx context.Context, uri string, upvotes, downvotes int) error {
243
+
return nil
244
+
}
+4
tests/integration/user_test.go
+4
tests/integration/user_test.go
···
49
49
t.Fatalf("Failed to connect to test database: %v", err)
50
50
}
51
51
52
+
// Limit connection pool to prevent "too many clients" error in parallel tests
53
+
db.SetMaxOpenConns(5)
54
+
db.SetMaxIdleConns(2)
55
+
52
56
if pingErr := db.Ping(); pingErr != nil {
53
57
t.Fatalf("Failed to ping test database: %v", pingErr)
54
58
}