commit c6f51cc48709d43a3f0a1c774131b2cf80a8e7d1 · bretton.dev/coves

+2 -2

cmd/server/main.go

···

       543
        
       	routes.RegisterTimelineRoutes(r, timelineService, voteService, authMiddleware)

     

       544
        
       	log.Println("Timeline XRPC endpoints registered (requires authentication, includes viewer vote state)")

     

       545
        
       

     

       546
       -
       	routes.RegisterDiscoverRoutes(r, discoverService)

     

       547
       -
       	log.Println("Discover XRPC endpoints registered (public, no auth required)")

     

       548
        
       

     

       549
        
       	routes.RegisterAggregatorRoutes(r, aggregatorService, userService, identityResolver)

     

       550
        
       	log.Println("Aggregator XRPC endpoints registered (query endpoints public, registration endpoint public)")

···

       543
        
       	routes.RegisterTimelineRoutes(r, timelineService, voteService, authMiddleware)

     

       544
        
       	log.Println("Timeline XRPC endpoints registered (requires authentication, includes viewer vote state)")

     

       545
        
       

     

       546
       +
       	routes.RegisterDiscoverRoutes(r, discoverService, voteService, authMiddleware)

     

       547
       +
       	log.Println("Discover XRPC endpoints registered (public with optional auth for viewer vote state)")

     

       548
        
       

     

       549
        
       	routes.RegisterAggregatorRoutes(r, aggregatorService, userService, identityResolver)

     

       550
        
       	log.Println("Aggregator XRPC endpoints registered (query endpoints public, registration endpoint public)")

+73

internal/api/handlers/common/viewer_state.go

···

       1
       +
       package common

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"Coves/internal/api/middleware"

     

       5
       +
       	"Coves/internal/core/posts"

     

       6
       +
       	"Coves/internal/core/votes"

     

       7
       +
       	"context"

     

       8
       +
       	"log"

     

       9
       +
       	"net/http"

     

       10
       +
       )

     

       11
       +
       

     

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

     

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

     

       14
       +
       type FeedPostProvider interface {

     

       15
       +
       	GetPost() *posts.PostView

     

       16
       +
       }

     

       17
       +
       

     

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

     

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

     

       20
       +
       //

     

       21
       +
       // Parameters:

     

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

     

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

     

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

     

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

     

       26
       +
       //

     

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

     

       28
       +
       func PopulateViewerVoteState[T FeedPostProvider](

     

       29
       +
       	ctx context.Context,

     

       30
       +
       	r *http.Request,

     

       31
       +
       	voteService votes.Service,

     

       32
       +
       	feedPosts []T,

     

       33
       +
       ) {

     

       34
       +
       	if voteService == nil {

     

       35
       +
       		return

     

       36
       +
       	}

     

       37
       +
       

     

       38
       +
       	session := middleware.GetOAuthSession(r)

     

       39
       +
       	if session == nil {

     

       40
       +
       		return

     

       41
       +
       	}

     

       42
       +
       

     

       43
       +
       	userDID := middleware.GetUserDID(r)

     

       44
       +
       

     

       45
       +
       	// Ensure vote cache is populated from PDS

     

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

     

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

     

       48
       +
       		return

     

       49
       +
       	}

     

       50
       +
       

     

       51
       +
       	// Collect post URIs to batch lookup

     

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

     

       53
       +
       	for _, feedPost := range feedPosts {

     

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

     

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

     

       56
       +
       		}

     

       57
       +
       	}

     

       58
       +
       

     

       59
       +
       	// Get viewer votes for all posts

     

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

     

       61
       +
       

     

       62
       +
       	// Populate viewer state on each post

     

       63
       +
       	for _, feedPost := range feedPosts {

     

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

     

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

     

       66
       +
       				post.Viewer = &posts.ViewerState{

     

       67
       +
       					Vote:    &vote.Direction,

     

       68
       +
       					VoteURI: &vote.URI,

     

       69
       +
       				}

     

       70
       +
       			}

     

       71
       +
       		}

     

       72
       +
       	}

     

       73
       +
       }

+3 -36

internal/api/handlers/communityFeed/get_community.go

···

       1
        
       package communityFeed

     

       2
        
       

     

       3
        
       import (

     

       4
       -
       	"Coves/internal/api/middleware"

     

       5
        
       	"Coves/internal/core/communityFeeds"

     

       6
        
       	"Coves/internal/core/posts"

     

       7
        
       	"Coves/internal/core/votes"

     
···

       47
        
       		return

     

       48
        
       	}

     

       49
        
       

     

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

     

       51
       -
       	if h.voteService != nil {

     

       52
       -
       		session := middleware.GetOAuthSession(r)

     

       53
       -
       		if session != nil {

     

       54
       -
       			userDID := middleware.GetUserDID(r)

     

       55
       -
       			// Ensure vote cache is populated from PDS

     

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

     

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

     

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

     

       59
       -
       			} else {

     

       60
       -
       				// Collect post URIs to batch lookup

     

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

     

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

     

       63
       -
       					if feedPost.Post != nil {

     

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

     

       65
       -
       					}

     

       66
       -
       				}

     

       67
       -
       

     

       68
       -
       				// Get viewer votes for all posts

     

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

     

       70
       -
       

     

       71
       -
       				// Populate viewer state on each post

     

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

     

       73
       -
       					if feedPost.Post != nil {

     

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

     

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

     

       76
       -
       								Vote:    &vote.Direction,

     

       77
       -
       								VoteURI: &vote.URI,

     

       78
       -
       							}

     

       79
       -
       						}

     

       80
       -
       					}

     

       81
       -
       				}

     

       82
       -
       			}

     

       83
       -
       		}

     

       84
       -
       	}

     

       85
        
       

     

       86
        
       	// Transform blob refs to URLs for all posts

     

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

···

       1
        
       package communityFeed

     

       2
        
       

     

       3
        
       import (

     

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

     

       5
        
       	"Coves/internal/core/communityFeeds"

     

       6
        
       	"Coves/internal/core/posts"

     

       7
        
       	"Coves/internal/core/votes"

     
···

       47
        
       		return

     

       48
        
       	}

     

       49
        
       

     

       50
       +
       	// Populate viewer vote state if authenticated

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       52
        
       

     

       53
        
       	// Transform blob refs to URLs for all posts

     

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

+11 -4

internal/api/handlers/discover/get_discover.go

···

       1
        
       package discover

     

       2
        
       

     

       3
        
       import (

     

       0
        
       
     

       4
        
       	"Coves/internal/core/discover"

     

       5
        
       	"Coves/internal/core/posts"

     

       0
        
       
     

       6
        
       	"encoding/json"

     

       7
        
       	"log"

     

       8
        
       	"net/http"

     
···

       11
        
       

     

       12
        
       // GetDiscoverHandler handles discover feed retrieval

     

       13
        
       type GetDiscoverHandler struct {

     

       14
       -
       	service discover.Service

     

       0
        
       
     

       15
        
       }

     

       16
        
       

     

       17
        
       // NewGetDiscoverHandler creates a new discover handler

     

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

     

       19
        
       	return &GetDiscoverHandler{

     

       20
       -
       		service: service,

     

       0
        
       
     

       21
        
       	}

     

       22
        
       }

     

       23
        
       

     

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

     

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

     

       26
       -
       // Public endpoint - no authentication required

     

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

     

       28
        
       	if r.Method != http.MethodGet {

     

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

     
···

       39
        
       		handleServiceError(w, err)

     

       40
        
       		return

     

       41
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       42
        
       

     

       43
        
       	// Transform blob refs to URLs for all posts

     

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

···

       1
        
       package discover

     

       2
        
       

     

       3
        
       import (

     

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

     

       5
        
       	"Coves/internal/core/discover"

     

       6
        
       	"Coves/internal/core/posts"

     

       7
       +
       	"Coves/internal/core/votes"

     

       8
        
       	"encoding/json"

     

       9
        
       	"log"

     

       10
        
       	"net/http"

     
···

       13
        
       

     

       14
        
       // GetDiscoverHandler handles discover feed retrieval

     

       15
        
       type GetDiscoverHandler struct {

     

       16
       +
       	service     discover.Service

     

       17
       +
       	voteService votes.Service

     

       18
        
       }

     

       19
        
       

     

       20
        
       // NewGetDiscoverHandler creates a new discover handler

     

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

     

       22
        
       	return &GetDiscoverHandler{

     

       23
       +
       		service:     service,

     

       24
       +
       		voteService: voteService,

     

       25
        
       	}

     

       26
        
       }

     

       27
        
       

     

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

     

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

     

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

     

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

     

       32
        
       	if r.Method != http.MethodGet {

     

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

     
···

       43
        
       		handleServiceError(w, err)

     

       44
        
       		return

     

       45
        
       	}

     

       46
       +
       

     

       47
       +
       	// Populate viewer vote state if authenticated

     

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

     

       49
        
       

     

       50
        
       	// Transform blob refs to URLs for all posts

     

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

+3 -34

internal/api/handlers/timeline/get_timeline.go

···

       1
        
       package timeline

     

       2
        
       

     

       3
        
       import (

     

       0
        
       
     

       4
        
       	"Coves/internal/api/middleware"

     

       5
        
       	"Coves/internal/core/posts"

     

       6
        
       	"Coves/internal/core/timeline"

     
···

       56
        
       		return

     

       57
        
       	}

     

       58
        
       

     

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

     

       60
       -
       	if h.voteService != nil {

     

       61
       -
       		session := middleware.GetOAuthSession(r)

     

       62
       -
       		if session != nil {

     

       63
       -
       			// Ensure vote cache is populated from PDS

     

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

     

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

     

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

     

       67
       -
       			} else {

     

       68
       -
       				// Collect post URIs to batch lookup

     

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

     

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

     

       71
       -
       					if feedPost.Post != nil {

     

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

     

       73
       -
       					}

     

       74
       -
       				}

     

       75
       -
       

     

       76
       -
       				// Get viewer votes for all posts

     

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

     

       78
       -
       

     

       79
       -
       				// Populate viewer state on each post

     

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

     

       81
       -
       					if feedPost.Post != nil {

     

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

     

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

     

       84
       -
       								Vote:    &vote.Direction,

     

       85
       -
       								VoteURI: &vote.URI,

     

       86
       -
       							}

     

       87
       -
       						}

     

       88
       -
       					}

     

       89
       -
       				}

     

       90
       -
       			}

     

       91
       -
       		}

     

       92
       -
       	}

     

       93
        
       

     

       94
        
       	// Transform blob refs to URLs for all posts

     

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

···

       1
        
       package timeline

     

       2
        
       

     

       3
        
       import (

     

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

     

       5
        
       	"Coves/internal/api/middleware"

     

       6
        
       	"Coves/internal/core/posts"

     

       7
        
       	"Coves/internal/core/timeline"

     
···

       57
        
       		return

     

       58
        
       	}

     

       59
        
       

     

       60
       +
       	// Populate viewer vote state if authenticated

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       62
        
       

     

       63
        
       	// Transform blob refs to URLs for all posts

     

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

+9 -4

internal/api/routes/discover.go

···

       2
        
       

     

       3
        
       import (

     

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

     

       0
        
       
     

       5
        
       	discoverCore "Coves/internal/core/discover"

     

       0
        
       
     

       6
        
       

     

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

     

       8
        
       )

     
···

       10
        
       // RegisterDiscoverRoutes registers discover-related XRPC endpoints

     

       11
        
       //

     

       12
        
       // SECURITY & RATE LIMITING:

     

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

     

       0
        
       
     

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

     

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

     

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

     
···

       18
        
       func RegisterDiscoverRoutes(

     

       19
        
       	r chi.Router,

     

       20
        
       	discoverService discoverCore.Service,

     

       0
        
       
     

       0
        
       
     

       21
        
       ) {

     

       22
        
       	// Create handlers

     

       23
       -
       	getDiscoverHandler := discover.NewGetDiscoverHandler(discoverService)

     

       24
        
       

     

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

     

       26
       -
       	// Public endpoint - no authentication required

     

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

     

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

     

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

     

       30
        
       }

···

       2
        
       

     

       3
        
       import (

     

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

     

       5
       +
       	"Coves/internal/api/middleware"

     

       6
        
       	discoverCore "Coves/internal/core/discover"

     

       7
       +
       	"Coves/internal/core/votes"

     

       8
        
       

     

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

     

       10
        
       )

     
···

       12
        
       // RegisterDiscoverRoutes registers discover-related XRPC endpoints

     

       13
        
       //

     

       14
        
       // SECURITY & RATE LIMITING:

     

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

     

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

     

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

     

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

     

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

     
···

       21
        
       func RegisterDiscoverRoutes(

     

       22
        
       	r chi.Router,

     

       23
        
       	discoverService discoverCore.Service,

     

       24
       +
       	voteService votes.Service,

     

       25
       +
       	authMiddleware *middleware.OAuthAuthMiddleware,

     

       26
        
       ) {

     

       27
        
       	// Create handlers

     

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

     

       29
        
       

     

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

     

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

     

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

     

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

     

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

     

       35
        
       }

internal/core/communityFeeds/types.go

···

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

     

       32
        
       }

     

       33
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       34
        
       // FeedReason is a union type for feed context

     

       35
        
       // Can be reasonRepost or reasonPin

     

       36
        
       type FeedReason struct {

···

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

     

       32
        
       }

     

       33
        
       

     

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

     

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

     

       36
       +
       	return f.Post

     

       37
       +
       }

     

       38
       +
       

     

       39
        
       // FeedReason is a union type for feed context

     

       40
        
       // Can be reasonRepost or reasonPin

     

       41
        
       type FeedReason struct {

internal/core/discover/types.go

···

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

     

       40
        
       }

     

       41
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       42
        
       // FeedReason is a union type for feed context

     

       43
        
       type FeedReason struct {

     

       44
        
       	Repost    *ReasonRepost    `json:"-"`

···

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

     

       40
        
       }

     

       41
        
       

     

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

     

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

     

       44
       +
       	return f.Post

     

       45
       +
       }

     

       46
       +
       

     

       47
        
       // FeedReason is a union type for feed context

     

       48
        
       type FeedReason struct {

     

       49
        
       	Repost    *ReasonRepost    `json:"-"`

internal/core/timeline/types.go

···

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

     

       43
        
       }

     

       44
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       45
        
       // FeedReason is a union type for feed context

     

       46
        
       // Future: Can be reasonRepost or reasonCommunity

     

       47
        
       type FeedReason struct {

···

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

     

       43
        
       }

     

       44
        
       

     

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

     

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

     

       47
       +
       	return f.Post

     

       48
       +
       }

     

       49
       +
       

     

       50
        
       // FeedReason is a union type for feed context

     

       51
        
       // Future: Can be reasonRepost or reasonCommunity

     

       52
        
       type FeedReason struct {

+193 -5

tests/integration/discover_test.go

···

       2
        
       

     

       3
        
       import (

     

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

     

       0
        
       
     

       0
        
       
     

       5
        
       	"Coves/internal/db/postgres"

     

       6
        
       	"context"

     

       7
        
       	"encoding/json"

     
···

       13
        
       

     

       14
        
       	discoverCore "Coves/internal/core/discover"

     

       15
        
       

     

       0
        
       
     

       0
        
       
     

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

     

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

     

       18
        
       )

     

       19
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       21
        
       func TestGetDiscover_ShowsAllCommunities(t *testing.T) {

     

       22
        
       	if testing.Short() {

     
···

       29
        
       	// Setup services

     

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

     

       31
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       32
       -
       	handler := discover.NewGetDiscoverHandler(discoverService)

     

       33
        
       

     

       34
        
       	ctx := context.Background()

     

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

     
···

       100
        
       	// Setup services

     

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

     

       102
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       103
       -
       	handler := discover.NewGetDiscoverHandler(discoverService)

     

       104
        
       

     

       105
        
       	ctx := context.Background()

     

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

     
···

       147
        
       	// Setup services

     

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

     

       149
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       150
       -
       	handler := discover.NewGetDiscoverHandler(discoverService)

     

       151
        
       

     

       152
        
       	ctx := context.Background()

     

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

     
···

       197
        
       	// Setup services

     

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

     

       199
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       200
       -
       	handler := discover.NewGetDiscoverHandler(discoverService)

     

       201
        
       

     

       202
        
       	ctx := context.Background()

     

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

     
···

       254
        
       	// Setup services

     

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

     

       256
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       257
       -
       	handler := discover.NewGetDiscoverHandler(discoverService)

     

       258
        
       

     

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

     

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

     
···

       271
        
       		assert.Contains(t, errorResp["message"], "limit")

     

       272
        
       	})

     

       273
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       2
        
       

     

       3
        
       import (

     

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

     

       5
       +
       	"Coves/internal/api/middleware"

     

       6
       +
       	"Coves/internal/core/votes"

     

       7
        
       	"Coves/internal/db/postgres"

     

       8
        
       	"context"

     

       9
        
       	"encoding/json"

     
···

       15
        
       

     

       16
        
       	discoverCore "Coves/internal/core/discover"

     

       17
        
       

     

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

     

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

     

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

     

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

     

       22
        
       )

     

       23
        
       

     

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

     

       25
       +
       type mockVoteService struct {

     

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

     

       27
       +
       }

     

       28
       +
       

     

       29
       +
       func newMockVoteService() *mockVoteService {

     

       30
       +
       	return &mockVoteService{

     

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

     

       32
       +
       	}

     

       33
       +
       }

     

       34
       +
       

     

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

     

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

     

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

     

       38
       +
       		Direction: direction,

     

       39
       +
       		URI:       voteURI,

     

       40
       +
       	}

     

       41
       +
       }

     

       42
       +
       

     

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

     

       44
       +
       	return &votes.CreateVoteResponse{}, nil

     

       45
       +
       }

     

       46
       +
       

     

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

     

       48
       +
       	return nil

     

       49
       +
       }

     

       50
       +
       

     

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

     

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

     

       53
       +
       }

     

       54
       +
       

     

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

     

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

     

       57
       +
       	return m.cachedVotes[key]

     

       58
       +
       }

     

       59
       +
       

     

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

     

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

     

       62
       +
       	for _, uri := range subjectURIs {

     

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

     

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

     

       65
       +
       			result[uri] = vote

     

       66
       +
       		}

     

       67
       +
       	}

     

       68
       +
       	return result

     

       69
       +
       }

     

       70
       +
       

     

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

     

       72
        
       func TestGetDiscover_ShowsAllCommunities(t *testing.T) {

     

       73
        
       	if testing.Short() {

     
···

       80
        
       	// Setup services

     

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

     

       82
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

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

     

       84
        
       

     

       85
        
       	ctx := context.Background()

     

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

     
···

       151
        
       	// Setup services

     

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

     

       153
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

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

     

       155
        
       

     

       156
        
       	ctx := context.Background()

     

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

     
···

       198
        
       	// Setup services

     

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

     

       200
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

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

     

       202
        
       

     

       203
        
       	ctx := context.Background()

     

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

     
···

       248
        
       	// Setup services

     

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

     

       250
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

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

     

       252
        
       

     

       253
        
       	ctx := context.Background()

     

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

     
···

       305
        
       	// Setup services

     

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

     

       307
        
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

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

     

       309
        
       

     

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

     

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

     
···

       322
        
       		assert.Contains(t, errorResp["message"], "limit")

     

       323
        
       	})

     

       324
        
       }

     

       325
       +
       

     

       326
       +
       // TestGetDiscover_ViewerVoteState tests that authenticated users see their vote state on posts

     

       327
       +
       func TestGetDiscover_ViewerVoteState(t *testing.T) {

     

       328
       +
       	if testing.Short() {

     

       329
       +
       		t.Skip("Skipping integration test in short mode")

     

       330
       +
       	}

     

       331
       +
       

     

       332
       +
       	db := setupTestDB(t)

     

       333
       +
       	t.Cleanup(func() { _ = db.Close() })

     

       334
       +
       

     

       335
       +
       	ctx := context.Background()

     

       336
       +
       	testID := time.Now().UnixNano()

     

       337
       +
       

     

       338
       +
       	// Create community and posts

     

       339
       +
       	communityDID, err := createFeedTestCommunity(db, ctx, fmt.Sprintf("votes-%d", testID), fmt.Sprintf("alice-%d.test", testID))

     

       340
       +
       	require.NoError(t, err)

     

       341
       +
       

     

       342
       +
       	post1URI := createTestPost(t, db, communityDID, "did:plc:author1", "Post with upvote", 10, time.Now().Add(-1*time.Hour))

     

       343
       +
       	post2URI := createTestPost(t, db, communityDID, "did:plc:author2", "Post with downvote", 5, time.Now().Add(-2*time.Hour))

     

       344
       +
       	_ = createTestPost(t, db, communityDID, "did:plc:author3", "Post without vote", 3, time.Now().Add(-3*time.Hour))

     

       345
       +
       

     

       346
       +
       	// Setup mock vote service with pre-populated votes

     

       347
       +
       	viewerDID := "did:plc:viewer123"

     

       348
       +
       	mockVotes := newMockVoteService()

     

       349
       +
       	mockVotes.AddVote(viewerDID, post1URI, "up", "at://"+viewerDID+"/social.coves.vote/vote1")

     

       350
       +
       	mockVotes.AddVote(viewerDID, post2URI, "down", "at://"+viewerDID+"/social.coves.vote/vote2")

     

       351
       +
       

     

       352
       +
       	// Setup handler with mock vote service

     

       353
       +
       	discoverRepo := postgres.NewDiscoverRepository(db, "test-cursor-secret")

     

       354
       +
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       355
       +
       	handler := discover.NewGetDiscoverHandler(discoverService, mockVotes)

     

       356
       +
       

     

       357
       +
       	// Create request with authenticated user context

     

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

     

       359
       +
       

     

       360
       +
       	// Inject OAuth session into context (simulates OptionalAuth middleware)

     

       361
       +
       	did, _ := syntax.ParseDID(viewerDID)

     

       362
       +
       	session := &oauthlib.ClientSessionData{

     

       363
       +
       		AccountDID:  did,

     

       364
       +
       		AccessToken: "test_token",

     

       365
       +
       	}

     

       366
       +
       	reqCtx := context.WithValue(req.Context(), middleware.UserDIDKey, viewerDID)

     

       367
       +
       	reqCtx = context.WithValue(reqCtx, middleware.OAuthSessionKey, session)

     

       368
       +
       	req = req.WithContext(reqCtx)

     

       369
       +
       

     

       370
       +
       	rec := httptest.NewRecorder()

     

       371
       +
       	handler.HandleGetDiscover(rec, req)

     

       372
       +
       

     

       373
       +
       	// Assertions

     

       374
       +
       	assert.Equal(t, http.StatusOK, rec.Code)

     

       375
       +
       

     

       376
       +
       	var response discoverCore.DiscoverResponse

     

       377
       +
       	err = json.Unmarshal(rec.Body.Bytes(), &response)

     

       378
       +
       	require.NoError(t, err)

     

       379
       +
       

     

       380
       +
       	// Find our test posts and verify vote state

     

       381
       +
       	var foundPost1, foundPost2, foundPost3 bool

     

       382
       +
       	for _, feedPost := range response.Feed {

     

       383
       +
       		switch feedPost.Post.URI {

     

       384
       +
       		case post1URI:

     

       385
       +
       			foundPost1 = true

     

       386
       +
       			require.NotNil(t, feedPost.Post.Viewer, "Post1 should have viewer state")

     

       387
       +
       			require.NotNil(t, feedPost.Post.Viewer.Vote, "Post1 should have vote direction")

     

       388
       +
       			assert.Equal(t, "up", *feedPost.Post.Viewer.Vote, "Post1 should show upvote")

     

       389
       +
       			require.NotNil(t, feedPost.Post.Viewer.VoteURI, "Post1 should have vote URI")

     

       390
       +
       			assert.Contains(t, *feedPost.Post.Viewer.VoteURI, "vote1", "Post1 should have correct vote URI")

     

       391
       +
       

     

       392
       +
       		case post2URI:

     

       393
       +
       			foundPost2 = true

     

       394
       +
       			require.NotNil(t, feedPost.Post.Viewer, "Post2 should have viewer state")

     

       395
       +
       			require.NotNil(t, feedPost.Post.Viewer.Vote, "Post2 should have vote direction")

     

       396
       +
       			assert.Equal(t, "down", *feedPost.Post.Viewer.Vote, "Post2 should show downvote")

     

       397
       +
       			require.NotNil(t, feedPost.Post.Viewer.VoteURI, "Post2 should have vote URI")

     

       398
       +
       

     

       399
       +
       		default:

     

       400
       +
       			// Posts without votes should have nil Viewer or nil Vote

     

       401
       +
       			if feedPost.Post.Viewer != nil && feedPost.Post.Viewer.Vote != nil {

     

       402
       +
       				// This post has a vote from our viewer - it's not post3

     

       403
       +
       				continue

     

       404
       +
       			}

     

       405
       +
       			foundPost3 = true

     

       406
       +
       		}

     

       407
       +
       	}

     

       408
       +
       

     

       409
       +
       	assert.True(t, foundPost1, "Should find post1 with upvote")

     

       410
       +
       	assert.True(t, foundPost2, "Should find post2 with downvote")

     

       411
       +
       	assert.True(t, foundPost3, "Should find post3 without vote")

     

       412
       +
       }

     

       413
       +
       

     

       414
       +
       // TestGetDiscover_NoViewerStateWithoutAuth tests that unauthenticated users don't get viewer state

     

       415
       +
       func TestGetDiscover_NoViewerStateWithoutAuth(t *testing.T) {

     

       416
       +
       	if testing.Short() {

     

       417
       +
       		t.Skip("Skipping integration test in short mode")

     

       418
       +
       	}

     

       419
       +
       

     

       420
       +
       	db := setupTestDB(t)

     

       421
       +
       	t.Cleanup(func() { _ = db.Close() })

     

       422
       +
       

     

       423
       +
       	ctx := context.Background()

     

       424
       +
       	testID := time.Now().UnixNano()

     

       425
       +
       

     

       426
       +
       	// Create community and post

     

       427
       +
       	communityDID, err := createFeedTestCommunity(db, ctx, fmt.Sprintf("noauth-%d", testID), fmt.Sprintf("alice-%d.test", testID))

     

       428
       +
       	require.NoError(t, err)

     

       429
       +
       

     

       430
       +
       	postURI := createTestPost(t, db, communityDID, "did:plc:author", "Some post", 10, time.Now())

     

       431
       +
       

     

       432
       +
       	// Setup mock vote service with a vote (but request will be unauthenticated)

     

       433
       +
       	mockVotes := newMockVoteService()

     

       434
       +
       	mockVotes.AddVote("did:plc:someuser", postURI, "up", "at://did:plc:someuser/social.coves.vote/vote1")

     

       435
       +
       

     

       436
       +
       	// Setup handler with mock vote service

     

       437
       +
       	discoverRepo := postgres.NewDiscoverRepository(db, "test-cursor-secret")

     

       438
       +
       	discoverService := discoverCore.NewDiscoverService(discoverRepo)

     

       439
       +
       	handler := discover.NewGetDiscoverHandler(discoverService, mockVotes)

     

       440
       +
       

     

       441
       +
       	// Create request WITHOUT auth context

     

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

     

       443
       +
       	rec := httptest.NewRecorder()

     

       444
       +
       	handler.HandleGetDiscover(rec, req)

     

       445
       +
       

     

       446
       +
       	// Should succeed

     

       447
       +
       	assert.Equal(t, http.StatusOK, rec.Code)

     

       448
       +
       

     

       449
       +
       	var response discoverCore.DiscoverResponse

     

       450
       +
       	err = json.Unmarshal(rec.Body.Bytes(), &response)

     

       451
       +
       	require.NoError(t, err)

     

       452
       +
       

     

       453
       +
       	// Find our post and verify NO viewer state (unauthenticated)

     

       454
       +
       	for _, feedPost := range response.Feed {

     

       455
       +
       		if feedPost.Post.URI == postURI {

     

       456
       +
       			assert.Nil(t, feedPost.Post.Viewer, "Unauthenticated request should not have viewer state")

     

       457
       +
       			return

     

       458
       +
       		}

     

       459
       +
       	}

     

       460
       +
       	t.Fatal("Test post not found in response")

     

       461
       +
       }

+11 -11

tests/integration/feed_test.go

···

       37
        
       		nil,

     

       38
        
       	)

     

       39
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       40
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       41
        
       

     

       42
        
       	// Setup test data: community, users, and posts

     

       43
        
       	ctx := context.Background()

     
···

       114
        
       		nil,

     

       115
        
       	)

     

       116
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       117
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       118
        
       

     

       119
        
       	// Setup test data

     

       120
        
       	ctx := context.Background()

     
···

       190
        
       		nil,

     

       191
        
       	)

     

       192
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       193
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       194
        
       

     

       195
        
       	// Setup test data

     

       196
        
       	ctx := context.Background()

     
···

       246
        
       		nil,

     

       247
        
       	)

     

       248
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       249
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       250
        
       

     

       251
        
       	// Setup test data with many posts

     

       252
        
       	ctx := context.Background()

     
···

       337
        
       		nil,

     

       338
        
       	)

     

       339
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       340
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       341
        
       

     

       342
        
       	// Request feed for non-existent community

     

       343
        
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.communityFeed.getCommunity?community=did:plc:nonexistent&sort=hot&limit=10", nil)

     
···

       373
        
       		nil,

     

       374
        
       	)

     

       375
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       376
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       377
        
       

     

       378
        
       	// Setup test community

     

       379
        
       	ctx := context.Background()

     
···

       429
        
       		nil,

     

       430
        
       	)

     

       431
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       432
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       433
        
       

     

       434
        
       	// Create community with no posts

     

       435
        
       	ctx := context.Background()

     
···

       473
        
       		nil,

     

       474
        
       	)

     

       475
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       476
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       477
        
       

     

       478
        
       	// Setup test community

     

       479
        
       	ctx := context.Background()

     
···

       526
        
       		nil,

     

       527
        
       	)

     

       528
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       529
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       530
        
       

     

       531
        
       	// Setup test data

     

       532
        
       	ctx := context.Background()

     
···

       627
        
       		nil,

     

       628
        
       	)

     

       629
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       630
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       631
        
       

     

       632
        
       	// Setup test data

     

       633
        
       	ctx := context.Background()

     
···

       720
        
       		nil,

     

       721
        
       	)

     

       722
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       723
       -
       	handler := communityFeed.NewGetCommunityHandler(feedService)

     

       724
        
       

     

       725
        
       	// Setup test data

     

       726
        
       	ctx := context.Background()

···

       37
        
       		nil,

     

       38
        
       	)

     

       39
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       40
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       41
        
       

     

       42
        
       	// Setup test data: community, users, and posts

     

       43
        
       	ctx := context.Background()

     
···

       114
        
       		nil,

     

       115
        
       	)

     

       116
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       117
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       118
        
       

     

       119
        
       	// Setup test data

     

       120
        
       	ctx := context.Background()

     
···

       190
        
       		nil,

     

       191
        
       	)

     

       192
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       193
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       194
        
       

     

       195
        
       	// Setup test data

     

       196
        
       	ctx := context.Background()

     
···

       246
        
       		nil,

     

       247
        
       	)

     

       248
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       249
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       250
        
       

     

       251
        
       	// Setup test data with many posts

     

       252
        
       	ctx := context.Background()

     
···

       337
        
       		nil,

     

       338
        
       	)

     

       339
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       340
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       341
        
       

     

       342
        
       	// Request feed for non-existent community

     

       343
        
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.communityFeed.getCommunity?community=did:plc:nonexistent&sort=hot&limit=10", nil)

     
···

       373
        
       		nil,

     

       374
        
       	)

     

       375
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       376
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       377
        
       

     

       378
        
       	// Setup test community

     

       379
        
       	ctx := context.Background()

     
···

       429
        
       		nil,

     

       430
        
       	)

     

       431
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       432
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       433
        
       

     

       434
        
       	// Create community with no posts

     

       435
        
       	ctx := context.Background()

     
···

       473
        
       		nil,

     

       474
        
       	)

     

       475
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       476
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       477
        
       

     

       478
        
       	// Setup test community

     

       479
        
       	ctx := context.Background()

     
···

       526
        
       		nil,

     

       527
        
       	)

     

       528
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       529
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       530
        
       

     

       531
        
       	// Setup test data

     

       532
        
       	ctx := context.Background()

     
···

       627
        
       		nil,

     

       628
        
       	)

     

       629
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       630
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       631
        
       

     

       632
        
       	// Setup test data

     

       633
        
       	ctx := context.Background()

     
···

       720
        
       		nil,

     

       721
        
       	)

     

       722
        
       	feedService := communityFeeds.NewCommunityFeedService(feedRepo, communityService)

     

       723
       +
       	handler := communityFeed.NewGetCommunityHandler(feedService, nil)

     

       724
        
       

     

       725
        
       	// Setup test data

     

       726
        
       	ctx := context.Background()

+7 -7

tests/integration/timeline_test.go

···

       30
        
       	// Setup services

     

       31
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       32
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       33
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       34
        
       

     

       35
        
       	ctx := context.Background()

     

       36
        
       	testID := time.Now().UnixNano()

     
···

       119
        
       	// Setup services

     

       120
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       121
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       122
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       123
        
       

     

       124
        
       	ctx := context.Background()

     

       125
        
       	testID := time.Now().UnixNano()

     
···

       190
        
       	// Setup services

     

       191
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       192
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       193
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       194
        
       

     

       195
        
       	ctx := context.Background()

     

       196
        
       	testID := time.Now().UnixNano()

     
···

       266
        
       	// Setup services

     

       267
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       268
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       269
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       270
        
       

     

       271
        
       	ctx := context.Background()

     

       272
        
       	testID := time.Now().UnixNano()

     
···

       308
        
       	// Setup services

     

       309
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       310
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       311
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       312
        
       

     

       313
        
       	// Request timeline WITHOUT auth context

     

       314
        
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.feed.getTimeline?sort=new&limit=10", nil)

     
···

       337
        
       	// Setup services

     

       338
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       339
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       340
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       341
        
       

     

       342
        
       	ctx := context.Background()

     

       343
        
       	testID := time.Now().UnixNano()

     
···

       388
        
       	// Setup services

     

       389
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       390
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       391
       -
       	handler := timeline.NewGetTimelineHandler(timelineService)

     

       392
        
       

     

       393
        
       	ctx := context.Background()

     

       394
        
       	testID := time.Now().UnixNano()

···

       30
        
       	// Setup services

     

       31
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       32
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       33
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       34
        
       

     

       35
        
       	ctx := context.Background()

     

       36
        
       	testID := time.Now().UnixNano()

     
···

       119
        
       	// Setup services

     

       120
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       121
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       122
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       123
        
       

     

       124
        
       	ctx := context.Background()

     

       125
        
       	testID := time.Now().UnixNano()

     
···

       190
        
       	// Setup services

     

       191
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       192
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       193
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       194
        
       

     

       195
        
       	ctx := context.Background()

     

       196
        
       	testID := time.Now().UnixNano()

     
···

       266
        
       	// Setup services

     

       267
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       268
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       269
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       270
        
       

     

       271
        
       	ctx := context.Background()

     

       272
        
       	testID := time.Now().UnixNano()

     
···

       308
        
       	// Setup services

     

       309
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       310
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       311
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       312
        
       

     

       313
        
       	// Request timeline WITHOUT auth context

     

       314
        
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.feed.getTimeline?sort=new&limit=10", nil)

     
···

       337
        
       	// Setup services

     

       338
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       339
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       340
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       341
        
       

     

       342
        
       	ctx := context.Background()

     

       343
        
       	testID := time.Now().UnixNano()

     
···

       388
        
       	// Setup services

     

       389
        
       	timelineRepo := postgres.NewTimelineRepository(db, "test-cursor-secret")

     

       390
        
       	timelineService := timelineCore.NewTimelineService(timelineRepo)

     

       391
       +
       	handler := timeline.NewGetTimelineHandler(timelineService, nil)

     

       392
        
       

     

       393
        
       	ctx := context.Background()

     

       394
        
       	testID := time.Now().UnixNano()

+1 -1

tests/integration/user_journey_e2e_test.go

···

       143
        
       	r := chi.NewRouter()

     

       144
        
       	routes.RegisterCommunityRoutes(r, communityService, e2eAuth.OAuthAuthMiddleware, nil) // nil = allow all community creators

     

       145
        
       	routes.RegisterPostRoutes(r, postService, e2eAuth.OAuthAuthMiddleware)

     

       146
       -
       	routes.RegisterTimelineRoutes(r, timelineService, e2eAuth.OAuthAuthMiddleware)

     

       147
        
       	httpServer := httptest.NewServer(r)

     

       148
        
       	defer httpServer.Close()

     

       149

···

       143
        
       	r := chi.NewRouter()

     

       144
        
       	routes.RegisterCommunityRoutes(r, communityService, e2eAuth.OAuthAuthMiddleware, nil) // nil = allow all community creators

     

       145
        
       	routes.RegisterPostRoutes(r, postService, e2eAuth.OAuthAuthMiddleware)

     

       146
       +
       	routes.RegisterTimelineRoutes(r, timelineService, nil, e2eAuth.OAuthAuthMiddleware)

     

       147
        
       	httpServer := httptest.NewServer(r)

     

       148
        
       	defer httpServer.Close()

     

       149