comparing 0e685995a6f6bcb5044c2e999f31bafc4d79a68a and main on bretton.dev/coves

+115

internal/api/handlers/vote/create_vote.go

···

       1
       1
       +
       package vote

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

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

     

       5
       5
       +
       	"Coves/internal/core/votes"

     

       6
       6
       +
       	"encoding/json"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"net/http"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // CreateVoteHandler handles vote creation

     

       12
       12
       +
       type CreateVoteHandler struct {

     

       13
       13
       +
       	service votes.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // NewCreateVoteHandler creates a new create vote handler

     

       17
       17
       +
       func NewCreateVoteHandler(service votes.Service) *CreateVoteHandler {

     

       18
       18
       +
       	return &CreateVoteHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       // CreateVoteInput represents the request body for creating a vote

     

       24
       24
       +
       type CreateVoteInput struct {

     

       25
       25
       +
       	Subject struct {

     

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

     

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

     

       28
       28
       +
       	} `json:"subject"`

     

       29
       29
       +
       	Direction string `json:"direction"`

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       // CreateVoteOutput represents the response body for creating a vote

     

       33
       33
       +
       type CreateVoteOutput struct {

     

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

     

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

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       // HandleCreateVote creates a vote on a post or comment

     

       39
       39
       +
       // POST /xrpc/social.coves.vote.create

     

       40
       40
       +
       //

     

       41
       41
       +
       // Request body: { "subject": { "uri": "at://...", "cid": "..." }, "direction": "up" }

     

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

     

       43
       43
       +
       //

     

       44
       44
       +
       // Behavior:

     

       45
       45
       +
       // - If no vote exists: creates new vote with given direction

     

       46
       46
       +
       // - If vote exists with same direction: deletes vote (toggle off)

     

       47
       47
       +
       // - If vote exists with different direction: updates to new direction

     

       48
       48
       +
       func (h *CreateVoteHandler) HandleCreateVote(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       51
       51
       +
       		return

     

       52
       52
       +
       	}

     

       53
       53
       +
       

     

       54
       54
       +
       	// Parse request body

     

       55
       55
       +
       	var input CreateVoteInput

     

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

     

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

     

       58
       58
       +
       		return

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       	// Validate required fields

     

       62
       62
       +
       	if input.Subject.URI == "" {

     

       63
       63
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "subject.uri is required")

     

       64
       64
       +
       		return

     

       65
       65
       +
       	}

     

       66
       66
       +
       	if input.Subject.CID == "" {

     

       67
       67
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "subject.cid is required")

     

       68
       68
       +
       		return

     

       69
       69
       +
       	}

     

       70
       70
       +
       	if input.Direction == "" {

     

       71
       71
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "direction is required")

     

       72
       72
       +
       		return

     

       73
       73
       +
       	}

     

       74
       74
       +
       

     

       75
       75
       +
       	// Validate direction

     

       76
       76
       +
       	if input.Direction != "up" && input.Direction != "down" {

     

       77
       77
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "direction must be 'up' or 'down'")

     

       78
       78
       +
       		return

     

       79
       79
       +
       	}

     

       80
       80
       +
       

     

       81
       81
       +
       	// Get OAuth session from context (injected by auth middleware)

     

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

     

       83
       83
       +
       	if session == nil {

     

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

     

       85
       85
       +
       		return

     

       86
       86
       +
       	}

     

       87
       87
       +
       

     

       88
       88
       +
       	// Create vote request

     

       89
       89
       +
       	req := votes.CreateVoteRequest{

     

       90
       90
       +
       		Subject: votes.StrongRef{

     

       91
       91
       +
       			URI: input.Subject.URI,

     

       92
       92
       +
       			CID: input.Subject.CID,

     

       93
       93
       +
       		},

     

       94
       94
       +
       		Direction: input.Direction,

     

       95
       95
       +
       	}

     

       96
       96
       +
       

     

       97
       97
       +
       	// Call service to create vote

     

       98
       98
       +
       	response, err := h.service.CreateVote(r.Context(), session, req)

     

       99
       99
       +
       	if err != nil {

     

       100
       100
       +
       		handleServiceError(w, err)

     

       101
       101
       +
       		return

     

       102
       102
       +
       	}

     

       103
       103
       +
       

     

       104
       104
       +
       	// Return success response

     

       105
       105
       +
       	output := CreateVoteOutput{

     

       106
       106
       +
       		URI: response.URI,

     

       107
       107
       +
       		CID: response.CID,

     

       108
       108
       +
       	}

     

       109
       109
       +
       

     

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

     

       111
       111
       +
       	w.WriteHeader(http.StatusOK)

     

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

     

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

     

       114
       114
       +
       	}

     

       115
       115
       +
       }

+93

internal/api/handlers/vote/delete_vote.go

···

       1
       1
       +
       package vote

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

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

     

       5
       5
       +
       	"Coves/internal/core/votes"

     

       6
       6
       +
       	"encoding/json"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"net/http"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // DeleteVoteHandler handles vote deletion

     

       12
       12
       +
       type DeleteVoteHandler struct {

     

       13
       13
       +
       	service votes.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // NewDeleteVoteHandler creates a new delete vote handler

     

       17
       17
       +
       func NewDeleteVoteHandler(service votes.Service) *DeleteVoteHandler {

     

       18
       18
       +
       	return &DeleteVoteHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       // DeleteVoteInput represents the request body for deleting a vote

     

       24
       24
       +
       type DeleteVoteInput struct {

     

       25
       25
       +
       	Subject struct {

     

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

     

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

     

       28
       28
       +
       	} `json:"subject"`

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       // DeleteVoteOutput represents the response body for deleting a vote

     

       32
       32
       +
       // Per lexicon: output is an empty object

     

       33
       33
       +
       type DeleteVoteOutput struct{}

     

       34
       34
       +
       

     

       35
       35
       +
       // HandleDeleteVote removes a vote from a post or comment

     

       36
       36
       +
       // POST /xrpc/social.coves.vote.delete

     

       37
       37
       +
       //

     

       38
       38
       +
       // Request body: { "subject": { "uri": "at://...", "cid": "..." } }

     

       39
       39
       +
       // Response: { "success": true }

     

       40
       40
       +
       func (h *DeleteVoteHandler) HandleDeleteVote(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       43
       43
       +
       		return

     

       44
       44
       +
       	}

     

       45
       45
       +
       

     

       46
       46
       +
       	// Parse request body

     

       47
       47
       +
       	var input DeleteVoteInput

     

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

     

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

     

       50
       50
       +
       		return

     

       51
       51
       +
       	}

     

       52
       52
       +
       

     

       53
       53
       +
       	// Validate required fields

     

       54
       54
       +
       	if input.Subject.URI == "" {

     

       55
       55
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "subject.uri is required")

     

       56
       56
       +
       		return

     

       57
       57
       +
       	}

     

       58
       58
       +
       	if input.Subject.CID == "" {

     

       59
       59
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "subject.cid is required")

     

       60
       60
       +
       		return

     

       61
       61
       +
       	}

     

       62
       62
       +
       

     

       63
       63
       +
       	// Get OAuth session from context (injected by auth middleware)

     

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

     

       65
       65
       +
       	if session == nil {

     

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

     

       67
       67
       +
       		return

     

       68
       68
       +
       	}

     

       69
       69
       +
       

     

       70
       70
       +
       	// Create delete vote request

     

       71
       71
       +
       	req := votes.DeleteVoteRequest{

     

       72
       72
       +
       		Subject: votes.StrongRef{

     

       73
       73
       +
       			URI: input.Subject.URI,

     

       74
       74
       +
       			CID: input.Subject.CID,

     

       75
       75
       +
       		},

     

       76
       76
       +
       	}

     

       77
       77
       +
       

     

       78
       78
       +
       	// Call service to delete vote

     

       79
       79
       +
       	err := h.service.DeleteVote(r.Context(), session, req)

     

       80
       80
       +
       	if err != nil {

     

       81
       81
       +
       		handleServiceError(w, err)

     

       82
       82
       +
       		return

     

       83
       83
       +
       	}

     

       84
       84
       +
       

     

       85
       85
       +
       	// Return success response (empty object per lexicon)

     

       86
       86
       +
       	output := DeleteVoteOutput{}

     

       87
       87
       +
       

     

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

     

       89
       89
       +
       	w.WriteHeader(http.StatusOK)

     

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

     

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

     

       92
       92
       +
       	}

     

       93
       93
       +
       }

+24

internal/api/routes/vote.go

···

       1
       1
       +
       package routes

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

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

     

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

     

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

     

       7
       7
       +
       

     

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

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // RegisterVoteRoutes registers vote-related XRPC endpoints on the router

     

       12
       12
       +
       // Implements social.coves.feed.vote.* lexicon endpoints

     

       13
       13
       +
       func RegisterVoteRoutes(r chi.Router, voteService votes.Service, authMiddleware *middleware.OAuthAuthMiddleware) {

     

       14
       14
       +
       	// Initialize handlers

     

       15
       15
       +
       	createHandler := vote.NewCreateVoteHandler(voteService)

     

       16
       16
       +
       	deleteHandler := vote.NewDeleteVoteHandler(voteService)

     

       17
       17
       +
       

     

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

     

       19
       19
       +
       	// social.coves.feed.vote.create - create or update a vote on a post/comment

     

       20
       20
       +
       	r.With(authMiddleware.RequireAuth).Post("/xrpc/social.coves.feed.vote.create", createHandler.HandleCreateVote)

     

       21
       21
       +
       

     

       22
       22
       +
       	// social.coves.feed.vote.delete - delete a vote from a post/comment

     

       23
       23
       +
       	r.With(authMiddleware.RequireAuth).Post("/xrpc/social.coves.feed.vote.delete", deleteHandler.HandleDeleteVote)

     

       24
       24
       +
       }

-3

internal/api/handlers/vote/errors.go

···

       34
       34
        
       	case errors.Is(err, votes.ErrVoteNotFound):

     

       35
       35
        
       		// Matches: social.coves.feed.vote.delete#VoteNotFound

     

       36
       36
        
       		writeError(w, http.StatusNotFound, "VoteNotFound", "No vote found for this subject")

     

       37
       37
       -
       	case errors.Is(err, votes.ErrSubjectNotFound):

     

       38
       38
       -
       		// Matches: social.coves.feed.vote.create#SubjectNotFound

     

       39
       39
       -
       		writeError(w, http.StatusNotFound, "SubjectNotFound", "The subject post or comment was not found")

     

       40
       37
        
       	case errors.Is(err, votes.ErrInvalidDirection):

     

       41
       38
        
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "Vote direction must be 'up' or 'down'")

     

       42
       39
        
       	case errors.Is(err, votes.ErrInvalidSubject):

+4 -4

internal/atproto/oauth/handlers_security.go

···

       25
       25
        
       // - Android: Verified via /.well-known/assetlinks.json

     

       26
       26
        
       var allowedMobileRedirectURIs = map[string]bool{

     

       27
       27
        
       	// Custom scheme per atproto spec (reverse-domain of coves.social)

     

       28
       28
       -
       	"social.coves:/callback":                  true,

     

       29
       29
       -
       	"social.coves://callback":                 true, // Some platforms add double slash

     

       30
       30
       -
       	"social.coves:/oauth/callback":            true, // Alternative path

     

       31
       31
       -
       	"social.coves://oauth/callback":           true,

     

       28
       28
       +
       	"social.coves:/callback":        true,

     

       29
       29
       +
       	"social.coves://callback":       true, // Some platforms add double slash

     

       30
       30
       +
       	"social.coves:/oauth/callback":  true, // Alternative path

     

       31
       31
       +
       	"social.coves://oauth/callback": true,

     

       32
       32
        
       	// Universal Links - cryptographically bound to app (preferred for security)

     

       33
       33
        
       	"https://coves.social/app/oauth/callback": true,

     

       34
       34
        
       }

-3

internal/core/votes/errors.go

···

       6
       6
        
       	// ErrVoteNotFound indicates the requested vote doesn't exist

     

       7
       7
        
       	ErrVoteNotFound = errors.New("vote not found")

     

       8
       8
        
       

     

       9
       9
       -
       	// ErrSubjectNotFound indicates the post/comment being voted on doesn't exist

     

       10
       10
       -
       	ErrSubjectNotFound = errors.New("subject not found")

     

       11
       11
       -
       

     

       12
       9
        
       	// ErrInvalidDirection indicates the vote direction is not "up" or "down"

     

       13
       10
        
       	ErrInvalidDirection = errors.New("invalid vote direction: must be 'up' or 'down'")

     

       14
       11

+3 -2

internal/db/postgres/vote_repo.go

···

       64
       64
        
       	return nil

     

       65
       65
        
       }

     

       66
       66
        
       

     

       67
       67
       -
       // GetByURI retrieves a vote by its AT-URI

     

       67
       67
       +
       // GetByURI retrieves an active vote by its AT-URI

     

       68
       68
        
       // Used by Jetstream consumer for DELETE operations

     

       69
       69
       +
       // Returns ErrVoteNotFound for soft-deleted votes

     

       69
       70
        
       func (r *postgresVoteRepo) GetByURI(ctx context.Context, uri string) (*votes.Vote, error) {

     

       70
       71
        
       	query := `

     

       71
       72
        
       		SELECT

     
···

       73
       74
        
       			subject_uri, subject_cid, direction,

     

       74
       75
        
       			created_at, indexed_at, deleted_at

     

       75
       76
        
       		FROM votes

     

       76
       76
       -
       		WHERE uri = $1

     

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

     

       77
       78
        
       	`

     

       78
       79
        
       

     

       79
       80
        
       	var vote votes.Vote

+285

internal/atproto/oauth/dev_auth_resolver.go

···

       1
       1
       +
       //go:build dev

     

       2
       2
       +
       

     

       3
       3
       +
       package oauth

     

       4
       4
       +
       

     

       5
       5
       +
       import (

     

       6
       6
       +
       	"context"

     

       7
       7
       +
       	"encoding/json"

     

       8
       8
       +
       	"fmt"

     

       9
       9
       +
       	"log/slog"

     

       10
       10
       +
       	"net/http"

     

       11
       11
       +
       	"net/url"

     

       12
       12
       +
       	"strings"

     

       13
       13
       +
       

     

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

     

       15
       15
       +
       	"github.com/bluesky-social/indigo/atproto/identity"

     

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

     

       17
       17
       +
       )

     

       18
       18
       +
       

     

       19
       19
       +
       // DevAuthResolver is a custom OAuth resolver that allows HTTP localhost URLs for development.

     

       20
       20
       +
       // The standard indigo OAuth resolver requires HTTPS and no port numbers, which breaks local testing.

     

       21
       21
       +
       type DevAuthResolver struct {

     

       22
       22
       +
       	Client         *http.Client

     

       23
       23
       +
       	UserAgent      string

     

       24
       24
       +
       	PDSURL         string // For resolving handles via local PDS

     

       25
       25
       +
       	handleResolver *DevHandleResolver

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       // ProtectedResourceMetadata matches the OAuth protected resource metadata document format

     

       29
       29
       +
       type ProtectedResourceMetadata struct {

     

       30
       30
       +
       	Resource             string   `json:"resource"`

     

       31
       31
       +
       	AuthorizationServers []string `json:"authorization_servers"`

     

       32
       32
       +
       }

     

       33
       33
       +
       

     

       34
       34
       +
       // NewDevAuthResolver creates a resolver that accepts localhost HTTP URLs

     

       35
       35
       +
       func NewDevAuthResolver(pdsURL string, allowPrivateIPs bool) *DevAuthResolver {

     

       36
       36
       +
       	resolver := &DevAuthResolver{

     

       37
       37
       +
       		Client:    NewSSRFSafeHTTPClient(allowPrivateIPs),

     

       38
       38
       +
       		UserAgent: "Coves/1.0",

     

       39
       39
       +
       		PDSURL:    pdsURL,

     

       40
       40
       +
       	}

     

       41
       41
       +
       	// Create handle resolver for resolving handles via local PDS

     

       42
       42
       +
       	if pdsURL != "" {

     

       43
       43
       +
       		resolver.handleResolver = NewDevHandleResolver(pdsURL, allowPrivateIPs)

     

       44
       44
       +
       	}

     

       45
       45
       +
       	return resolver

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       // ResolveAuthServerURL resolves a PDS URL to an auth server URL.

     

       49
       49
       +
       // Unlike indigo's standard resolver, this allows HTTP and ports for localhost.

     

       50
       50
       +
       func (r *DevAuthResolver) ResolveAuthServerURL(ctx context.Context, hostURL string) (string, error) {

     

       51
       51
       +
       	u, err := url.Parse(hostURL)

     

       52
       52
       +
       	if err != nil {

     

       53
       53
       +
       		return "", err

     

       54
       54
       +
       	}

     

       55
       55
       +
       

     

       56
       56
       +
       	// For localhost, allow HTTP and port numbers

     

       57
       57
       +
       	isLocalhost := u.Hostname() == "localhost" || u.Hostname() == "127.0.0.1"

     

       58
       58
       +
       	if !isLocalhost {

     

       59
       59
       +
       		// For non-localhost, enforce HTTPS and no port (standard rules)

     

       60
       60
       +
       		if u.Scheme != "https" || u.Port() != "" {

     

       61
       61
       +
       			return "", fmt.Errorf("not a valid public host URL: %s", hostURL)

     

       62
       62
       +
       		}

     

       63
       63
       +
       	}

     

       64
       64
       +
       

     

       65
       65
       +
       	// Build the protected resource document URL

     

       66
       66
       +
       	var docURL string

     

       67
       67
       +
       	if isLocalhost {

     

       68
       68
       +
       		// For localhost, preserve the port and use HTTP

     

       69
       69
       +
       		port := u.Port()

     

       70
       70
       +
       		if port == "" {

     

       71
       71
       +
       			port = "3001" // Default PDS port

     

       72
       72
       +
       		}

     

       73
       73
       +
       		docURL = fmt.Sprintf("http://%s:%s/.well-known/oauth-protected-resource", u.Hostname(), port)

     

       74
       74
       +
       	} else {

     

       75
       75
       +
       		docURL = fmt.Sprintf("https://%s/.well-known/oauth-protected-resource", u.Hostname())

     

       76
       76
       +
       	}

     

       77
       77
       +
       

     

       78
       78
       +
       	// Fetch the protected resource document

     

       79
       79
       +
       	req, err := http.NewRequestWithContext(ctx, "GET", docURL, nil)

     

       80
       80
       +
       	if err != nil {

     

       81
       81
       +
       		return "", err

     

       82
       82
       +
       	}

     

       83
       83
       +
       	if r.UserAgent != "" {

     

       84
       84
       +
       		req.Header.Set("User-Agent", r.UserAgent)

     

       85
       85
       +
       	}

     

       86
       86
       +
       

     

       87
       87
       +
       	resp, err := r.Client.Do(req)

     

       88
       88
       +
       	if err != nil {

     

       89
       89
       +
       		return "", fmt.Errorf("fetching protected resource document: %w", err)

     

       90
       90
       +
       	}

     

       91
       91
       +
       	defer resp.Body.Close()

     

       92
       92
       +
       

     

       93
       93
       +
       	if resp.StatusCode != http.StatusOK {

     

       94
       94
       +
       		return "", fmt.Errorf("HTTP error fetching protected resource document: %d", resp.StatusCode)

     

       95
       95
       +
       	}

     

       96
       96
       +
       

     

       97
       97
       +
       	var body ProtectedResourceMetadata

     

       98
       98
       +
       	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {

     

       99
       99
       +
       		return "", fmt.Errorf("invalid protected resource document: %w", err)

     

       100
       100
       +
       	}

     

       101
       101
       +
       

     

       102
       102
       +
       	if len(body.AuthorizationServers) < 1 {

     

       103
       103
       +
       		return "", fmt.Errorf("no auth server URL in protected resource document")

     

       104
       104
       +
       	}

     

       105
       105
       +
       

     

       106
       106
       +
       	authURL := body.AuthorizationServers[0]

     

       107
       107
       +
       

     

       108
       108
       +
       	// Validate the auth server URL (with localhost exception)

     

       109
       109
       +
       	au, err := url.Parse(authURL)

     

       110
       110
       +
       	if err != nil {

     

       111
       111
       +
       		return "", fmt.Errorf("invalid auth server URL: %w", err)

     

       112
       112
       +
       	}

     

       113
       113
       +
       

     

       114
       114
       +
       	authIsLocalhost := au.Hostname() == "localhost" || au.Hostname() == "127.0.0.1"

     

       115
       115
       +
       	if !authIsLocalhost {

     

       116
       116
       +
       		if au.Scheme != "https" || au.Port() != "" {

     

       117
       117
       +
       			return "", fmt.Errorf("invalid auth server URL: %s", authURL)

     

       118
       118
       +
       		}

     

       119
       119
       +
       	}

     

       120
       120
       +
       

     

       121
       121
       +
       	return authURL, nil

     

       122
       122
       +
       }

     

       123
       123
       +
       

     

       124
       124
       +
       // ResolveAuthServerMetadataDev fetches OAuth server metadata from a given auth server URL.

     

       125
       125
       +
       // Unlike indigo's resolver, this allows HTTP and ports for localhost.

     

       126
       126
       +
       func (r *DevAuthResolver) ResolveAuthServerMetadataDev(ctx context.Context, serverURL string) (*oauthlib.AuthServerMetadata, error) {

     

       127
       127
       +
       	u, err := url.Parse(serverURL)

     

       128
       128
       +
       	if err != nil {

     

       129
       129
       +
       		return nil, err

     

       130
       130
       +
       	}

     

       131
       131
       +
       

     

       132
       132
       +
       	// Build metadata URL - preserve port for localhost

     

       133
       133
       +
       	var metaURL string

     

       134
       134
       +
       	isLocalhost := u.Hostname() == "localhost" || u.Hostname() == "127.0.0.1"

     

       135
       135
       +
       	if isLocalhost && u.Port() != "" {

     

       136
       136
       +
       		metaURL = fmt.Sprintf("%s://%s:%s/.well-known/oauth-authorization-server", u.Scheme, u.Hostname(), u.Port())

     

       137
       137
       +
       	} else if isLocalhost {

     

       138
       138
       +
       		metaURL = fmt.Sprintf("%s://%s/.well-known/oauth-authorization-server", u.Scheme, u.Hostname())

     

       139
       139
       +
       	} else {

     

       140
       140
       +
       		metaURL = fmt.Sprintf("https://%s/.well-known/oauth-authorization-server", u.Hostname())

     

       141
       141
       +
       	}

     

       142
       142
       +
       

     

       143
       143
       +
       	slog.Debug("dev mode: fetching auth server metadata", "url", metaURL)

     

       144
       144
       +
       

     

       145
       145
       +
       	req, err := http.NewRequestWithContext(ctx, "GET", metaURL, nil)

     

       146
       146
       +
       	if err != nil {

     

       147
       147
       +
       		return nil, err

     

       148
       148
       +
       	}

     

       149
       149
       +
       	if r.UserAgent != "" {

     

       150
       150
       +
       		req.Header.Set("User-Agent", r.UserAgent)

     

       151
       151
       +
       	}

     

       152
       152
       +
       

     

       153
       153
       +
       	resp, err := r.Client.Do(req)

     

       154
       154
       +
       	if err != nil {

     

       155
       155
       +
       		return nil, fmt.Errorf("fetching auth server metadata: %w", err)

     

       156
       156
       +
       	}

     

       157
       157
       +
       	defer resp.Body.Close()

     

       158
       158
       +
       

     

       159
       159
       +
       	if resp.StatusCode != http.StatusOK {

     

       160
       160
       +
       		return nil, fmt.Errorf("HTTP error fetching auth server metadata: %d", resp.StatusCode)

     

       161
       161
       +
       	}

     

       162
       162
       +
       

     

       163
       163
       +
       	var metadata oauthlib.AuthServerMetadata

     

       164
       164
       +
       	if err := json.NewDecoder(resp.Body).Decode(&metadata); err != nil {

     

       165
       165
       +
       		return nil, fmt.Errorf("invalid auth server metadata: %w", err)

     

       166
       166
       +
       	}

     

       167
       167
       +
       

     

       168
       168
       +
       	// Skip validation for localhost (indigo's Validate checks HTTPS)

     

       169
       169
       +
       	if !isLocalhost {

     

       170
       170
       +
       		if err := metadata.Validate(serverURL); err != nil {

     

       171
       171
       +
       			return nil, fmt.Errorf("invalid auth server metadata: %w", err)

     

       172
       172
       +
       		}

     

       173
       173
       +
       	}

     

       174
       174
       +
       

     

       175
       175
       +
       	return &metadata, nil

     

       176
       176
       +
       }

     

       177
       177
       +
       

     

       178
       178
       +
       // StartDevAuthFlow performs OAuth flow for localhost development.

     

       179
       179
       +
       // This bypasses indigo's HTTPS validation for the auth server URL.

     

       180
       180
       +
       // It resolves the identity, gets the PDS endpoint, fetches auth server metadata,

     

       181
       181
       +
       // and returns a redirect URL for the user to approve.

     

       182
       182
       +
       func (r *DevAuthResolver) StartDevAuthFlow(ctx context.Context, client *OAuthClient, identifier string, dir identity.Directory) (string, error) {

     

       183
       183
       +
       	var accountDID syntax.DID

     

       184
       184
       +
       	var pdsEndpoint string

     

       185
       185
       +
       

     

       186
       186
       +
       	// Check if identifier is a handle or DID

     

       187
       187
       +
       	if strings.HasPrefix(identifier, "did:") {

     

       188
       188
       +
       		// It's a DID - look up via directory (PLC)

     

       189
       189
       +
       		atid, err := syntax.ParseAtIdentifier(identifier)

     

       190
       190
       +
       		if err != nil {

     

       191
       191
       +
       			return "", fmt.Errorf("not a valid DID (%s): %w", identifier, err)

     

       192
       192
       +
       		}

     

       193
       193
       +
       		ident, err := dir.Lookup(ctx, *atid)

     

       194
       194
       +
       		if err != nil {

     

       195
       195
       +
       			return "", fmt.Errorf("failed to resolve DID (%s): %w", identifier, err)

     

       196
       196
       +
       		}

     

       197
       197
       +
       		accountDID = ident.DID

     

       198
       198
       +
       		pdsEndpoint = ident.PDSEndpoint()

     

       199
       199
       +
       	} else {

     

       200
       200
       +
       		// It's a handle - resolve via local PDS first

     

       201
       201
       +
       		if r.handleResolver == nil {

     

       202
       202
       +
       			return "", fmt.Errorf("handle resolution not configured (PDS URL not set)")

     

       203
       203
       +
       		}

     

       204
       204
       +
       

     

       205
       205
       +
       		// Resolve handle to DID via local PDS

     

       206
       206
       +
       		did, err := r.handleResolver.ResolveHandle(ctx, identifier)

     

       207
       207
       +
       		if err != nil {

     

       208
       208
       +
       			return "", fmt.Errorf("failed to resolve handle via PDS (%s): %w", identifier, err)

     

       209
       209
       +
       		}

     

       210
       210
       +
       		if did == "" {

     

       211
       211
       +
       			return "", fmt.Errorf("handle not found: %s", identifier)

     

       212
       212
       +
       		}

     

       213
       213
       +
       

     

       214
       214
       +
       		slog.Info("dev mode: resolved handle via local PDS", "handle", identifier, "did", did)

     

       215
       215
       +
       

     

       216
       216
       +
       		// Parse the DID

     

       217
       217
       +
       		parsedDID, err := syntax.ParseDID(did)

     

       218
       218
       +
       		if err != nil {

     

       219
       219
       +
       			return "", fmt.Errorf("invalid DID from PDS (%s): %w", did, err)

     

       220
       220
       +
       		}

     

       221
       221
       +
       		accountDID = parsedDID

     

       222
       222
       +
       

     

       223
       223
       +
       		// Now look up the DID document via PLC to get PDS endpoint

     

       224
       224
       +
       		atid, err := syntax.ParseAtIdentifier(did)

     

       225
       225
       +
       		if err != nil {

     

       226
       226
       +
       			return "", fmt.Errorf("not a valid DID (%s): %w", did, err)

     

       227
       227
       +
       		}

     

       228
       228
       +
       		ident, err := dir.Lookup(ctx, *atid)

     

       229
       229
       +
       		if err != nil {

     

       230
       230
       +
       			return "", fmt.Errorf("failed to resolve DID document (%s): %w", did, err)

     

       231
       231
       +
       		}

     

       232
       232
       +
       		pdsEndpoint = ident.PDSEndpoint()

     

       233
       233
       +
       	}

     

       234
       234
       +
       

     

       235
       235
       +
       	if pdsEndpoint == "" {

     

       236
       236
       +
       		return "", fmt.Errorf("identity does not link to an atproto host (PDS)")

     

       237
       237
       +
       	}

     

       238
       238
       +
       

     

       239
       239
       +
       	slog.Debug("dev mode: resolving auth server",

     

       240
       240
       +
       		"did", accountDID,

     

       241
       241
       +
       		"pds", pdsEndpoint)

     

       242
       242
       +
       

     

       243
       243
       +
       	// Resolve auth server URL (allowing HTTP for localhost)

     

       244
       244
       +
       	authServerURL, err := r.ResolveAuthServerURL(ctx, pdsEndpoint)

     

       245
       245
       +
       	if err != nil {

     

       246
       246
       +
       		return "", fmt.Errorf("resolving auth server: %w", err)

     

       247
       247
       +
       	}

     

       248
       248
       +
       

     

       249
       249
       +
       	slog.Info("dev mode: resolved auth server", "url", authServerURL)

     

       250
       250
       +
       

     

       251
       251
       +
       	// Fetch auth server metadata using our dev-friendly resolver

     

       252
       252
       +
       	authMeta, err := r.ResolveAuthServerMetadataDev(ctx, authServerURL)

     

       253
       253
       +
       	if err != nil {

     

       254
       254
       +
       		return "", fmt.Errorf("fetching auth server metadata: %w", err)

     

       255
       255
       +
       	}

     

       256
       256
       +
       

     

       257
       257
       +
       	slog.Debug("dev mode: got auth server metadata",

     

       258
       258
       +
       		"issuer", authMeta.Issuer,

     

       259
       259
       +
       		"authorization_endpoint", authMeta.AuthorizationEndpoint,

     

       260
       260
       +
       		"token_endpoint", authMeta.TokenEndpoint)

     

       261
       261
       +
       

     

       262
       262
       +
       	// Send auth request (PAR) using indigo's method

     

       263
       263
       +
       	info, err := client.ClientApp.SendAuthRequest(ctx, authMeta, client.Config.Scopes, identifier)

     

       264
       264
       +
       	if err != nil {

     

       265
       265
       +
       		return "", fmt.Errorf("auth request failed: %w", err)

     

       266
       266
       +
       	}

     

       267
       267
       +
       

     

       268
       268
       +
       	// Set the account DID

     

       269
       269
       +
       	info.AccountDID = &accountDID

     

       270
       270
       +
       

     

       271
       271
       +
       	// Persist auth request info

     

       272
       272
       +
       	client.ClientApp.Store.SaveAuthRequestInfo(ctx, *info)

     

       273
       273
       +
       

     

       274
       274
       +
       	// Build redirect URL

     

       275
       275
       +
       	params := url.Values{}

     

       276
       276
       +
       	params.Set("client_id", client.ClientApp.Config.ClientID)

     

       277
       277
       +
       	params.Set("request_uri", info.RequestURI)

     

       278
       278
       +
       

     

       279
       279
       +
       	authEndpoint := authMeta.AuthorizationEndpoint

     

       280
       280
       +
       	redirectURL := fmt.Sprintf("%s?%s", authEndpoint, params.Encode())

     

       281
       281
       +
       

     

       282
       282
       +
       	slog.Info("dev mode: OAuth redirect URL built", "url_prefix", authEndpoint)

     

       283
       283
       +
       

     

       284
       284
       +
       	return redirectURL, nil

     

       285
       285
       +
       }

+106

internal/atproto/oauth/dev_resolver.go

···

       1
       1
       +
       //go:build dev

     

       2
       2
       +
       

     

       3
       3
       +
       package oauth

     

       4
       4
       +
       

     

       5
       5
       +
       import (

     

       6
       6
       +
       	"context"

     

       7
       7
       +
       	"encoding/json"

     

       8
       8
       +
       	"fmt"

     

       9
       9
       +
       	"log/slog"

     

       10
       10
       +
       	"net/http"

     

       11
       11
       +
       	"net/url"

     

       12
       12
       +
       	"strings"

     

       13
       13
       +
       	"time"

     

       14
       14
       +
       )

     

       15
       15
       +
       

     

       16
       16
       +
       // DevHandleResolver resolves handles via local PDS for development

     

       17
       17
       +
       // This is needed because local handles (e.g., user.local.coves.dev) can't be

     

       18
       18
       +
       // resolved via standard DNS/HTTP well-known methods - they only exist on the local PDS.

     

       19
       19
       +
       type DevHandleResolver struct {

     

       20
       20
       +
       	pdsURL     string

     

       21
       21
       +
       	httpClient *http.Client

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       // NewDevHandleResolver creates a resolver that queries local PDS for handle resolution

     

       25
       25
       +
       func NewDevHandleResolver(pdsURL string, allowPrivateIPs bool) *DevHandleResolver {

     

       26
       26
       +
       	return &DevHandleResolver{

     

       27
       27
       +
       		pdsURL:     strings.TrimSuffix(pdsURL, "/"),

     

       28
       28
       +
       		httpClient: NewSSRFSafeHTTPClient(allowPrivateIPs),

     

       29
       29
       +
       	}

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       // ResolveHandle queries the local PDS to resolve a handle to a DID

     

       33
       33
       +
       // Returns the DID if successful, or empty string if not found

     

       34
       34
       +
       func (r *DevHandleResolver) ResolveHandle(ctx context.Context, handle string) (string, error) {

     

       35
       35
       +
       	if r.pdsURL == "" {

     

       36
       36
       +
       		return "", fmt.Errorf("PDS URL not configured")

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	// Build the resolve handle URL

     

       40
       40
       +
       	resolveURL := fmt.Sprintf("%s/xrpc/com.atproto.identity.resolveHandle?handle=%s",

     

       41
       41
       +
       		r.pdsURL, url.QueryEscape(handle))

     

       42
       42
       +
       

     

       43
       43
       +
       	// Create request with context and timeout

     

       44
       44
       +
       	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)

     

       45
       45
       +
       	defer cancel()

     

       46
       46
       +
       

     

       47
       47
       +
       	req, err := http.NewRequestWithContext(ctx, "GET", resolveURL, nil)

     

       48
       48
       +
       	if err != nil {

     

       49
       49
       +
       		return "", fmt.Errorf("failed to create request: %w", err)

     

       50
       50
       +
       	}

     

       51
       51
       +
       	req.Header.Set("User-Agent", "Coves/1.0")

     

       52
       52
       +
       

     

       53
       53
       +
       	// Execute request

     

       54
       54
       +
       	resp, err := r.httpClient.Do(req)

     

       55
       55
       +
       	if err != nil {

     

       56
       56
       +
       		return "", fmt.Errorf("failed to query PDS: %w", err)

     

       57
       57
       +
       	}

     

       58
       58
       +
       	defer resp.Body.Close()

     

       59
       59
       +
       

     

       60
       60
       +
       	// Check response status

     

       61
       61
       +
       	if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusBadRequest {

     

       62
       62
       +
       		return "", nil // Handle not found

     

       63
       63
       +
       	}

     

       64
       64
       +
       	if resp.StatusCode != http.StatusOK {

     

       65
       65
       +
       		return "", fmt.Errorf("PDS returned status %d", resp.StatusCode)

     

       66
       66
       +
       	}

     

       67
       67
       +
       

     

       68
       68
       +
       	// Parse response

     

       69
       69
       +
       	var result struct {

     

       70
       70
       +
       		DID string `json:"did"`

     

       71
       71
       +
       	}

     

       72
       72
       +
       	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {

     

       73
       73
       +
       		return "", fmt.Errorf("failed to parse PDS response: %w", err)

     

       74
       74
       +
       	}

     

       75
       75
       +
       

     

       76
       76
       +
       	if result.DID == "" {

     

       77
       77
       +
       		return "", nil // No DID in response

     

       78
       78
       +
       	}

     

       79
       79
       +
       

     

       80
       80
       +
       	slog.Debug("resolved handle via local PDS",

     

       81
       81
       +
       		"handle", handle,

     

       82
       82
       +
       		"did", result.DID,

     

       83
       83
       +
       		"pds_url", r.pdsURL)

     

       84
       84
       +
       

     

       85
       85
       +
       	return result.DID, nil

     

       86
       86
       +
       }

     

       87
       87
       +
       

     

       88
       88
       +
       // ResolveIdentifier attempts to resolve a handle to DID, or returns the DID if already provided

     

       89
       89
       +
       // This is the main entry point for the handlers

     

       90
       90
       +
       func (r *DevHandleResolver) ResolveIdentifier(ctx context.Context, identifier string) (string, error) {

     

       91
       91
       +
       	// If it's already a DID, return as-is

     

       92
       92
       +
       	if strings.HasPrefix(identifier, "did:") {

     

       93
       93
       +
       		return identifier, nil

     

       94
       94
       +
       	}

     

       95
       95
       +
       

     

       96
       96
       +
       	// Try to resolve the handle via local PDS

     

       97
       97
       +
       	did, err := r.ResolveHandle(ctx, identifier)

     

       98
       98
       +
       	if err != nil {

     

       99
       99
       +
       		return "", fmt.Errorf("failed to resolve handle via PDS: %w", err)

     

       100
       100
       +
       	}

     

       101
       101
       +
       	if did == "" {

     

       102
       102
       +
       		return "", fmt.Errorf("handle not found on local PDS: %s", identifier)

     

       103
       103
       +
       	}

     

       104
       104
       +
       

     

       105
       105
       +
       	return did, nil

     

       106
       106
       +
       }

+41

internal/atproto/oauth/dev_stubs.go

···

       1
       1
       +
       //go:build !dev

     

       2
       2
       +
       

     

       3
       3
       +
       package oauth

     

       4
       4
       +
       

     

       5
       5
       +
       import (

     

       6
       6
       +
       	"context"

     

       7
       7
       +
       

     

       8
       8
       +
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // DevHandleResolver is a stub for production builds.

     

       12
       12
       +
       // The actual implementation is in dev_resolver.go (only compiled with -tags dev).

     

       13
       13
       +
       type DevHandleResolver struct{}

     

       14
       14
       +
       

     

       15
       15
       +
       // NewDevHandleResolver returns nil in production builds.

     

       16
       16
       +
       // Dev mode features are only available when built with -tags dev.

     

       17
       17
       +
       func NewDevHandleResolver(pdsURL string, allowPrivateIPs bool) *DevHandleResolver {

     

       18
       18
       +
       	return nil

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       // ResolveHandle is a stub that should never be called in production.

     

       22
       22
       +
       // The nil check in handlers.go prevents this from being reached.

     

       23
       23
       +
       func (r *DevHandleResolver) ResolveHandle(ctx context.Context, handle string) (string, error) {

     

       24
       24
       +
       	panic("dev mode: ResolveHandle called in production build - this should never happen")

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       // DevAuthResolver is a stub for production builds.

     

       28
       28
       +
       // The actual implementation is in dev_auth_resolver.go (only compiled with -tags dev).

     

       29
       29
       +
       type DevAuthResolver struct{}

     

       30
       30
       +
       

     

       31
       31
       +
       // NewDevAuthResolver returns nil in production builds.

     

       32
       32
       +
       // Dev mode features are only available when built with -tags dev.

     

       33
       33
       +
       func NewDevAuthResolver(pdsURL string, allowPrivateIPs bool) *DevAuthResolver {

     

       34
       34
       +
       	return nil

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       // StartDevAuthFlow is a stub that should never be called in production.

     

       38
       38
       +
       // The nil check in handlers.go prevents this from being reached.

     

       39
       39
       +
       func (r *DevAuthResolver) StartDevAuthFlow(ctx context.Context, client *OAuthClient, identifier string, dir identity.Directory) (string, error) {

     

       40
       40
       +
       	panic("dev mode: StartDevAuthFlow called in production build - this should never happen")

     

       41
       41
       +
       }

+5 -1

scripts/dev-run.sh

···

       1
       1
        
       #!/bin/bash

     

       2
       2
        
       # Development server runner - loads .env.dev before starting

     

       3
       3
       +
       # Uses -tags dev to include dev-only code (localhost OAuth resolvers, etc.)

     

       3
       4
        
       

     

       4
       5
        
       set -a  # automatically export all variables

     

       5
       6
        
       source .env.dev

     
···

       9
       10
        
       echo "   IS_DEV_ENV: $IS_DEV_ENV"

     

       10
       11
        
       echo "   PLC_DIRECTORY_URL: $PLC_DIRECTORY_URL"

     

       11
       12
        
       echo "   JETSTREAM_URL: $JETSTREAM_URL"

     

       13
       13
       +
       echo "   APPVIEW_PUBLIC_URL: $APPVIEW_PUBLIC_URL"

     

       14
       14
       +
       echo "   PDS_URL: $PDS_URL"

     

       15
       15
       +
       echo "   Build tags: dev"

     

       12
       16
        
       echo ""

     

       13
       17
        
       

     

       14
       14
       -
       go run ./cmd/server

     

       18
       18
       +
       go run -tags dev ./cmd/server

+267

cmd/reindex-votes/main.go

···

       1
       1
       +
       // cmd/reindex-votes/main.go

     

       2
       2
       +
       // Quick tool to reindex votes from PDS to AppView database

     

       3
       3
       +
       package main

     

       4
       4
       +
       

     

       5
       5
       +
       import (

     

       6
       6
       +
       	"context"

     

       7
       7
       +
       	"database/sql"

     

       8
       8
       +
       	"encoding/json"

     

       9
       9
       +
       	"fmt"

     

       10
       10
       +
       	"log"

     

       11
       11
       +
       	"net/http"

     

       12
       12
       +
       	"net/url"

     

       13
       13
       +
       	"os"

     

       14
       14
       +
       	"strings"

     

       15
       15
       +
       	"time"

     

       16
       16
       +
       

     

       17
       17
       +
       	_ "github.com/lib/pq"

     

       18
       18
       +
       )

     

       19
       19
       +
       

     

       20
       20
       +
       type ListRecordsResponse struct {

     

       21
       21
       +
       	Records []Record `json:"records"`

     

       22
       22
       +
       	Cursor  string   `json:"cursor"`

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       type Record struct {

     

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

     

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

     

       28
       28
       +
       	Value map[string]interface{} `json:"value"`

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       func main() {

     

       32
       32
       +
       	// Get config from env

     

       33
       33
       +
       	dbURL := os.Getenv("DATABASE_URL")

     

       34
       34
       +
       	if dbURL == "" {

     

       35
       35
       +
       		dbURL = "postgres://dev_user:dev_password@localhost:5435/coves_dev?sslmode=disable"

     

       36
       36
       +
       	}

     

       37
       37
       +
       	pdsURL := os.Getenv("PDS_URL")

     

       38
       38
       +
       	if pdsURL == "" {

     

       39
       39
       +
       		pdsURL = "http://localhost:3001"

     

       40
       40
       +
       	}

     

       41
       41
       +
       

     

       42
       42
       +
       	log.Printf("Connecting to database...")

     

       43
       43
       +
       	db, err := sql.Open("postgres", dbURL)

     

       44
       44
       +
       	if err != nil {

     

       45
       45
       +
       		log.Fatalf("Failed to connect to database: %v", err)

     

       46
       46
       +
       	}

     

       47
       47
       +
       	defer db.Close()

     

       48
       48
       +
       

     

       49
       49
       +
       	ctx := context.Background()

     

       50
       50
       +
       

     

       51
       51
       +
       	// Get all accounts directly from the PDS

     

       52
       52
       +
       	log.Printf("Fetching accounts from PDS (%s)...", pdsURL)

     

       53
       53
       +
       	dids, err := fetchAllAccountsFromPDS(pdsURL)

     

       54
       54
       +
       	if err != nil {

     

       55
       55
       +
       		log.Fatalf("Failed to fetch accounts from PDS: %v", err)

     

       56
       56
       +
       	}

     

       57
       57
       +
       	log.Printf("Found %d accounts on PDS to check for votes", len(dids))

     

       58
       58
       +
       

     

       59
       59
       +
       	// Reset vote counts first

     

       60
       60
       +
       	log.Printf("Resetting all vote counts...")

     

       61
       61
       +
       	if _, err := db.ExecContext(ctx, "DELETE FROM votes"); err != nil {

     

       62
       62
       +
       		log.Fatalf("Failed to clear votes table: %v", err)

     

       63
       63
       +
       	}

     

       64
       64
       +
       	if _, err := db.ExecContext(ctx, "UPDATE posts SET upvote_count = 0, downvote_count = 0, score = 0"); err != nil {

     

       65
       65
       +
       		log.Fatalf("Failed to reset post vote counts: %v", err)

     

       66
       66
       +
       	}

     

       67
       67
       +
       	if _, err := db.ExecContext(ctx, "UPDATE comments SET upvote_count = 0, downvote_count = 0, score = 0"); err != nil {

     

       68
       68
       +
       		log.Fatalf("Failed to reset comment vote counts: %v", err)

     

       69
       69
       +
       	}

     

       70
       70
       +
       

     

       71
       71
       +
       	// For each user, fetch their votes from PDS

     

       72
       72
       +
       	totalVotes := 0

     

       73
       73
       +
       	for _, did := range dids {

     

       74
       74
       +
       		votes, err := fetchVotesFromPDS(pdsURL, did)

     

       75
       75
       +
       		if err != nil {

     

       76
       76
       +
       			log.Printf("Warning: failed to fetch votes for %s: %v", did, err)

     

       77
       77
       +
       			continue

     

       78
       78
       +
       		}

     

       79
       79
       +
       

     

       80
       80
       +
       		if len(votes) == 0 {

     

       81
       81
       +
       			continue

     

       82
       82
       +
       		}

     

       83
       83
       +
       

     

       84
       84
       +
       		log.Printf("Found %d votes for %s", len(votes), did)

     

       85
       85
       +
       

     

       86
       86
       +
       		// Index each vote

     

       87
       87
       +
       		for _, vote := range votes {

     

       88
       88
       +
       			if err := indexVote(ctx, db, did, vote); err != nil {

     

       89
       89
       +
       				log.Printf("Warning: failed to index vote %s: %v", vote.URI, err)

     

       90
       90
       +
       				continue

     

       91
       91
       +
       			}

     

       92
       92
       +
       			totalVotes++

     

       93
       93
       +
       		}

     

       94
       94
       +
       	}

     

       95
       95
       +
       

     

       96
       96
       +
       	log.Printf("✓ Reindexed %d votes from PDS", totalVotes)

     

       97
       97
       +
       }

     

       98
       98
       +
       

     

       99
       99
       +
       // fetchAllAccountsFromPDS queries the PDS sync API to get all repo DIDs

     

       100
       100
       +
       func fetchAllAccountsFromPDS(pdsURL string) ([]string, error) {

     

       101
       101
       +
       	// Use com.atproto.sync.listRepos to get all repos on this PDS

     

       102
       102
       +
       	var allDIDs []string

     

       103
       103
       +
       	cursor := ""

     

       104
       104
       +
       

     

       105
       105
       +
       	for {

     

       106
       106
       +
       		reqURL := fmt.Sprintf("%s/xrpc/com.atproto.sync.listRepos?limit=100", pdsURL)

     

       107
       107
       +
       		if cursor != "" {

     

       108
       108
       +
       			reqURL += "&cursor=" + url.QueryEscape(cursor)

     

       109
       109
       +
       		}

     

       110
       110
       +
       

     

       111
       111
       +
       		resp, err := http.Get(reqURL)

     

       112
       112
       +
       		if err != nil {

     

       113
       113
       +
       			return nil, fmt.Errorf("HTTP request failed: %w", err)

     

       114
       114
       +
       		}

     

       115
       115
       +
       		defer resp.Body.Close()

     

       116
       116
       +
       

     

       117
       117
       +
       		if resp.StatusCode != 200 {

     

       118
       118
       +
       			return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)

     

       119
       119
       +
       		}

     

       120
       120
       +
       

     

       121
       121
       +
       		var result struct {

     

       122
       122
       +
       			Repos []struct {

     

       123
       123
       +
       				DID string `json:"did"`

     

       124
       124
       +
       			} `json:"repos"`

     

       125
       125
       +
       			Cursor string `json:"cursor"`

     

       126
       126
       +
       		}

     

       127
       127
       +
       		if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {

     

       128
       128
       +
       			return nil, fmt.Errorf("failed to decode response: %w", err)

     

       129
       129
       +
       		}

     

       130
       130
       +
       

     

       131
       131
       +
       		for _, repo := range result.Repos {

     

       132
       132
       +
       			allDIDs = append(allDIDs, repo.DID)

     

       133
       133
       +
       		}

     

       134
       134
       +
       

     

       135
       135
       +
       		if result.Cursor == "" {

     

       136
       136
       +
       			break

     

       137
       137
       +
       		}

     

       138
       138
       +
       		cursor = result.Cursor

     

       139
       139
       +
       	}

     

       140
       140
       +
       

     

       141
       141
       +
       	return allDIDs, nil

     

       142
       142
       +
       }

     

       143
       143
       +
       

     

       144
       144
       +
       func fetchVotesFromPDS(pdsURL, did string) ([]Record, error) {

     

       145
       145
       +
       	var allRecords []Record

     

       146
       146
       +
       	cursor := ""

     

       147
       147
       +
       	collection := "social.coves.feed.vote"

     

       148
       148
       +
       

     

       149
       149
       +
       	for {

     

       150
       150
       +
       		reqURL := fmt.Sprintf("%s/xrpc/com.atproto.repo.listRecords?repo=%s&collection=%s&limit=100",

     

       151
       151
       +
       			pdsURL, url.QueryEscape(did), url.QueryEscape(collection))

     

       152
       152
       +
       		if cursor != "" {

     

       153
       153
       +
       			reqURL += "&cursor=" + url.QueryEscape(cursor)

     

       154
       154
       +
       		}

     

       155
       155
       +
       

     

       156
       156
       +
       		resp, err := http.Get(reqURL)

     

       157
       157
       +
       		if err != nil {

     

       158
       158
       +
       			return nil, fmt.Errorf("HTTP request failed: %w", err)

     

       159
       159
       +
       		}

     

       160
       160
       +
       		defer resp.Body.Close()

     

       161
       161
       +
       

     

       162
       162
       +
       		if resp.StatusCode == 400 {

     

       163
       163
       +
       			// User doesn't exist on this PDS or has no records - that's OK

     

       164
       164
       +
       			return nil, nil

     

       165
       165
       +
       		}

     

       166
       166
       +
       		if resp.StatusCode != 200 {

     

       167
       167
       +
       			return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)

     

       168
       168
       +
       		}

     

       169
       169
       +
       

     

       170
       170
       +
       		var result ListRecordsResponse

     

       171
       171
       +
       		if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {

     

       172
       172
       +
       			return nil, fmt.Errorf("failed to decode response: %w", err)

     

       173
       173
       +
       		}

     

       174
       174
       +
       

     

       175
       175
       +
       		allRecords = append(allRecords, result.Records...)

     

       176
       176
       +
       

     

       177
       177
       +
       		if result.Cursor == "" {

     

       178
       178
       +
       			break

     

       179
       179
       +
       		}

     

       180
       180
       +
       		cursor = result.Cursor

     

       181
       181
       +
       	}

     

       182
       182
       +
       

     

       183
       183
       +
       	return allRecords, nil

     

       184
       184
       +
       }

     

       185
       185
       +
       

     

       186
       186
       +
       func indexVote(ctx context.Context, db *sql.DB, voterDID string, record Record) error {

     

       187
       187
       +
       	// Extract vote data from record

     

       188
       188
       +
       	subject, ok := record.Value["subject"].(map[string]interface{})

     

       189
       189
       +
       	if !ok {

     

       190
       190
       +
       		return fmt.Errorf("missing subject")

     

       191
       191
       +
       	}

     

       192
       192
       +
       	subjectURI, _ := subject["uri"].(string)

     

       193
       193
       +
       	subjectCID, _ := subject["cid"].(string)

     

       194
       194
       +
       	direction, _ := record.Value["direction"].(string)

     

       195
       195
       +
       	createdAtStr, _ := record.Value["createdAt"].(string)

     

       196
       196
       +
       

     

       197
       197
       +
       	if subjectURI == "" || direction == "" {

     

       198
       198
       +
       		return fmt.Errorf("invalid vote record: missing required fields")

     

       199
       199
       +
       	}

     

       200
       200
       +
       

     

       201
       201
       +
       	// Parse created_at

     

       202
       202
       +
       	createdAt, err := time.Parse(time.RFC3339, createdAtStr)

     

       203
       203
       +
       	if err != nil {

     

       204
       204
       +
       		createdAt = time.Now()

     

       205
       205
       +
       	}

     

       206
       206
       +
       

     

       207
       207
       +
       	// Extract rkey from URI (at://did/collection/rkey)

     

       208
       208
       +
       	parts := strings.Split(record.URI, "/")

     

       209
       209
       +
       	if len(parts) < 5 {

     

       210
       210
       +
       		return fmt.Errorf("invalid URI format: %s", record.URI)

     

       211
       211
       +
       	}

     

       212
       212
       +
       	rkey := parts[len(parts)-1]

     

       213
       213
       +
       

     

       214
       214
       +
       	// Start transaction

     

       215
       215
       +
       	tx, err := db.BeginTx(ctx, nil)

     

       216
       216
       +
       	if err != nil {

     

       217
       217
       +
       		return fmt.Errorf("failed to begin transaction: %w", err)

     

       218
       218
       +
       	}

     

       219
       219
       +
       	defer tx.Rollback()

     

       220
       220
       +
       

     

       221
       221
       +
       	// Insert vote

     

       222
       222
       +
       	_, err = tx.ExecContext(ctx, `

     

       223
       223
       +
       		INSERT INTO votes (uri, cid, rkey, voter_did, subject_uri, subject_cid, direction, created_at, indexed_at)

     

       224
       224
       +
       		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, NOW())

     

       225
       225
       +
       		ON CONFLICT (uri) DO NOTHING

     

       226
       226
       +
       	`, record.URI, record.CID, rkey, voterDID, subjectURI, subjectCID, direction, createdAt)

     

       227
       227
       +
       	if err != nil {

     

       228
       228
       +
       		return fmt.Errorf("failed to insert vote: %w", err)

     

       229
       229
       +
       	}

     

       230
       230
       +
       

     

       231
       231
       +
       	// Update post/comment counts

     

       232
       232
       +
       	collection := extractCollectionFromURI(subjectURI)

     

       233
       233
       +
       	var updateQuery string

     

       234
       234
       +
       

     

       235
       235
       +
       	switch collection {

     

       236
       236
       +
       	case "social.coves.community.post":

     

       237
       237
       +
       		if direction == "up" {

     

       238
       238
       +
       			updateQuery = `UPDATE posts SET upvote_count = upvote_count + 1, score = upvote_count + 1 - downvote_count WHERE uri = $1 AND deleted_at IS NULL`

     

       239
       239
       +
       		} else {

     

       240
       240
       +
       			updateQuery = `UPDATE posts SET downvote_count = downvote_count + 1, score = upvote_count - (downvote_count + 1) WHERE uri = $1 AND deleted_at IS NULL`

     

       241
       241
       +
       		}

     

       242
       242
       +
       	case "social.coves.community.comment":

     

       243
       243
       +
       		if direction == "up" {

     

       244
       244
       +
       			updateQuery = `UPDATE comments SET upvote_count = upvote_count + 1, score = upvote_count + 1 - downvote_count WHERE uri = $1 AND deleted_at IS NULL`

     

       245
       245
       +
       		} else {

     

       246
       246
       +
       			updateQuery = `UPDATE comments SET downvote_count = downvote_count + 1, score = upvote_count - (downvote_count + 1) WHERE uri = $1 AND deleted_at IS NULL`

     

       247
       247
       +
       		}

     

       248
       248
       +
       	default:

     

       249
       249
       +
       		// Unknown collection, just index the vote

     

       250
       250
       +
       		return tx.Commit()

     

       251
       251
       +
       	}

     

       252
       252
       +
       

     

       253
       253
       +
       	if _, err := tx.ExecContext(ctx, updateQuery, subjectURI); err != nil {

     

       254
       254
       +
       		return fmt.Errorf("failed to update vote counts: %w", err)

     

       255
       255
       +
       	}

     

       256
       256
       +
       

     

       257
       257
       +
       	return tx.Commit()

     

       258
       258
       +
       }

     

       259
       259
       +
       

     

       260
       260
       +
       func extractCollectionFromURI(uri string) string {

     

       261
       261
       +
       	// at://did:plc:xxx/social.coves.community.post/rkey

     

       262
       262
       +
       	parts := strings.Split(uri, "/")

     

       263
       263
       +
       	if len(parts) >= 4 {

     

       264
       264
       +
       		return parts[3]

     

       265
       265
       +
       	}

     

       266
       266
       +
       	return ""

     

       267
       267
       +
       }

+221

internal/core/votes/cache.go

···

       1
       1
       +
       package votes

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"log/slog"

     

       7
       7
       +
       	"strings"

     

       8
       8
       +
       	"sync"

     

       9
       9
       +
       	"time"

     

       10
       10
       +
       

     

       11
       11
       +
       	"Coves/internal/atproto/pds"

     

       12
       12
       +
       )

     

       13
       13
       +
       

     

       14
       14
       +
       // CachedVote represents a vote stored in the cache

     

       15
       15
       +
       type CachedVote struct {

     

       16
       16
       +
       	Direction string // "up" or "down"

     

       17
       17
       +
       	URI       string // vote record URI (at://did/collection/rkey)

     

       18
       18
       +
       	RKey      string // record key

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       // VoteCache provides an in-memory cache of user votes fetched from their PDS.

     

       22
       22
       +
       // This avoids eventual consistency issues with the AppView database.

     

       23
       23
       +
       type VoteCache struct {

     

       24
       24
       +
       	mu     sync.RWMutex

     

       25
       25
       +
       	votes  map[string]map[string]*CachedVote // userDID -> subjectURI -> vote

     

       26
       26
       +
       	expiry map[string]time.Time              // userDID -> expiry time

     

       27
       27
       +
       	ttl    time.Duration

     

       28
       28
       +
       	logger *slog.Logger

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       // NewVoteCache creates a new vote cache with the specified TTL

     

       32
       32
       +
       func NewVoteCache(ttl time.Duration, logger *slog.Logger) *VoteCache {

     

       33
       33
       +
       	if logger == nil {

     

       34
       34
       +
       		logger = slog.Default()

     

       35
       35
       +
       	}

     

       36
       36
       +
       	return &VoteCache{

     

       37
       37
       +
       		votes:  make(map[string]map[string]*CachedVote),

     

       38
       38
       +
       		expiry: make(map[string]time.Time),

     

       39
       39
       +
       		ttl:    ttl,

     

       40
       40
       +
       		logger: logger,

     

       41
       41
       +
       	}

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       // GetVotesForUser returns all cached votes for a user.

     

       45
       45
       +
       // Returns nil if cache is empty or expired for this user.

     

       46
       46
       +
       func (c *VoteCache) GetVotesForUser(userDID string) map[string]*CachedVote {

     

       47
       47
       +
       	c.mu.RLock()

     

       48
       48
       +
       	defer c.mu.RUnlock()

     

       49
       49
       +
       

     

       50
       50
       +
       	// Check if cache exists and is not expired

     

       51
       51
       +
       	expiry, exists := c.expiry[userDID]

     

       52
       52
       +
       	if !exists || time.Now().After(expiry) {

     

       53
       53
       +
       		return nil

     

       54
       54
       +
       	}

     

       55
       55
       +
       

     

       56
       56
       +
       	return c.votes[userDID]

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       // GetVote returns the cached vote for a specific subject, or nil if not found/expired

     

       60
       60
       +
       func (c *VoteCache) GetVote(userDID, subjectURI string) *CachedVote {

     

       61
       61
       +
       	votes := c.GetVotesForUser(userDID)

     

       62
       62
       +
       	if votes == nil {

     

       63
       63
       +
       		return nil

     

       64
       64
       +
       	}

     

       65
       65
       +
       	return votes[subjectURI]

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       // IsCached returns true if the user's votes are cached and not expired

     

       69
       69
       +
       func (c *VoteCache) IsCached(userDID string) bool {

     

       70
       70
       +
       	c.mu.RLock()

     

       71
       71
       +
       	defer c.mu.RUnlock()

     

       72
       72
       +
       

     

       73
       73
       +
       	expiry, exists := c.expiry[userDID]

     

       74
       74
       +
       	return exists && time.Now().Before(expiry)

     

       75
       75
       +
       }

     

       76
       76
       +
       

     

       77
       77
       +
       // SetVotesForUser replaces all cached votes for a user

     

       78
       78
       +
       func (c *VoteCache) SetVotesForUser(userDID string, votes map[string]*CachedVote) {

     

       79
       79
       +
       	c.mu.Lock()

     

       80
       80
       +
       	defer c.mu.Unlock()

     

       81
       81
       +
       

     

       82
       82
       +
       	c.votes[userDID] = votes

     

       83
       83
       +
       	c.expiry[userDID] = time.Now().Add(c.ttl)

     

       84
       84
       +
       

     

       85
       85
       +
       	c.logger.Debug("vote cache updated",

     

       86
       86
       +
       		"user", userDID,

     

       87
       87
       +
       		"vote_count", len(votes),

     

       88
       88
       +
       		"expires_at", c.expiry[userDID])

     

       89
       89
       +
       }

     

       90
       90
       +
       

     

       91
       91
       +
       // SetVote adds or updates a single vote in the cache

     

       92
       92
       +
       func (c *VoteCache) SetVote(userDID, subjectURI string, vote *CachedVote) {

     

       93
       93
       +
       	c.mu.Lock()

     

       94
       94
       +
       	defer c.mu.Unlock()

     

       95
       95
       +
       

     

       96
       96
       +
       	if c.votes[userDID] == nil {

     

       97
       97
       +
       		c.votes[userDID] = make(map[string]*CachedVote)

     

       98
       98
       +
       	}

     

       99
       99
       +
       

     

       100
       100
       +
       	c.votes[userDID][subjectURI] = vote

     

       101
       101
       +
       

     

       102
       102
       +
       	// Always extend expiry on vote action - active users keep their cache fresh

     

       103
       103
       +
       	c.expiry[userDID] = time.Now().Add(c.ttl)

     

       104
       104
       +
       

     

       105
       105
       +
       	c.logger.Debug("vote cached",

     

       106
       106
       +
       		"user", userDID,

     

       107
       107
       +
       		"subject", subjectURI,

     

       108
       108
       +
       		"direction", vote.Direction)

     

       109
       109
       +
       }

     

       110
       110
       +
       

     

       111
       111
       +
       // RemoveVote removes a vote from the cache (for toggle-off)

     

       112
       112
       +
       func (c *VoteCache) RemoveVote(userDID, subjectURI string) {

     

       113
       113
       +
       	c.mu.Lock()

     

       114
       114
       +
       	defer c.mu.Unlock()

     

       115
       115
       +
       

     

       116
       116
       +
       	if c.votes[userDID] != nil {

     

       117
       117
       +
       		delete(c.votes[userDID], subjectURI)

     

       118
       118
       +
       

     

       119
       119
       +
       		// Extend expiry on vote action - active users keep their cache fresh

     

       120
       120
       +
       		c.expiry[userDID] = time.Now().Add(c.ttl)

     

       121
       121
       +
       

     

       122
       122
       +
       		c.logger.Debug("vote removed from cache",

     

       123
       123
       +
       			"user", userDID,

     

       124
       124
       +
       			"subject", subjectURI)

     

       125
       125
       +
       	}

     

       126
       126
       +
       }

     

       127
       127
       +
       

     

       128
       128
       +
       // Invalidate removes all cached votes for a user

     

       129
       129
       +
       func (c *VoteCache) Invalidate(userDID string) {

     

       130
       130
       +
       	c.mu.Lock()

     

       131
       131
       +
       	defer c.mu.Unlock()

     

       132
       132
       +
       

     

       133
       133
       +
       	delete(c.votes, userDID)

     

       134
       134
       +
       	delete(c.expiry, userDID)

     

       135
       135
       +
       

     

       136
       136
       +
       	c.logger.Debug("vote cache invalidated", "user", userDID)

     

       137
       137
       +
       }

     

       138
       138
       +
       

     

       139
       139
       +
       // FetchAndCacheFromPDS fetches all votes from the user's PDS and caches them.

     

       140
       140
       +
       // This should be called on first authenticated request or when cache is expired.

     

       141
       141
       +
       func (c *VoteCache) FetchAndCacheFromPDS(ctx context.Context, pdsClient pds.Client) error {

     

       142
       142
       +
       	userDID := pdsClient.DID()

     

       143
       143
       +
       

     

       144
       144
       +
       	c.logger.Debug("fetching votes from PDS",

     

       145
       145
       +
       		"user", userDID,

     

       146
       146
       +
       		"pds", pdsClient.HostURL())

     

       147
       147
       +
       

     

       148
       148
       +
       	votes, err := c.fetchAllVotesFromPDS(ctx, pdsClient)

     

       149
       149
       +
       	if err != nil {

     

       150
       150
       +
       		return fmt.Errorf("failed to fetch votes from PDS: %w", err)

     

       151
       151
       +
       	}

     

       152
       152
       +
       

     

       153
       153
       +
       	c.SetVotesForUser(userDID, votes)

     

       154
       154
       +
       

     

       155
       155
       +
       	c.logger.Info("vote cache populated from PDS",

     

       156
       156
       +
       		"user", userDID,

     

       157
       157
       +
       		"vote_count", len(votes))

     

       158
       158
       +
       

     

       159
       159
       +
       	return nil

     

       160
       160
       +
       }

     

       161
       161
       +
       

     

       162
       162
       +
       // fetchAllVotesFromPDS paginates through all vote records on the user's PDS

     

       163
       163
       +
       func (c *VoteCache) fetchAllVotesFromPDS(ctx context.Context, pdsClient pds.Client) (map[string]*CachedVote, error) {

     

       164
       164
       +
       	votes := make(map[string]*CachedVote)

     

       165
       165
       +
       	cursor := ""

     

       166
       166
       +
       	const pageSize = 100

     

       167
       167
       +
       	const collection = "social.coves.feed.vote"

     

       168
       168
       +
       

     

       169
       169
       +
       	for {

     

       170
       170
       +
       		result, err := pdsClient.ListRecords(ctx, collection, pageSize, cursor)

     

       171
       171
       +
       		if err != nil {

     

       172
       172
       +
       			if pds.IsAuthError(err) {

     

       173
       173
       +
       				return nil, ErrNotAuthorized

     

       174
       174
       +
       			}

     

       175
       175
       +
       			return nil, fmt.Errorf("listRecords failed: %w", err)

     

       176
       176
       +
       		}

     

       177
       177
       +
       

     

       178
       178
       +
       		for _, rec := range result.Records {

     

       179
       179
       +
       			// Extract subject from record value

     

       180
       180
       +
       			subject, ok := rec.Value["subject"].(map[string]any)

     

       181
       181
       +
       			if !ok {

     

       182
       182
       +
       				continue

     

       183
       183
       +
       			}

     

       184
       184
       +
       

     

       185
       185
       +
       			subjectURI, ok := subject["uri"].(string)

     

       186
       186
       +
       			if !ok || subjectURI == "" {

     

       187
       187
       +
       				continue

     

       188
       188
       +
       			}

     

       189
       189
       +
       

     

       190
       190
       +
       			direction, _ := rec.Value["direction"].(string)

     

       191
       191
       +
       			if direction == "" {

     

       192
       192
       +
       				continue

     

       193
       193
       +
       			}

     

       194
       194
       +
       

     

       195
       195
       +
       			// Extract rkey from URI

     

       196
       196
       +
       			rkey := extractRKeyFromURI(rec.URI)

     

       197
       197
       +
       

     

       198
       198
       +
       			votes[subjectURI] = &CachedVote{

     

       199
       199
       +
       				Direction: direction,

     

       200
       200
       +
       				URI:       rec.URI,

     

       201
       201
       +
       				RKey:      rkey,

     

       202
       202
       +
       			}

     

       203
       203
       +
       		}

     

       204
       204
       +
       

     

       205
       205
       +
       		if result.Cursor == "" {

     

       206
       206
       +
       			break

     

       207
       207
       +
       		}

     

       208
       208
       +
       		cursor = result.Cursor

     

       209
       209
       +
       	}

     

       210
       210
       +
       

     

       211
       211
       +
       	return votes, nil

     

       212
       212
       +
       }

     

       213
       213
       +
       

     

       214
       214
       +
       // extractRKeyFromURI extracts the rkey from an AT-URI (at://did/collection/rkey)

     

       215
       215
       +
       func extractRKeyFromURI(uri string) string {

     

       216
       216
       +
       	parts := strings.Split(uri, "/")

     

       217
       217
       +
       	if len(parts) >= 5 {

     

       218
       218
       +
       		return parts[len(parts)-1]

     

       219
       219
       +
       	}

     

       220
       220
       +
       	return ""

     

       221
       221
       +
       }

+14

internal/core/votes/service.go

···

       44
       44
        
       	// - Deletes the user's vote record from their PDS

     

       45
       45
        
       	// - AppView will soft-delete via Jetstream consumer

     

       46
       46
        
       	DeleteVote(ctx context.Context, session *oauthlib.ClientSessionData, req DeleteVoteRequest) error

     

       47
       47
       +
       

     

       48
       48
       +
       	// EnsureCachePopulated fetches the user's votes from their PDS if not already cached.

     

       49
       49
       +
       	// This should be called before rendering feeds to ensure vote state is available.

     

       50
       50
       +
       	// If cache is already populated and not expired, this is a no-op.

     

       51
       51
       +
       	EnsureCachePopulated(ctx context.Context, session *oauthlib.ClientSessionData) error

     

       52
       52
       +
       

     

       53
       53
       +
       	// GetViewerVote returns the viewer's vote for a specific subject, or nil if not voted.

     

       54
       54
       +
       	// Returns from cache if available, otherwise returns nil (caller should ensure cache is populated).

     

       55
       55
       +
       	GetViewerVote(userDID, subjectURI string) *CachedVote

     

       56
       56
       +
       

     

       57
       57
       +
       	// GetViewerVotesForSubjects returns the viewer's votes for multiple subjects.

     

       58
       58
       +
       	// Returns a map of subjectURI -> CachedVote for subjects the user has voted on.

     

       59
       59
       +
       	// This is efficient for batch lookups when rendering feeds.

     

       60
       60
       +
       	GetViewerVotesForSubjects(userDID string, subjectURIs []string) map[string]*CachedVote

     

       47
       61
        
       }

     

       48
       62
        
       

     

       49
       63
        
       // CreateVoteRequest contains the parameters for creating a vote

+84 -2

internal/core/votes/service_impl.go

···

       30
       30
        
       	oauthStore       oauth.ClientAuthStore

     

       31
       31
        
       	logger           *slog.Logger

     

       32
       32
        
       	pdsClientFactory PDSClientFactory // Optional, for testing. If nil, uses OAuth.

     

       33
       33
       +
       	cache            *VoteCache       // In-memory cache of user votes from PDS

     

       33
       34
        
       }

     

       34
       35
        
       

     

       35
       36
        
       // NewService creates a new vote service instance

     

       36
       36
       -
       func NewService(repo Repository, oauthClient *oauthclient.OAuthClient, oauthStore oauth.ClientAuthStore, logger *slog.Logger) Service {

     

       37
       37
       +
       func NewService(repo Repository, oauthClient *oauthclient.OAuthClient, oauthStore oauth.ClientAuthStore, cache *VoteCache, logger *slog.Logger) Service {

     

       37
       38
        
       	if logger == nil {

     

       38
       39
        
       		logger = slog.Default()

     

       39
       40
        
       	}

     
···

       41
       42
        
       		repo:        repo,

     

       42
       43
        
       		oauthClient: oauthClient,

     

       43
       44
        
       		oauthStore:  oauthStore,

     

       45
       45
       +
       		cache:       cache,

     

       44
       46
        
       		logger:      logger,

     

       45
       47
        
       	}

     

       46
       48
        
       }

     

       47
       49
        
       

     

       48
       50
        
       // NewServiceWithPDSFactory creates a vote service with a custom PDS client factory.

     

       49
       51
        
       // This is primarily for testing with password-based authentication.

     

       50
       50
       -
       func NewServiceWithPDSFactory(repo Repository, logger *slog.Logger, factory PDSClientFactory) Service {

     

       52
       52
       +
       func NewServiceWithPDSFactory(repo Repository, cache *VoteCache, logger *slog.Logger, factory PDSClientFactory) Service {

     

       51
       53
        
       	if logger == nil {

     

       52
       54
        
       		logger = slog.Default()

     

       53
       55
        
       	}

     

       54
       56
        
       	return &voteService{

     

       55
       57
        
       		repo:             repo,

     

       58
       58
       +
       		cache:            cache,

     

       56
       59
        
       		logger:           logger,

     

       57
       60
        
       		pdsClientFactory: factory,

     

       58
       61
        
       	}

     
···

       150
       153
        
       				"subject", req.Subject.URI,

     

       151
       154
        
       				"direction", req.Direction)

     

       152
       155
        
       

     

       156
       156
       +
       			// Update cache - remove the vote

     

       157
       157
       +
       			if s.cache != nil {

     

       158
       158
       +
       				s.cache.RemoveVote(session.AccountDID.String(), req.Subject.URI)

     

       159
       159
       +
       			}

     

       160
       160
       +
       

     

       153
       161
        
       			// Return empty response to indicate deletion

     

       154
       162
        
       			return &CreateVoteResponse{

     

       155
       163
        
       				URI: "",

     
···

       197
       205
        
       		"uri", uri,

     

       198
       206
        
       		"cid", cid)

     

       199
       207
        
       

     

       208
       208
       +
       	// Update cache - add the new vote

     

       209
       209
       +
       	if s.cache != nil {

     

       210
       210
       +
       		s.cache.SetVote(session.AccountDID.String(), req.Subject.URI, &CachedVote{

     

       211
       211
       +
       			Direction: req.Direction,

     

       212
       212
       +
       			URI:       uri,

     

       213
       213
       +
       			RKey:      extractRKeyFromURI(uri),

     

       214
       214
       +
       		})

     

       215
       215
       +
       	}

     

       216
       216
       +
       

     

       200
       217
        
       	return &CreateVoteResponse{

     

       201
       218
        
       		URI: uri,

     

       202
       219
        
       		CID: cid,

     
···

       253
       270
        
       		"subject", req.Subject.URI,

     

       254
       271
        
       		"uri", existing.URI)

     

       255
       272
        
       

     

       273
       273
       +
       	// Update cache - remove the vote

     

       274
       274
       +
       	if s.cache != nil {

     

       275
       275
       +
       		s.cache.RemoveVote(session.AccountDID.String(), req.Subject.URI)

     

       276
       276
       +
       	}

     

       277
       277
       +
       

     

       256
       278
        
       	return nil

     

       257
       279
        
       }

     

       258
       280
        
       

     
···

       350
       372
        
       	// No vote found for this subject after checking all pages

     

       351
       373
        
       	return nil, nil

     

       352
       374
        
       }

     

       375
       375
       +
       

     

       376
       376
       +
       // EnsureCachePopulated fetches the user's votes from their PDS if not already cached.

     

       377
       377
       +
       func (s *voteService) EnsureCachePopulated(ctx context.Context, session *oauth.ClientSessionData) error {

     

       378
       378
       +
       	if s.cache == nil {

     

       379
       379
       +
       		return nil // No cache configured

     

       380
       380
       +
       	}

     

       381
       381
       +
       

     

       382
       382
       +
       	// Check if already cached

     

       383
       383
       +
       	if s.cache.IsCached(session.AccountDID.String()) {

     

       384
       384
       +
       		return nil

     

       385
       385
       +
       	}

     

       386
       386
       +
       

     

       387
       387
       +
       	// Create PDS client for this session

     

       388
       388
       +
       	pdsClient, err := s.getPDSClient(ctx, session)

     

       389
       389
       +
       	if err != nil {

     

       390
       390
       +
       		s.logger.Error("failed to create PDS client for cache population",

     

       391
       391
       +
       			"error", err,

     

       392
       392
       +
       			"user", session.AccountDID)

     

       393
       393
       +
       		return fmt.Errorf("failed to create PDS client: %w", err)

     

       394
       394
       +
       	}

     

       395
       395
       +
       

     

       396
       396
       +
       	// Fetch and cache votes from PDS

     

       397
       397
       +
       	if err := s.cache.FetchAndCacheFromPDS(ctx, pdsClient); err != nil {

     

       398
       398
       +
       		s.logger.Error("failed to populate vote cache from PDS",

     

       399
       399
       +
       			"error", err,

     

       400
       400
       +
       			"user", session.AccountDID)

     

       401
       401
       +
       		return fmt.Errorf("failed to populate vote cache: %w", err)

     

       402
       402
       +
       	}

     

       403
       403
       +
       

     

       404
       404
       +
       	return nil

     

       405
       405
       +
       }

     

       406
       406
       +
       

     

       407
       407
       +
       // GetViewerVote returns the viewer's vote for a specific subject, or nil if not voted.

     

       408
       408
       +
       func (s *voteService) GetViewerVote(userDID, subjectURI string) *CachedVote {

     

       409
       409
       +
       	if s.cache == nil {

     

       410
       410
       +
       		return nil

     

       411
       411
       +
       	}

     

       412
       412
       +
       	return s.cache.GetVote(userDID, subjectURI)

     

       413
       413
       +
       }

     

       414
       414
       +
       

     

       415
       415
       +
       // GetViewerVotesForSubjects returns the viewer's votes for multiple subjects.

     

       416
       416
       +
       func (s *voteService) GetViewerVotesForSubjects(userDID string, subjectURIs []string) map[string]*CachedVote {

     

       417
       417
       +
       	result := make(map[string]*CachedVote)

     

       418
       418
       +
       	if s.cache == nil {

     

       419
       419
       +
       		return result

     

       420
       420
       +
       	}

     

       421
       421
       +
       

     

       422
       422
       +
       	allVotes := s.cache.GetVotesForUser(userDID)

     

       423
       423
       +
       	if allVotes == nil {

     

       424
       424
       +
       		return result

     

       425
       425
       +
       	}

     

       426
       426
       +
       

     

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

     

       428
       428
       +
       		if vote, exists := allVotes[uri]; exists {

     

       429
       429
       +
       			result[uri] = vote

     

       430
       430
       +
       		}

     

       431
       431
       +
       	}

     

       432
       432
       +
       

     

       433
       433
       +
       	return result

     

       434
       434
       +
       }

+76 -16

internal/atproto/jetstream/vote_consumer.go

···

       99
       99
        
       	}

     

       100
       100
        
       

     

       101
       101
        
       	// Atomically: Index vote + Update post counts

     

       102
       102
       -
       	if err := c.indexVoteAndUpdateCounts(ctx, vote); err != nil {

     

       102
       102
       +
       	wasNew, err := c.indexVoteAndUpdateCounts(ctx, vote)

     

       103
       103
       +
       	if err != nil {

     

       103
       104
        
       		return fmt.Errorf("failed to index vote and update counts: %w", err)

     

       104
       105
        
       	}

     

       105
       106
        
       

     

       106
       106
       -
       	log.Printf("✓ Indexed vote: %s (%s on %s)", uri, vote.Direction, vote.SubjectURI)

     

       107
       107
       +
       	if wasNew {

     

       108
       108
       +
       		log.Printf("✓ Indexed vote: %s (%s on %s)", uri, vote.Direction, vote.SubjectURI)

     

       109
       109
       +
       	}

     

       107
       110
        
       	return nil

     

       108
       111
        
       }

     

       109
       112
        
       

     
···

       133
       136
        
       }

     

       134
       137
        
       

     

       135
       138
        
       // indexVoteAndUpdateCounts atomically indexes a vote and updates post vote counts

     

       136
       136
       -
       func (c *VoteEventConsumer) indexVoteAndUpdateCounts(ctx context.Context, vote *votes.Vote) error {

     

       139
       139
       +
       // Returns (true, nil) if vote was newly inserted, (false, nil) if already existed (idempotent)

     

       140
       140
       +
       func (c *VoteEventConsumer) indexVoteAndUpdateCounts(ctx context.Context, vote *votes.Vote) (bool, error) {

     

       137
       141
        
       	tx, err := c.db.BeginTx(ctx, nil)

     

       138
       142
        
       	if err != nil {

     

       139
       139
       -
       		return fmt.Errorf("failed to begin transaction: %w", err)

     

       143
       143
       +
       		return false, fmt.Errorf("failed to begin transaction: %w", err)

     

       140
       144
        
       	}

     

       141
       145
        
       	defer func() {

     

       142
       146
        
       		if rollbackErr := tx.Rollback(); rollbackErr != nil && rollbackErr != sql.ErrTxDone {

     
···

       144
       148
        
       		}

     

       145
       149
        
       	}()

     

       146
       150
        
       

     

       147
       147
       -
       	// 1. Index the vote (idempotent with ON CONFLICT DO NOTHING)

     

       151
       151
       +
       	// 1. Check for existing active vote with different URI (stale record)

     

       152
       152
       +
       	// This handles cases where:

     

       153
       153
       +
       	// - User voted on another client and we missed the delete event

     

       154
       154
       +
       	// - Vote was reindexed but user created a new vote with different rkey

     

       155
       155
       +
       	// - Any other state mismatch between PDS and AppView

     

       156
       156
       +
       	var existingDirection sql.NullString

     

       157
       157
       +
       	checkQuery := `

     

       158
       158
       +
       		SELECT direction FROM votes

     

       159
       159
       +
       		WHERE voter_did = $1

     

       160
       160
       +
       		  AND subject_uri = $2

     

       161
       161
       +
       		  AND deleted_at IS NULL

     

       162
       162
       +
       		  AND uri != $3

     

       163
       163
       +
       		LIMIT 1

     

       164
       164
       +
       	`

     

       165
       165
       +
       	if err := tx.QueryRowContext(ctx, checkQuery, vote.VoterDID, vote.SubjectURI, vote.URI).Scan(&existingDirection); err != nil && err != sql.ErrNoRows {

     

       166
       166
       +
       		return false, fmt.Errorf("failed to check existing vote: %w", err)

     

       167
       167
       +
       	}

     

       168
       168
       +
       

     

       169
       169
       +
       	// If there's a stale vote, soft-delete it and adjust counts

     

       170
       170
       +
       	if existingDirection.Valid {

     

       171
       171
       +
       		softDeleteQuery := `

     

       172
       172
       +
       			UPDATE votes

     

       173
       173
       +
       			SET deleted_at = NOW()

     

       174
       174
       +
       			WHERE voter_did = $1

     

       175
       175
       +
       			  AND subject_uri = $2

     

       176
       176
       +
       			  AND deleted_at IS NULL

     

       177
       177
       +
       			  AND uri != $3

     

       178
       178
       +
       		`

     

       179
       179
       +
       		if _, err := tx.ExecContext(ctx, softDeleteQuery, vote.VoterDID, vote.SubjectURI, vote.URI); err != nil {

     

       180
       180
       +
       			return false, fmt.Errorf("failed to soft-delete existing votes: %w", err)

     

       181
       181
       +
       		}

     

       182
       182
       +
       

     

       183
       183
       +
       		// Decrement the old vote's count (will be re-incremented below if same direction)

     

       184
       184
       +
       		collection := utils.ExtractCollectionFromURI(vote.SubjectURI)

     

       185
       185
       +
       		var decrementQuery string

     

       186
       186
       +
       		if existingDirection.String == "up" {

     

       187
       187
       +
       			if collection == "social.coves.community.post" {

     

       188
       188
       +
       				decrementQuery = `UPDATE posts SET upvote_count = GREATEST(0, upvote_count - 1), score = upvote_count - 1 - downvote_count WHERE uri = $1 AND deleted_at IS NULL`

     

       189
       189
       +
       			} else if collection == "social.coves.community.comment" {

     

       190
       190
       +
       				decrementQuery = `UPDATE comments SET upvote_count = GREATEST(0, upvote_count - 1), score = upvote_count - 1 - downvote_count WHERE uri = $1 AND deleted_at IS NULL`

     

       191
       191
       +
       			}

     

       192
       192
       +
       		} else {

     

       193
       193
       +
       			if collection == "social.coves.community.post" {

     

       194
       194
       +
       				decrementQuery = `UPDATE posts SET downvote_count = GREATEST(0, downvote_count - 1), score = upvote_count - (downvote_count - 1) WHERE uri = $1 AND deleted_at IS NULL`

     

       195
       195
       +
       			} else if collection == "social.coves.community.comment" {

     

       196
       196
       +
       				decrementQuery = `UPDATE comments SET downvote_count = GREATEST(0, downvote_count - 1), score = upvote_count - (downvote_count - 1) WHERE uri = $1 AND deleted_at IS NULL`

     

       197
       197
       +
       			}

     

       198
       198
       +
       		}

     

       199
       199
       +
       		if decrementQuery != "" {

     

       200
       200
       +
       			if _, err := tx.ExecContext(ctx, decrementQuery, vote.SubjectURI); err != nil {

     

       201
       201
       +
       				return false, fmt.Errorf("failed to decrement old vote count: %w", err)

     

       202
       202
       +
       			}

     

       203
       203
       +
       		}

     

       204
       204
       +
       		log.Printf("Cleaned up stale vote for %s on %s (was %s)", vote.VoterDID, vote.SubjectURI, existingDirection.String)

     

       205
       205
       +
       	}

     

       206
       206
       +
       

     

       207
       207
       +
       	// 2. Index the vote (idempotent with ON CONFLICT DO NOTHING)

     

       148
       208
        
       	query := `

     

       149
       209
        
       		INSERT INTO votes (

     

       150
       210
        
       			uri, cid, rkey, voter_did,

     
···

       169
       229
        
       

     

       170
       230
        
       	// If no rows returned, vote already exists (idempotent - OK for Jetstream replays)

     

       171
       231
        
       	if err == sql.ErrNoRows {

     

       172
       172
       -
       		log.Printf("Vote already indexed: %s (idempotent)", vote.URI)

     

       232
       232
       +
       		// Silently handle idempotent case - no log needed for replayed events

     

       173
       233
        
       		if commitErr := tx.Commit(); commitErr != nil {

     

       174
       174
       -
       			return fmt.Errorf("failed to commit transaction: %w", commitErr)

     

       234
       234
       +
       			return false, fmt.Errorf("failed to commit transaction: %w", commitErr)

     

       175
       235
        
       		}

     

       176
       176
       -
       		return nil

     

       236
       236
       +
       		return false, nil // Vote already existed

     

       177
       237
        
       	}

     

       178
       238
        
       

     

       179
       239
        
       	if err != nil {

     

       180
       180
       -
       		return fmt.Errorf("failed to insert vote: %w", err)

     

       240
       240
       +
       		return false, fmt.Errorf("failed to insert vote: %w", err)

     

       181
       241
        
       	}

     

       182
       242
        
       

     

       183
       183
       -
       	// 2. Update vote counts on the subject (post or comment)

     

       243
       243
       +
       	// 3. Update vote counts on the subject (post or comment)

     

       184
       244
        
       	// Parse collection from subject URI to determine target table

     

       185
       245
        
       	collection := utils.ExtractCollectionFromURI(vote.SubjectURI)

     

       186
       246
        
       

     
···

       227
       287
        
       		// Vote is still indexed in votes table, we just don't update denormalized counts

     

       228
       288
        
       		log.Printf("Vote subject has unsupported collection: %s (vote indexed, counts not updated)", collection)

     

       229
       289
        
       		if commitErr := tx.Commit(); commitErr != nil {

     

       230
       230
       -
       			return fmt.Errorf("failed to commit transaction: %w", commitErr)

     

       290
       290
       +
       			return false, fmt.Errorf("failed to commit transaction: %w", commitErr)

     

       231
       291
        
       		}

     

       232
       232
       -
       		return nil

     

       292
       292
       +
       		return true, nil // Vote was newly indexed

     

       233
       293
        
       	}

     

       234
       294
        
       

     

       235
       295
        
       	result, err := tx.ExecContext(ctx, updateQuery, vote.SubjectURI)

     

       236
       296
        
       	if err != nil {

     

       237
       237
       -
       		return fmt.Errorf("failed to update vote counts: %w", err)

     

       297
       297
       +
       		return false, fmt.Errorf("failed to update vote counts: %w", err)

     

       238
       298
        
       	}

     

       239
       299
        
       

     

       240
       300
        
       	rowsAffected, err := result.RowsAffected()

     

       241
       301
        
       	if err != nil {

     

       242
       242
       -
       		return fmt.Errorf("failed to check update result: %w", err)

     

       302
       302
       +
       		return false, fmt.Errorf("failed to check update result: %w", err)

     

       243
       303
        
       	}

     

       244
       304
        
       

     

       245
       305
        
       	// If subject doesn't exist or is deleted, that's OK (vote still indexed)

     
···

       249
       309
        
       

     

       250
       310
        
       	// Commit transaction

     

       251
       311
        
       	if err := tx.Commit(); err != nil {

     

       252
       252
       -
       		return fmt.Errorf("failed to commit transaction: %w", err)

     

       312
       312
       +
       		return false, fmt.Errorf("failed to commit transaction: %w", err)

     

       253
       313
        
       	}

     

       254
       314
        
       

     

       255
       255
       -
       	return nil

     

       315
       315
       +
       	return true, nil // Vote was newly indexed

     

       256
       316
        
       }

     

       257
       317
        
       

     

       258
       318
        
       // deleteVoteAndUpdateCounts atomically soft-deletes a vote and updates post vote counts

+109

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

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

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

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

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

     

       8
       8
       +
             "input": {

     

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

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

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

     

       13
       13
       +
                 "properties": {

     

       14
       14
       +
                   "reply": {

     

       15
       15
       +
                     "type": "object",

     

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

     

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

     

       18
       18
       +
                     "properties": {

     

       19
       19
       +
                       "root": {

     

       20
       20
       +
                         "type": "ref",

     

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

     

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

     

       23
       23
       +
                       },

     

       24
       24
       +
                       "parent": {

     

       25
       25
       +
                         "type": "ref",

     

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

     

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

     

       28
       28
       +
                       }

     

       29
       29
       +
                     }

     

       30
       30
       +
                   },

     

       31
       31
       +
                   "content": {

     

       32
       32
       +
                     "type": "string",

     

       33
       33
       +
                     "maxGraphemes": 10000,

     

       34
       34
       +
                     "maxLength": 100000,

     

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

     

       36
       36
       +
                   },

     

       37
       37
       +
                   "facets": {

     

       38
       38
       +
                     "type": "array",

     

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

     

       40
       40
       +
                     "items": {

     

       41
       41
       +
                       "type": "ref",

     

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

     

       43
       43
       +
                     }

     

       44
       44
       +
                   },

     

       45
       45
       +
                   "embed": {

     

       46
       46
       +
                     "type": "union",

     

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

     

       48
       48
       +
                     "refs": [

     

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

     

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

     

       51
       51
       +
                     ]

     

       52
       52
       +
                   },

     

       53
       53
       +
                   "langs": {

     

       54
       54
       +
                     "type": "array",

     

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

     

       56
       56
       +
                     "maxLength": 3,

     

       57
       57
       +
                     "items": {

     

       58
       58
       +
                       "type": "string",

     

       59
       59
       +
                       "format": "language"

     

       60
       60
       +
                     }

     

       61
       61
       +
                   },

     

       62
       62
       +
                   "labels": {

     

       63
       63
       +
                     "type": "ref",

     

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

     

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

     

       66
       66
       +
                   }

     

       67
       67
       +
                 }

     

       68
       68
       +
               }

     

       69
       69
       +
             },

     

       70
       70
       +
             "output": {

     

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

     

       72
       72
       +
               "schema": {

     

       73
       73
       +
                 "type": "object",

     

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

     

       75
       75
       +
                 "properties": {

     

       76
       76
       +
                   "uri": {

     

       77
       77
       +
                     "type": "string",

     

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

     

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

     

       80
       80
       +
                   },

     

       81
       81
       +
                   "cid": {

     

       82
       82
       +
                     "type": "string",

     

       83
       83
       +
                     "format": "cid",

     

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

     

       85
       85
       +
                   }

     

       86
       86
       +
                 }

     

       87
       87
       +
               }

     

       88
       88
       +
             },

     

       89
       89
       +
             "errors": [

     

       90
       90
       +
               {

     

       91
       91
       +
                 "name": "InvalidReply",

     

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

     

       93
       93
       +
               },

     

       94
       94
       +
               {

     

       95
       95
       +
                 "name": "ContentTooLong",

     

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

     

       97
       97
       +
               },

     

       98
       98
       +
               {

     

       99
       99
       +
                 "name": "ContentEmpty",

     

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

     

       101
       101
       +
               },

     

       102
       102
       +
               {

     

       103
       103
       +
                 "name": "NotAuthorized",

     

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

     

       105
       105
       +
               }

     

       106
       106
       +
             ]

     

       107
       107
       +
           }

     

       108
       108
       +
         }

     

       109
       109
       +
       }

+41

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

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

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

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

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

     

       8
       8
       +
             "input": {

     

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

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

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

     

       13
       13
       +
                 "properties": {

     

       14
       14
       +
                   "uri": {

     

       15
       15
       +
                     "type": "string",

     

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

     

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

     

       18
       18
       +
                   }

     

       19
       19
       +
                 }

     

       20
       20
       +
               }

     

       21
       21
       +
             },

     

       22
       22
       +
             "output": {

     

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

     

       24
       24
       +
               "schema": {

     

       25
       25
       +
                 "type": "object",

     

       26
       26
       +
                 "properties": {}

     

       27
       27
       +
               }

     

       28
       28
       +
             },

     

       29
       29
       +
             "errors": [

     

       30
       30
       +
               {

     

       31
       31
       +
                 "name": "CommentNotFound",

     

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

     

       33
       33
       +
               },

     

       34
       34
       +
               {

     

       35
       35
       +
                 "name": "NotAuthorized",

     

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

     

       37
       37
       +
               }

     

       38
       38
       +
             ]

     

       39
       39
       +
           }

     

       40
       40
       +
         }

     

       41
       41
       +
       }

+97

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

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

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

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

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

     

       8
       8
       +
             "input": {

     

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

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

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

     

       13
       13
       +
                 "properties": {

     

       14
       14
       +
                   "uri": {

     

       15
       15
       +
                     "type": "string",

     

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

     

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

     

       18
       18
       +
                   },

     

       19
       19
       +
                   "content": {

     

       20
       20
       +
                     "type": "string",

     

       21
       21
       +
                     "maxGraphemes": 10000,

     

       22
       22
       +
                     "maxLength": 100000,

     

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

     

       24
       24
       +
                   },

     

       25
       25
       +
                   "facets": {

     

       26
       26
       +
                     "type": "array",

     

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

     

       28
       28
       +
                     "items": {

     

       29
       29
       +
                       "type": "ref",

     

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

     

       31
       31
       +
                     }

     

       32
       32
       +
                   },

     

       33
       33
       +
                   "embed": {

     

       34
       34
       +
                     "type": "union",

     

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

     

       36
       36
       +
                     "refs": [

     

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

     

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

     

       39
       39
       +
                     ]

     

       40
       40
       +
                   },

     

       41
       41
       +
                   "langs": {

     

       42
       42
       +
                     "type": "array",

     

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

     

       44
       44
       +
                     "maxLength": 3,

     

       45
       45
       +
                     "items": {

     

       46
       46
       +
                       "type": "string",

     

       47
       47
       +
                       "format": "language"

     

       48
       48
       +
                     }

     

       49
       49
       +
                   },

     

       50
       50
       +
                   "labels": {

     

       51
       51
       +
                     "type": "ref",

     

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

     

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

     

       54
       54
       +
                   }

     

       55
       55
       +
                 }

     

       56
       56
       +
               }

     

       57
       57
       +
             },

     

       58
       58
       +
             "output": {

     

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

     

       60
       60
       +
               "schema": {

     

       61
       61
       +
                 "type": "object",

     

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

     

       63
       63
       +
                 "properties": {

     

       64
       64
       +
                   "uri": {

     

       65
       65
       +
                     "type": "string",

     

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

     

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

     

       68
       68
       +
                   },

     

       69
       69
       +
                   "cid": {

     

       70
       70
       +
                     "type": "string",

     

       71
       71
       +
                     "format": "cid",

     

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

     

       73
       73
       +
                   }

     

       74
       74
       +
                 }

     

       75
       75
       +
               }

     

       76
       76
       +
             },

     

       77
       77
       +
             "errors": [

     

       78
       78
       +
               {

     

       79
       79
       +
                 "name": "CommentNotFound",

     

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

     

       81
       81
       +
               },

     

       82
       82
       +
               {

     

       83
       83
       +
                 "name": "ContentTooLong",

     

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

     

       85
       85
       +
               },

     

       86
       86
       +
               {

     

       87
       87
       +
                 "name": "ContentEmpty",

     

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

     

       89
       89
       +
               },

     

       90
       90
       +
               {

     

       91
       91
       +
                 "name": "NotAuthorized",

     

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

     

       93
       93
       +
               }

     

       94
       94
       +
             ]

     

       95
       95
       +
           }

     

       96
       96
       +
         }

     

       97
       97
       +
       }

+38

internal/core/comments/types.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

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

     

       4
       4
       +
       type CreateCommentRequest struct {

     

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

     

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

     

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

     

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

     

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

     

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

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

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

     

       14
       14
       +
       type CreateCommentResponse struct {

     

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

     

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

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

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

     

       20
       20
       +
       type UpdateCommentRequest struct {

     

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

     

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

     

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

     

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

     

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

     

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

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

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

     

       30
       30
       +
       type UpdateCommentResponse struct {

     

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

     

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

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

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

     

       36
       36
       +
       type DeleteCommentRequest struct {

     

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

     

       38
       38
       +
       }

+130

internal/api/handlers/comments/create_comment.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

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

     

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

     

       6
       6
       +
       	"encoding/json"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"net/http"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // CreateCommentHandler handles comment creation requests

     

       12
       12
       +
       type CreateCommentHandler struct {

     

       13
       13
       +
       	service comments.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

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

     

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

     

       18
       18
       +
       	return &CreateCommentHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

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

     

       24
       24
       +
       type CreateCommentInput struct {

     

       25
       25
       +
       	Reply struct {

     

       26
       26
       +
       		Root struct {

     

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

     

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

     

       29
       29
       +
       		} `json:"root"`

     

       30
       30
       +
       		Parent struct {

     

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

     

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

     

       33
       33
       +
       		} `json:"parent"`

     

       34
       34
       +
       	} `json:"reply"`

     

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

     

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

     

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

     

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

     

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

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       // CreateCommentOutput matches the lexicon output schema

     

       43
       43
       +
       type CreateCommentOutput struct {

     

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

     

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

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       // HandleCreate handles comment creation requests

     

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

     

       50
       50
       +
       //

     

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

     

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

     

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

     

       54
       54
       +
       	// 1. Check method is POST

     

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

     

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

     

       57
       57
       +
       		return

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

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

     

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

     

       62
       62
       +
       

     

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

     

       64
       64
       +
       	var input CreateCommentInput

     

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

     

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

     

       67
       67
       +
       		return

     

       68
       68
       +
       	}

     

       69
       69
       +
       

     

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

     

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

     

       72
       72
       +
       	if session == nil {

     

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

     

       74
       74
       +
       		return

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

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

     

       78
       78
       +
       	var labels *comments.SelfLabels

     

       79
       79
       +
       	if input.Labels != nil {

     

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

     

       81
       81
       +
       		if err != nil {

     

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

     

       83
       83
       +
       			return

     

       84
       84
       +
       		}

     

       85
       85
       +
       		var selfLabels comments.SelfLabels

     

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

     

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

     

       88
       88
       +
       			return

     

       89
       89
       +
       		}

     

       90
       90
       +
       		labels = &selfLabels

     

       91
       91
       +
       	}

     

       92
       92
       +
       

     

       93
       93
       +
       	// 6. Convert input to CreateCommentRequest

     

       94
       94
       +
       	req := comments.CreateCommentRequest{

     

       95
       95
       +
       		Reply: comments.ReplyRef{

     

       96
       96
       +
       			Root: comments.StrongRef{

     

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

     

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

     

       99
       99
       +
       			},

     

       100
       100
       +
       			Parent: comments.StrongRef{

     

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

     

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

     

       103
       103
       +
       			},

     

       104
       104
       +
       		},

     

       105
       105
       +
       		Content: input.Content,

     

       106
       106
       +
       		Facets:  input.Facets,

     

       107
       107
       +
       		Embed:   input.Embed,

     

       108
       108
       +
       		Langs:   input.Langs,

     

       109
       109
       +
       		Labels:  labels,

     

       110
       110
       +
       	}

     

       111
       111
       +
       

     

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

     

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

     

       114
       114
       +
       	if err != nil {

     

       115
       115
       +
       		handleServiceError(w, err)

     

       116
       116
       +
       		return

     

       117
       117
       +
       	}

     

       118
       118
       +
       

     

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

     

       120
       120
       +
       	output := CreateCommentOutput{

     

       121
       121
       +
       		URI: response.URI,

     

       122
       122
       +
       		CID: response.CID,

     

       123
       123
       +
       	}

     

       124
       124
       +
       

     

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

     

       126
       126
       +
       	w.WriteHeader(http.StatusOK)

     

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

     

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

     

       129
       129
       +
       	}

     

       130
       130
       +
       }

+80

internal/api/handlers/comments/delete_comment.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

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

     

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

     

       6
       6
       +
       	"encoding/json"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"net/http"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // DeleteCommentHandler handles comment deletion requests

     

       12
       12
       +
       type DeleteCommentHandler struct {

     

       13
       13
       +
       	service comments.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

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

     

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

     

       18
       18
       +
       	return &DeleteCommentHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

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

     

       24
       24
       +
       type DeleteCommentInput struct {

     

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

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       // DeleteCommentOutput is empty per lexicon specification

     

       29
       29
       +
       type DeleteCommentOutput struct{}

     

       30
       30
       +
       

     

       31
       31
       +
       // HandleDelete handles comment deletion requests

     

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

     

       33
       33
       +
       //

     

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

     

       35
       35
       +
       // Response: {}

     

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

     

       37
       37
       +
       	// 1. Check method is POST

     

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

     

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

     

       40
       40
       +
       		return

     

       41
       41
       +
       	}

     

       42
       42
       +
       

     

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

     

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

     

       45
       45
       +
       

     

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

     

       47
       47
       +
       	var input DeleteCommentInput

     

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

     

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

     

       50
       50
       +
       		return

     

       51
       51
       +
       	}

     

       52
       52
       +
       

     

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

     

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

     

       55
       55
       +
       	if session == nil {

     

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

     

       57
       57
       +
       		return

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

       60
       60
       +
       	// 5. Convert input to DeleteCommentRequest

     

       61
       61
       +
       	req := comments.DeleteCommentRequest{

     

       62
       62
       +
       		URI: input.URI,

     

       63
       63
       +
       	}

     

       64
       64
       +
       

     

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

     

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

     

       67
       67
       +
       	if err != nil {

     

       68
       68
       +
       		handleServiceError(w, err)

     

       69
       69
       +
       		return

     

       70
       70
       +
       	}

     

       71
       71
       +
       

     

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

     

       73
       73
       +
       	output := DeleteCommentOutput{}

     

       74
       74
       +
       

     

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

     

       76
       76
       +
       	w.WriteHeader(http.StatusOK)

     

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

     

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

     

       79
       79
       +
       	}

     

       80
       80
       +
       }

+34 -2

internal/api/handlers/comments/errors.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"Coves/internal/core/comments"

     

       5
       5
        
       	"encoding/json"

     

       6
       6
       +
       	"errors"

     

       6
       7
        
       	"log"

     

       7
       8
        
       	"net/http"

     

       8
       9
        
       )

     
···

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

     

       31
       32
        
       	switch {

     

       32
       33
        
       	case comments.IsNotFound(err):

     

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

     

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

     

       35
       35
       +
       		switch {

     

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

     

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

     

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

     

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

     

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

     

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

     

       42
       42
       +
       		default:

     

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

     

       44
       44
       +
       		}

     

       34
       45
        
       

     

       35
       46
        
       	case comments.IsValidationError(err):

     

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

     

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

     

       48
       48
       +
       		switch {

     

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

     

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

     

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

     

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

     

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

     

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

     

       55
       55
       +
       		default:

     

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

     

       57
       57
       +
       		}

     

       58
       58
       +
       

     

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

     

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

     

       61
       61
       +
       

     

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

     

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

     

       64
       64
       +
       

     

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

     

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

     

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

     

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

     

       37
       69
        
       

     

       38
       70
        
       	default:

     

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

+112

internal/api/handlers/comments/update_comment.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

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

     

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

     

       6
       6
       +
       	"encoding/json"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"net/http"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // UpdateCommentHandler handles comment update requests

     

       12
       12
       +
       type UpdateCommentHandler struct {

     

       13
       13
       +
       	service comments.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

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

     

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

     

       18
       18
       +
       	return &UpdateCommentHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

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

     

       24
       24
       +
       type UpdateCommentInput struct {

     

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

     

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

     

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

     

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

     

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

     

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

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       // UpdateCommentOutput matches the lexicon output schema

     

       34
       34
       +
       type UpdateCommentOutput struct {

     

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

     

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

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       // HandleUpdate handles comment update requests

     

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

     

       41
       41
       +
       //

     

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

     

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

     

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

     

       45
       45
       +
       	// 1. Check method is POST

     

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

     

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

     

       48
       48
       +
       		return

     

       49
       49
       +
       	}

     

       50
       50
       +
       

     

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

     

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

     

       53
       53
       +
       

     

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

     

       55
       55
       +
       	var input UpdateCommentInput

     

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

     

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

     

       58
       58
       +
       		return

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

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

     

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

     

       63
       63
       +
       	if session == nil {

     

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

     

       65
       65
       +
       		return

     

       66
       66
       +
       	}

     

       67
       67
       +
       

     

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

     

       69
       69
       +
       	var labels *comments.SelfLabels

     

       70
       70
       +
       	if input.Labels != nil {

     

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

     

       72
       72
       +
       		if err != nil {

     

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

     

       74
       74
       +
       			return

     

       75
       75
       +
       		}

     

       76
       76
       +
       		var selfLabels comments.SelfLabels

     

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

     

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

     

       79
       79
       +
       			return

     

       80
       80
       +
       		}

     

       81
       81
       +
       		labels = &selfLabels

     

       82
       82
       +
       	}

     

       83
       83
       +
       

     

       84
       84
       +
       	// 6. Convert input to UpdateCommentRequest

     

       85
       85
       +
       	req := comments.UpdateCommentRequest{

     

       86
       86
       +
       		URI:     input.URI,

     

       87
       87
       +
       		Content: input.Content,

     

       88
       88
       +
       		Facets:  input.Facets,

     

       89
       89
       +
       		Embed:   input.Embed,

     

       90
       90
       +
       		Langs:   input.Langs,

     

       91
       91
       +
       		Labels:  labels,

     

       92
       92
       +
       	}

     

       93
       93
       +
       

     

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

     

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

     

       96
       96
       +
       	if err != nil {

     

       97
       97
       +
       		handleServiceError(w, err)

     

       98
       98
       +
       		return

     

       99
       99
       +
       	}

     

       100
       100
       +
       

     

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

     

       102
       102
       +
       	output := UpdateCommentOutput{

     

       103
       103
       +
       		URI: response.URI,

     

       104
       104
       +
       		CID: response.CID,

     

       105
       105
       +
       	}

     

       106
       106
       +
       

     

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

     

       108
       108
       +
       	w.WriteHeader(http.StatusOK)

     

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

     

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

     

       111
       111
       +
       	}

     

       112
       112
       +
       }

+35

internal/api/routes/comment.go

···

       1
       1
       +
       package routes

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

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

     

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

     

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

     

       7
       7
       +
       

     

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

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

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

     

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

     

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

     

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

     

       15
       15
       +
       	// Initialize handlers

     

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

     

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

     

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

     

       19
       19
       +
       

     

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

     

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

     

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

     

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

     

       24
       24
       +
       		createHandler.HandleCreate)

     

       25
       25
       +
       

     

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

     

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

     

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

     

       29
       29
       +
       		updateHandler.HandleUpdate)

     

       30
       30
       +
       

     

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

     

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

     

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

     

       34
       34
       +
       		deleteHandler.HandleDelete)

     

       35
       35
       +
       }

+4 -2

tests/integration/comment_query_test.go

···

       785
       785
        
       	postRepo := postgres.NewPostRepository(db)

     

       786
       786
        
       	userRepo := postgres.NewUserRepository(db)

     

       787
       787
        
       	communityRepo := postgres.NewCommunityRepository(db)

     

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

     

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

     

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

     

       789
       790
        
       }

     

       790
       791
        
       

     

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

     
···

       871
       872
        
       	postRepo := postgres.NewPostRepository(db)

     

       872
       873
        
       	userRepo := postgres.NewUserRepository(db)

     

       873
       874
        
       	communityRepo := postgres.NewCommunityRepository(db)

     

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

     

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

     

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

     

       875
       877
        
       	return &testCommentServiceAdapter{service: service}

     

       876
       878
        
       }

     

       877
       879

+6 -3

tests/integration/comment_vote_test.go

···

       417
       417
        
       		}

     

       418
       418
        
       

     

       419
       419
        
       		// Query comments with viewer authentication

     

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

     

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

     

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

     

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

     

       422
       423
        
       			PostURI:   testPostURI,

     

       423
       424
        
       			Sort:      "new",

     
···

       499
       500
        
       		}

     

       500
       501
        
       

     

       501
       502
        
       		// Query with authentication but no vote

     

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

     

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

     

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

     

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

     

       504
       506
        
       			PostURI:   testPostURI,

     

       505
       507
        
       			Sort:      "new",

     
···

       542
       544
        
       

     

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

     

       544
       546
        
       		// Query without authentication

     

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

     

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

     

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

     

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

     

       547
       550
        
       			PostURI:   testPostURI,

     

       548
       551
        
       			Sort:      "new",

+1 -1

go.mod

···

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

go.sum

···

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

+66

internal/db/migrations/021_add_comment_deletion_metadata.sql

···

       1
       1
       +
       -- +goose Up

     

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

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       -- Create enum type for deletion reasons

     

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

     

       7
       7
       +
       

     

       8
       8
       +
       -- Add new columns to comments table

     

       9
       9
       +
       ALTER TABLE comments ADD COLUMN deletion_reason deletion_reason;

     

       10
       10
       +
       ALTER TABLE comments ADD COLUMN deleted_by TEXT;

     

       11
       11
       +
       

     

       12
       12
       +
       -- Add comments for new columns

     

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

     

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

     

       15
       15
       +
       

     

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

     

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

     

       18
       18
       +
       UPDATE comments

     

       19
       19
       +
       SET deletion_reason = 'author',

     

       20
       20
       +
           deleted_by = commenter_did

     

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

     

       22
       22
       +
       

     

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

     

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

     

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

     

       26
       26
       +
       

     

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

     

       28
       28
       +
       DROP INDEX IF EXISTS idx_comments_root;

     

       29
       29
       +
       DROP INDEX IF EXISTS idx_comments_parent;

     

       30
       30
       +
       DROP INDEX IF EXISTS idx_comments_parent_score;

     

       31
       31
       +
       DROP INDEX IF EXISTS idx_comments_uri_active;

     

       32
       32
       +
       

     

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

     

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

     

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

     

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

     

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

     

       38
       38
       +
       

     

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

     

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

     

       41
       41
       +
       WHERE deleted_at IS NOT NULL;

     

       42
       42
       +
       

     

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

     

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

     

       45
       45
       +
       WHERE deleted_at IS NOT NULL;

     

       46
       46
       +
       

     

       47
       47
       +
       -- +goose Down

     

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

     

       49
       49
       +
       

     

       50
       50
       +
       DROP INDEX IF EXISTS idx_comments_deleted_by;

     

       51
       51
       +
       DROP INDEX IF EXISTS idx_comments_deleted_reason;

     

       52
       52
       +
       DROP INDEX IF EXISTS idx_comments_uri_lookup;

     

       53
       53
       +
       DROP INDEX IF EXISTS idx_comments_parent_score;

     

       54
       54
       +
       DROP INDEX IF EXISTS idx_comments_parent;

     

       55
       55
       +
       DROP INDEX IF EXISTS idx_comments_root;

     

       56
       56
       +
       

     

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

     

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

     

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

     

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

     

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

     

       62
       62
       +
       

     

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

     

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

     

       65
       65
       +
       

     

       66
       66
       +
       DROP TYPE IF EXISTS deletion_reason;

internal/core/communityFeeds/types.go

···

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

     

       32
       32
        
       }

     

       33
       33
        
       

     

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

     

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

     

       36
       36
       +
       	return f.Post

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

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

     

       35
       40
        
       // Can be reasonRepost or reasonPin

     

       36
       41
        
       type FeedReason struct {

internal/core/discover/types.go

···

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

     

       40
       40
        
       }

     

       41
       41
        
       

     

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

     

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

     

       44
       44
       +
       	return f.Post

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

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

     

       43
       48
        
       type FeedReason struct {

     

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

internal/core/timeline/types.go

···

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

     

       43
       43
        
       }

     

       44
       44
        
       

     

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

     

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

     

       47
       47
       +
       	return f.Post

     

       48
       48
       +
       }

     

       49
       49
       +
       

     

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

     

       46
       51
        
       // Future: Can be reasonRepost or reasonCommunity

     

       47
       52
        
       type FeedReason struct {

+12

internal/api/handlers/vote/create_vote_test.go

···

       37
       37
        
       	return nil

     

       38
       38
        
       }

     

       39
       39
        
       

     

       40
       40
       +
       func (m *mockVoteService) EnsureCachePopulated(ctx context.Context, session *oauthlib.ClientSessionData) error {

     

       41
       41
       +
       	return nil

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

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

     

       45
       45
       +
       	return nil

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

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

     

       49
       49
       +
       	return nil

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       40
       52
        
       func TestCreateVoteHandler_Success(t *testing.T) {

     

       41
       53
        
       	mockService := &mockVoteService{}

     

       42
       54
        
       	handler := NewCreateVoteHandler(mockService)

scripts/generate_deep_thread.go

···

       1
       1
       +
       //go:build ignore

     

       2
       2
       +
       

     

       1
       3
        
       package main

     

       2
       4
        
       

     

       3
       5
        
       import (

scripts/generate_nba_comments.go

···

       1
       1
       +
       //go:build ignore

     

       2
       2
       +
       

     

       1
       3
        
       package main

     

       2
       4
        
       

     

       3
       5
        
       import (

scripts/generate_test_comments.go

···

       1
       1
       +
       //go:build ignore

     

       2
       2
       +
       

     

       1
       3
        
       package main

     

       2
       4
        
       

     

       3
       5
        
       import (

+29

internal/atproto/oauth/store.go

···

       445
       445
        
       	return rows, nil

     

       446
       446
        
       }

     

       447
       447
        
       

     

       448
       448
       +
       // UpdateHandleByDID updates the handle for all OAuth sessions belonging to a DID.

     

       449
       449
       +
       // This is called when identity events indicate a handle change, keeping active

     

       450
       450
       +
       // sessions in sync with the user's current handle.

     

       451
       451
       +
       // Returns the number of sessions updated.

     

       452
       452
       +
       func (s *PostgresOAuthStore) UpdateHandleByDID(ctx context.Context, did, newHandle string) (int64, error) {

     

       453
       453
       +
       	query := `

     

       454
       454
       +
       		UPDATE oauth_sessions

     

       455
       455
       +
       		SET handle = $2, updated_at = NOW()

     

       456
       456
       +
       		WHERE did = $1 AND expires_at > NOW()

     

       457
       457
       +
       	`

     

       458
       458
       +
       

     

       459
       459
       +
       	result, err := s.db.ExecContext(ctx, query, did, newHandle)

     

       460
       460
       +
       	if err != nil {

     

       461
       461
       +
       		return 0, fmt.Errorf("failed to update session handle: %w", err)

     

       462
       462
       +
       	}

     

       463
       463
       +
       

     

       464
       464
       +
       	rows, err := result.RowsAffected()

     

       465
       465
       +
       	if err != nil {

     

       466
       466
       +
       		return 0, fmt.Errorf("failed to get rows affected: %w", err)

     

       467
       467
       +
       	}

     

       468
       468
       +
       

     

       469
       469
       +
       	if rows > 0 {

     

       470
       470
       +
       		slog.Info("updated OAuth session handles for identity change",

     

       471
       471
       +
       			"did", did, "new_handle", newHandle, "sessions_updated", rows)

     

       472
       472
       +
       	}

     

       473
       473
       +
       

     

       474
       474
       +
       	return rows, nil

     

       475
       475
       +
       }

     

       476
       476
       +
       

     

       448
       477
        
       // MobileOAuthData holds mobile-specific OAuth flow data

     

       449
       478
        
       type MobileOAuthData struct {

     

       450
       479
        
       	CSRFToken   string

+375

tests/integration/oauth_session_handle_sync_test.go

···

       1
       1
       +
       package integration

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       	"testing"

     

       8
       8
       +
       	"time"

     

       9
       9
       +
       

     

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

     

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

     

       12
       12
       +
       	"github.com/stretchr/testify/require"

     

       13
       13
       +
       

     

       14
       14
       +
       	"Coves/internal/atproto/identity"

     

       15
       15
       +
       	"Coves/internal/atproto/jetstream"

     

       16
       16
       +
       	"Coves/internal/atproto/oauth"

     

       17
       17
       +
       	"Coves/internal/core/users"

     

       18
       18
       +
       	"Coves/internal/db/postgres"

     

       19
       19
       +
       )

     

       20
       20
       +
       

     

       21
       21
       +
       // TestOAuthSessionHandleSync tests that OAuth session handles are updated

     

       22
       22
       +
       // when identity events indicate a handle change.

     

       23
       23
       +
       //

     

       24
       24
       +
       // This ensures mobile/web apps display the correct handle after a user

     

       25
       25
       +
       // changes their handle on their PDS.

     

       26
       26
       +
       //

     

       27
       27
       +
       // Prerequisites:

     

       28
       28
       +
       //   - Test database on localhost:5434

     

       29
       29
       +
       //

     

       30
       30
       +
       // Run with:

     

       31
       31
       +
       //

     

       32
       32
       +
       //	docker-compose --profile test up -d postgres-test

     

       33
       33
       +
       //	TEST_DATABASE_URL="postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" \

     

       34
       34
       +
       //	  go test -v ./tests/integration/ -run "TestOAuthSessionHandleSync"

     

       35
       35
       +
       func TestOAuthSessionHandleSync(t *testing.T) {

     

       36
       36
       +
       	db := setupTestDB(t)

     

       37
       37
       +
       	defer func() {

     

       38
       38
       +
       		if err := db.Close(); err != nil {

     

       39
       39
       +
       			t.Logf("Failed to close database: %v", err)

     

       40
       40
       +
       		}

     

       41
       41
       +
       	}()

     

       42
       42
       +
       

     

       43
       43
       +
       	ctx := context.Background()

     

       44
       44
       +
       

     

       45
       45
       +
       	// Set up real infrastructure components

     

       46
       46
       +
       	userRepo := postgres.NewUserRepository(db)

     

       47
       47
       +
       	resolver := identity.NewResolver(db, identity.DefaultConfig())

     

       48
       48
       +
       	userService := users.NewUserService(userRepo, resolver, "http://localhost:3001")

     

       49
       49
       +
       

     

       50
       50
       +
       	// Create real OAuth store (with session handle updater capability)

     

       51
       51
       +
       	baseOAuthStore := oauth.NewPostgresOAuthStore(db, 24*time.Hour)

     

       52
       52
       +
       

     

       53
       53
       +
       	t.Run("Handle change syncs to active OAuth sessions", func(t *testing.T) {

     

       54
       54
       +
       		testDID := "did:plc:oauthsync123"

     

       55
       55
       +
       		oldHandle := "oldhandle.oauth.sync.test"

     

       56
       56
       +
       		newHandle := "newhandle.oauth.sync.test"

     

       57
       57
       +
       		sessionID := "test-session-oauth-sync-001"

     

       58
       58
       +
       

     

       59
       59
       +
       		// 1. Create user with old handle

     

       60
       60
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       61
       61
       +
       			DID:    testDID,

     

       62
       62
       +
       			Handle: oldHandle,

     

       63
       63
       +
       			PDSURL: "https://bsky.social",

     

       64
       64
       +
       		})

     

       65
       65
       +
       		require.NoError(t, err, "Failed to create test user")

     

       66
       66
       +
       		t.Logf("✅ Created user: %s (%s)", oldHandle, testDID)

     

       67
       67
       +
       

     

       68
       68
       +
       		// 2. Create OAuth session with old handle

     

       69
       69
       +
       		parsedDID, err := syntax.ParseDID(testDID)

     

       70
       70
       +
       		require.NoError(t, err, "Failed to parse DID")

     

       71
       71
       +
       

     

       72
       72
       +
       		session := oauthlib.ClientSessionData{

     

       73
       73
       +
       			AccountDID:   parsedDID,

     

       74
       74
       +
       			SessionID:    sessionID,

     

       75
       75
       +
       			HostURL:      "https://bsky.social",

     

       76
       76
       +
       			AccessToken:  "test-access-token",

     

       77
       77
       +
       			RefreshToken: "test-refresh-token",

     

       78
       78
       +
       			Scopes:       []string{"atproto"},

     

       79
       79
       +
       		}

     

       80
       80
       +
       		err = baseOAuthStore.SaveSession(ctx, session)

     

       81
       81
       +
       		require.NoError(t, err, "Failed to save OAuth session")

     

       82
       82
       +
       		t.Logf("✅ Created OAuth session: %s", sessionID)

     

       83
       83
       +
       

     

       84
       84
       +
       		// 3. Verify session was created with correct data

     

       85
       85
       +
       		savedSession, err := baseOAuthStore.GetSession(ctx, parsedDID, sessionID)

     

       86
       86
       +
       		require.NoError(t, err, "Failed to retrieve saved session")

     

       87
       87
       +
       		require.NotNil(t, savedSession, "Session should exist")

     

       88
       88
       +
       		t.Logf("✅ Verified session exists for DID: %s", testDID)

     

       89
       89
       +
       

     

       90
       90
       +
       		// 4. Cast store to SessionHandleUpdater (what the consumer uses)

     

       91
       91
       +
       		sessionUpdater, ok := baseOAuthStore.(jetstream.SessionHandleUpdater)

     

       92
       92
       +
       		require.True(t, ok, "OAuth store should implement SessionHandleUpdater")

     

       93
       93
       +
       

     

       94
       94
       +
       		// 5. Create consumer with session handle updater

     

       95
       95
       +
       		consumer := jetstream.NewUserEventConsumer(

     

       96
       96
       +
       			userService,

     

       97
       97
       +
       			resolver,

     

       98
       98
       +
       			"", // No WebSocket URL - we'll call HandleIdentityEventPublic directly

     

       99
       99
       +
       			"",

     

       100
       100
       +
       			jetstream.WithSessionHandleUpdater(sessionUpdater),

     

       101
       101
       +
       		)

     

       102
       102
       +
       

     

       103
       103
       +
       		// 6. Simulate identity event with NEW handle (as if PDS sent handle change)

     

       104
       104
       +
       		identityEvent := &jetstream.JetstreamEvent{

     

       105
       105
       +
       			Did:  testDID,

     

       106
       106
       +
       			Kind: "identity",

     

       107
       107
       +
       			Identity: &jetstream.IdentityEvent{

     

       108
       108
       +
       				Did:    testDID,

     

       109
       109
       +
       				Handle: newHandle,

     

       110
       110
       +
       				Seq:    999999,

     

       111
       111
       +
       				Time:   time.Now().Format(time.RFC3339),

     

       112
       112
       +
       			},

     

       113
       113
       +
       		}

     

       114
       114
       +
       

     

       115
       115
       +
       		t.Logf("📡 Simulating identity event: %s → %s", oldHandle, newHandle)

     

       116
       116
       +
       		err = consumer.HandleIdentityEventPublic(ctx, identityEvent)

     

       117
       117
       +
       		require.NoError(t, err, "Failed to handle identity event")

     

       118
       118
       +
       		t.Logf("✅ Identity event processed")

     

       119
       119
       +
       

     

       120
       120
       +
       		// 7. Verify users table was updated

     

       121
       121
       +
       		user, err := userService.GetUserByDID(ctx, testDID)

     

       122
       122
       +
       		require.NoError(t, err, "Failed to get user after handle change")

     

       123
       123
       +
       		require.Equal(t, newHandle, user.Handle, "User handle should be updated in database")

     

       124
       124
       +
       		t.Logf("✅ Users table updated: handle=%s", user.Handle)

     

       125
       125
       +
       

     

       126
       126
       +
       		// 8. Verify OAuth session handle was updated

     

       127
       127
       +
       		var sessionHandle string

     

       128
       128
       +
       		err = db.QueryRowContext(ctx,

     

       129
       129
       +
       			"SELECT handle FROM oauth_sessions WHERE did = $1 AND session_id = $2",

     

       130
       130
       +
       			testDID, sessionID,

     

       131
       131
       +
       		).Scan(&sessionHandle)

     

       132
       132
       +
       		require.NoError(t, err, "Failed to query session handle")

     

       133
       133
       +
       		require.Equal(t, newHandle, sessionHandle, "OAuth session handle should be updated")

     

       134
       134
       +
       		t.Logf("✅ OAuth session handle updated: %s", sessionHandle)

     

       135
       135
       +
       	})

     

       136
       136
       +
       

     

       137
       137
       +
       	t.Run("Multiple sessions updated on handle change", func(t *testing.T) {

     

       138
       138
       +
       		testDID := "did:plc:multisession456"

     

       139
       139
       +
       		oldHandle := "multi.old.handle.test"

     

       140
       140
       +
       		newHandle := "multi.new.handle.test"

     

       141
       141
       +
       

     

       142
       142
       +
       		// 1. Create user

     

       143
       143
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       144
       144
       +
       			DID:    testDID,

     

       145
       145
       +
       			Handle: oldHandle,

     

       146
       146
       +
       			PDSURL: "https://bsky.social",

     

       147
       147
       +
       		})

     

       148
       148
       +
       		require.NoError(t, err)

     

       149
       149
       +
       

     

       150
       150
       +
       		// 2. Create multiple OAuth sessions (simulating login from multiple devices)

     

       151
       151
       +
       		parsedDID, _ := syntax.ParseDID(testDID)

     

       152
       152
       +
       		for i := 1; i <= 3; i++ {

     

       153
       153
       +
       			session := oauthlib.ClientSessionData{

     

       154
       154
       +
       				AccountDID:   parsedDID,

     

       155
       155
       +
       				SessionID:    fmt.Sprintf("multi-session-%d", i),

     

       156
       156
       +
       				HostURL:      "https://bsky.social",

     

       157
       157
       +
       				AccessToken:  fmt.Sprintf("access-token-%d", i),

     

       158
       158
       +
       				RefreshToken: fmt.Sprintf("refresh-token-%d", i),

     

       159
       159
       +
       				Scopes:       []string{"atproto"},

     

       160
       160
       +
       			}

     

       161
       161
       +
       			err = baseOAuthStore.SaveSession(ctx, session)

     

       162
       162
       +
       			require.NoError(t, err)

     

       163
       163
       +
       		}

     

       164
       164
       +
       		t.Logf("✅ Created 3 OAuth sessions for user")

     

       165
       165
       +
       

     

       166
       166
       +
       		// 3. Process identity event with new handle

     

       167
       167
       +
       		sessionUpdater := baseOAuthStore.(jetstream.SessionHandleUpdater)

     

       168
       168
       +
       		consumer := jetstream.NewUserEventConsumer(

     

       169
       169
       +
       			userService, resolver, "", "",

     

       170
       170
       +
       			jetstream.WithSessionHandleUpdater(sessionUpdater),

     

       171
       171
       +
       		)

     

       172
       172
       +
       

     

       173
       173
       +
       		identityEvent := &jetstream.JetstreamEvent{

     

       174
       174
       +
       			Did:  testDID,

     

       175
       175
       +
       			Kind: "identity",

     

       176
       176
       +
       			Identity: &jetstream.IdentityEvent{

     

       177
       177
       +
       				Did:    testDID,

     

       178
       178
       +
       				Handle: newHandle,

     

       179
       179
       +
       				Seq:    888888,

     

       180
       180
       +
       				Time:   time.Now().Format(time.RFC3339),

     

       181
       181
       +
       			},

     

       182
       182
       +
       		}

     

       183
       183
       +
       

     

       184
       184
       +
       		err = consumer.HandleIdentityEventPublic(ctx, identityEvent)

     

       185
       185
       +
       		require.NoError(t, err)

     

       186
       186
       +
       

     

       187
       187
       +
       		// 4. Verify ALL sessions were updated

     

       188
       188
       +
       		var count int

     

       189
       189
       +
       		err = db.QueryRowContext(ctx,

     

       190
       190
       +
       			"SELECT COUNT(*) FROM oauth_sessions WHERE did = $1 AND handle = $2",

     

       191
       191
       +
       			testDID, newHandle,

     

       192
       192
       +
       		).Scan(&count)

     

       193
       193
       +
       		require.NoError(t, err)

     

       194
       194
       +
       		require.Equal(t, 3, count, "All 3 sessions should have updated handles")

     

       195
       195
       +
       		t.Logf("✅ All %d sessions updated with new handle", count)

     

       196
       196
       +
       	})

     

       197
       197
       +
       

     

       198
       198
       +
       	t.Run("No sessions updated when user has no active sessions", func(t *testing.T) {

     

       199
       199
       +
       		testDID := "did:plc:nosessions789"

     

       200
       200
       +
       		oldHandle := "nosession.old.test"

     

       201
       201
       +
       		newHandle := "nosession.new.test"

     

       202
       202
       +
       

     

       203
       203
       +
       		// 1. Create user with no OAuth sessions

     

       204
       204
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       205
       205
       +
       			DID:    testDID,

     

       206
       206
       +
       			Handle: oldHandle,

     

       207
       207
       +
       			PDSURL: "https://bsky.social",

     

       208
       208
       +
       		})

     

       209
       209
       +
       		require.NoError(t, err)

     

       210
       210
       +
       

     

       211
       211
       +
       		// 2. Process identity event

     

       212
       212
       +
       		sessionUpdater := baseOAuthStore.(jetstream.SessionHandleUpdater)

     

       213
       213
       +
       		consumer := jetstream.NewUserEventConsumer(

     

       214
       214
       +
       			userService, resolver, "", "",

     

       215
       215
       +
       			jetstream.WithSessionHandleUpdater(sessionUpdater),

     

       216
       216
       +
       		)

     

       217
       217
       +
       

     

       218
       218
       +
       		identityEvent := &jetstream.JetstreamEvent{

     

       219
       219
       +
       			Did:  testDID,

     

       220
       220
       +
       			Kind: "identity",

     

       221
       221
       +
       			Identity: &jetstream.IdentityEvent{

     

       222
       222
       +
       				Did:    testDID,

     

       223
       223
       +
       				Handle: newHandle,

     

       224
       224
       +
       				Seq:    777777,

     

       225
       225
       +
       				Time:   time.Now().Format(time.RFC3339),

     

       226
       226
       +
       			},

     

       227
       227
       +
       		}

     

       228
       228
       +
       

     

       229
       229
       +
       		// Should not error even when no sessions exist

     

       230
       230
       +
       		err = consumer.HandleIdentityEventPublic(ctx, identityEvent)

     

       231
       231
       +
       		require.NoError(t, err, "Should handle event gracefully with no sessions")

     

       232
       232
       +
       

     

       233
       233
       +
       		// 3. Verify user was still updated

     

       234
       234
       +
       		user, err := userService.GetUserByDID(ctx, testDID)

     

       235
       235
       +
       		require.NoError(t, err)

     

       236
       236
       +
       		require.Equal(t, newHandle, user.Handle)

     

       237
       237
       +
       		t.Logf("✅ User updated correctly even with no active sessions")

     

       238
       238
       +
       	})

     

       239
       239
       +
       

     

       240
       240
       +
       	t.Run("Consumer works without session updater (backward compat)", func(t *testing.T) {

     

       241
       241
       +
       		testDID := "did:plc:nosyncer000"

     

       242
       242
       +
       		oldHandle := "nosyncer.old.test"

     

       243
       243
       +
       		newHandle := "nosyncer.new.test"

     

       244
       244
       +
       

     

       245
       245
       +
       		// 1. Create user

     

       246
       246
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       247
       247
       +
       			DID:    testDID,

     

       248
       248
       +
       			Handle: oldHandle,

     

       249
       249
       +
       			PDSURL: "https://bsky.social",

     

       250
       250
       +
       		})

     

       251
       251
       +
       		require.NoError(t, err)

     

       252
       252
       +
       

     

       253
       253
       +
       		// 2. Create consumer WITHOUT session handle updater

     

       254
       254
       +
       		consumer := jetstream.NewUserEventConsumer(

     

       255
       255
       +
       			userService, resolver, "", "",

     

       256
       256
       +
       			// No WithSessionHandleUpdater - testing backward compatibility

     

       257
       257
       +
       		)

     

       258
       258
       +
       

     

       259
       259
       +
       		// 3. Process identity event - should work without error

     

       260
       260
       +
       		identityEvent := &jetstream.JetstreamEvent{

     

       261
       261
       +
       			Did:  testDID,

     

       262
       262
       +
       			Kind: "identity",

     

       263
       263
       +
       			Identity: &jetstream.IdentityEvent{

     

       264
       264
       +
       				Did:    testDID,

     

       265
       265
       +
       				Handle: newHandle,

     

       266
       266
       +
       				Seq:    666666,

     

       267
       267
       +
       				Time:   time.Now().Format(time.RFC3339),

     

       268
       268
       +
       			},

     

       269
       269
       +
       		}

     

       270
       270
       +
       

     

       271
       271
       +
       		err = consumer.HandleIdentityEventPublic(ctx, identityEvent)

     

       272
       272
       +
       		require.NoError(t, err, "Consumer should work without session updater")

     

       273
       273
       +
       

     

       274
       274
       +
       		// 4. Verify user was updated

     

       275
       275
       +
       		user, err := userService.GetUserByDID(ctx, testDID)

     

       276
       276
       +
       		require.NoError(t, err)

     

       277
       277
       +
       		require.Equal(t, newHandle, user.Handle)

     

       278
       278
       +
       		t.Logf("✅ Consumer works correctly without session handle updater")

     

       279
       279
       +
       	})

     

       280
       280
       +
       }

     

       281
       281
       +
       

     

       282
       282
       +
       // TestOAuthSessionHandleSync_LiveJetstream tests the full flow with real Jetstream

     

       283
       283
       +
       // This requires the dev infrastructure to be running.

     

       284
       284
       +
       //

     

       285
       285
       +
       // Prerequisites:

     

       286
       286
       +
       //   - PDS running on localhost:3001

     

       287
       287
       +
       //   - Jetstream running on localhost:6008

     

       288
       288
       +
       //   - Test database on localhost:5434

     

       289
       289
       +
       //

     

       290
       290
       +
       // Run with:

     

       291
       291
       +
       //

     

       292
       292
       +
       //	docker-compose --profile test --profile jetstream up -d

     

       293
       293
       +
       //	TEST_DATABASE_URL="postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" \

     

       294
       294
       +
       //	  go test -v ./tests/integration/ -run "TestOAuthSessionHandleSync_LiveJetstream"

     

       295
       295
       +
       func TestOAuthSessionHandleSync_LiveJetstream(t *testing.T) {

     

       296
       296
       +
       	if testing.Short() {

     

       297
       297
       +
       		t.Skip("Skipping live Jetstream test in short mode")

     

       298
       298
       +
       	}

     

       299
       299
       +
       

     

       300
       300
       +
       	// Check if Jetstream is available

     

       301
       301
       +
       	if !isServiceAvailable("http://localhost:6008") {

     

       302
       302
       +
       		t.Skip("Jetstream not available at localhost:6008 - run 'docker-compose --profile jetstream up -d' first")

     

       303
       303
       +
       	}

     

       304
       304
       +
       

     

       305
       305
       +
       	// Check if PDS is available

     

       306
       306
       +
       	if !isServiceAvailable("http://localhost:3001/xrpc/_health") {

     

       307
       307
       +
       		t.Skip("PDS not available at localhost:3001 - run 'docker-compose up -d pds' first")

     

       308
       308
       +
       	}

     

       309
       309
       +
       

     

       310
       310
       +
       	db := setupTestDB(t)

     

       311
       311
       +
       	defer func() {

     

       312
       312
       +
       		if err := db.Close(); err != nil {

     

       313
       313
       +
       			t.Logf("Failed to close database: %v", err)

     

       314
       314
       +
       		}

     

       315
       315
       +
       	}()

     

       316
       316
       +
       

     

       317
       317
       +
       	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

     

       318
       318
       +
       	defer cancel()

     

       319
       319
       +
       

     

       320
       320
       +
       	// Set up real infrastructure

     

       321
       321
       +
       	userRepo := postgres.NewUserRepository(db)

     

       322
       322
       +
       	resolver := identity.NewResolver(db, identity.DefaultConfig())

     

       323
       323
       +
       	userService := users.NewUserService(userRepo, resolver, "http://localhost:3001")

     

       324
       324
       +
       	baseOAuthStore := oauth.NewPostgresOAuthStore(db, 24*time.Hour)

     

       325
       325
       +
       	sessionUpdater := baseOAuthStore.(jetstream.SessionHandleUpdater)

     

       326
       326
       +
       

     

       327
       327
       +
       	// Start consumer connected to real Jetstream

     

       328
       328
       +
       	consumer := jetstream.NewUserEventConsumer(

     

       329
       329
       +
       		userService,

     

       330
       330
       +
       		resolver,

     

       331
       331
       +
       		"ws://localhost:6008/subscribe",

     

       332
       332
       +
       		"",

     

       333
       333
       +
       		jetstream.WithSessionHandleUpdater(sessionUpdater),

     

       334
       334
       +
       	)

     

       335
       335
       +
       

     

       336
       336
       +
       	// Start consumer in background

     

       337
       337
       +
       	consumerCtx, consumerCancel := context.WithCancel(ctx)

     

       338
       338
       +
       	defer consumerCancel()

     

       339
       339
       +
       

     

       340
       340
       +
       	go func() {

     

       341
       341
       +
       		if err := consumer.Start(consumerCtx); err != nil && err != context.Canceled {

     

       342
       342
       +
       			t.Logf("Consumer stopped: %v", err)

     

       343
       343
       +
       		}

     

       344
       344
       +
       	}()

     

       345
       345
       +
       

     

       346
       346
       +
       	// Give consumer time to connect

     

       347
       347
       +
       	time.Sleep(500 * time.Millisecond)

     

       348
       348
       +
       

     

       349
       349
       +
       	t.Run("Real Jetstream integration", func(t *testing.T) {

     

       350
       350
       +
       		t.Log("🔌 Connected to live Jetstream - waiting for identity events...")

     

       351
       351
       +
       		t.Log("Note: This test verifies the consumer is properly configured with session sync.")

     

       352
       352
       +
       		t.Log("To fully test handle sync, create a user on the PDS and change their handle.")

     

       353
       353
       +
       

     

       354
       354
       +
       		// For now, just verify the consumer is running with the session updater

     

       355
       355
       +
       		// A full E2E test would require:

     

       356
       356
       +
       		// 1. Create user on PDS

     

       357
       357
       +
       		// 2. Create OAuth session

     

       358
       358
       +
       		// 3. Update handle on PDS (via user credentials)

     

       359
       359
       +
       		// 4. Wait for Jetstream to deliver identity event

     

       360
       360
       +
       		// 5. Verify session handle updated

     

       361
       361
       +
       

     

       362
       362
       +
       		t.Log("✅ Consumer running with OAuth session sync enabled")

     

       363
       363
       +
       	})

     

       364
       364
       +
       }

     

       365
       365
       +
       

     

       366
       366
       +
       // isServiceAvailable checks if an HTTP service is responding

     

       367
       367
       +
       func isServiceAvailable(url string) bool {

     

       368
       368
       +
       	client := &http.Client{Timeout: 2 * time.Second}

     

       369
       369
       +
       	resp, err := client.Get(url)

     

       370
       370
       +
       	if err != nil {

     

       371
       371
       +
       		return false

     

       372
       372
       +
       	}

     

       373
       373
       +
       	defer resp.Body.Close()

     

       374
       374
       +
       	return resp.StatusCode < 500

     

       375
       375
       +
       }

+76 -1

aggregators/kagi-news/tests/test_e2e.py

···

       421
       421
        
           assert embed["external"]["description"] == "Test description"

     

       422
       422
        
           # Thumbnail is not included - server's unfurl service handles it

     

       423
       423
        
           assert "thumb" not in embed["external"]

     

       424
       424
       -
           print("\n✅ External embed format correct")

     

       424
       424
       +
           # Sources should not be present when not provided

     

       425
       425
       +
           assert "sources" not in embed["external"]

     

       426
       426
       +
           print("\n✅ External embed format correct (no sources)")

     

       427
       427
       +
       

     

       428
       428
       +
       

     

       429
       429
       +
       def test_coves_client_external_embed_with_sources(aggregator_credentials):

     

       430
       430
       +
           """

     

       431
       431
       +
           Test external embed formatting with sources.

     

       432
       432
       +
       

     

       433
       433
       +
           Verifies:

     

       434
       434
       +
           - Embed structure matches social.coves.embed.external

     

       435
       435
       +
           - Sources array is included when provided

     

       436
       436
       +
           - Each source has uri, title, domain

     

       437
       437
       +
           """

     

       438
       438
       +
           handle, password = aggregator_credentials

     

       439
       439
       +
       

     

       440
       440
       +
           client = CovesClient(

     

       441
       441
       +
               api_url="http://localhost:8081",

     

       442
       442
       +
               handle=handle,

     

       443
       443
       +
               password=password

     

       444
       444
       +
           )

     

       445
       445
       +
       

     

       446
       446
       +
           # Create external embed with sources

     

       447
       447
       +
           sources = [

     

       448
       448
       +
               {"uri": "https://source1.com/article", "title": "Source 1 Article", "domain": "source1.com"},

     

       449
       449
       +
               {"uri": "https://source2.com/story", "title": "Source 2 Story", "domain": "source2.com"},

     

       450
       450
       +
           ]

     

       451
       451
       +
       

     

       452
       452
       +
           embed = client.create_external_embed(

     

       453
       453
       +
               uri="https://example.com/story",

     

       454
       454
       +
               title="Test Story With Sources",

     

       455
       455
       +
               description="Test description with sources",

     

       456
       456
       +
               sources=sources

     

       457
       457
       +
           )

     

       458
       458
       +
       

     

       459
       459
       +
           assert embed["$type"] == "social.coves.embed.external"

     

       460
       460
       +
           assert embed["external"]["uri"] == "https://example.com/story"

     

       461
       461
       +
           assert embed["external"]["title"] == "Test Story With Sources"

     

       462
       462
       +
           assert embed["external"]["description"] == "Test description with sources"

     

       463
       463
       +
           # Sources should be present

     

       464
       464
       +
           assert "sources" in embed["external"]

     

       465
       465
       +
           assert len(embed["external"]["sources"]) == 2

     

       466
       466
       +
           assert embed["external"]["sources"][0]["uri"] == "https://source1.com/article"

     

       467
       467
       +
           assert embed["external"]["sources"][0]["title"] == "Source 1 Article"

     

       468
       468
       +
           assert embed["external"]["sources"][0]["domain"] == "source1.com"

     

       469
       469
       +
           assert embed["external"]["sources"][1]["uri"] == "https://source2.com/story"

     

       470
       470
       +
           print("\n✅ External embed format correct (with sources)")

     

       471
       471
       +
       

     

       472
       472
       +
       

     

       473
       473
       +
       def test_coves_client_external_embed_with_empty_sources(aggregator_credentials):

     

       474
       474
       +
           """

     

       475
       475
       +
           Test external embed formatting with empty sources list.

     

       476
       476
       +
       

     

       477
       477
       +
           Verifies:

     

       478
       478
       +
           - Empty sources list is not included in embed (regression test)

     

       479
       479
       +
           """

     

       480
       480
       +
           handle, password = aggregator_credentials

     

       481
       481
       +
       

     

       482
       482
       +
           client = CovesClient(

     

       483
       483
       +
               api_url="http://localhost:8081",

     

       484
       484
       +
               handle=handle,

     

       485
       485
       +
               password=password

     

       486
       486
       +
           )

     

       487
       487
       +
       

     

       488
       488
       +
           # Create external embed with empty sources list

     

       489
       489
       +
           embed = client.create_external_embed(

     

       490
       490
       +
               uri="https://example.com/story",

     

       491
       491
       +
               title="Test Story",

     

       492
       492
       +
               description="Test description",

     

       493
       493
       +
               sources=[]

     

       494
       494
       +
           )

     

       495
       495
       +
       

     

       496
       496
       +
           assert embed["$type"] == "social.coves.embed.external"

     

       497
       497
       +
           # Empty sources list should not be included

     

       498
       498
       +
           assert "sources" not in embed["external"]

     

       499
       499
       +
           print("\n✅ External embed format correct (empty sources excluded)")

+137

aggregators/kagi-news/tests/test_main.py

···

       459
       459
        
                   assert call_kwargs["embed"]["external"]["title"] == sample_story.title

     

       460
       460
        
                   # Thumbnail is not included - server's unfurl service handles it

     

       461
       461
        
                   assert "thumb" not in call_kwargs["embed"]["external"]

     

       462
       462
       +
       

     

       463
       463
       +
           def test_create_post_with_sources_in_embed(self, mock_config, mock_rss_feed, sample_story, tmp_path):

     

       464
       464
       +
               """Test that posts include sources in external embeds when available."""

     

       465
       465
       +
               state_file = tmp_path / "state.json"

     

       466
       466
       +
               mock_client = Mock()

     

       467
       467
       +
               mock_client.create_post.return_value = "at://did:plc:test/social.coves.post/abc123"

     

       468
       468
       +
       

     

       469
       469
       +
               # Mock create_external_embed to return proper embed structure with sources

     

       470
       470
       +
               mock_client.create_external_embed.return_value = {

     

       471
       471
       +
                   "$type": "social.coves.embed.external",

     

       472
       472
       +
                   "external": {

     

       473
       473
       +
                       "uri": sample_story.link,

     

       474
       474
       +
                       "title": sample_story.title,

     

       475
       475
       +
                       "description": sample_story.summary,

     

       476
       476
       +
                       "sources": [

     

       477
       477
       +
                           {"uri": "https://example.com/1", "title": "Source 1", "domain": "example.com"}

     

       478
       478
       +
                       ]

     

       479
       479
       +
                   }

     

       480
       480
       +
               }

     

       481
       481
       +
       

     

       482
       482
       +
               with patch('src.main.ConfigLoader') as MockConfigLoader, \

     

       483
       483
       +
                    patch('src.main.RSSFetcher') as MockRSSFetcher, \

     

       484
       484
       +
                    patch('src.main.KagiHTMLParser') as MockHTMLParser, \

     

       485
       485
       +
                    patch('src.main.RichTextFormatter') as MockFormatter:

     

       486
       486
       +
       

     

       487
       487
       +
                   # Setup mocks

     

       488
       488
       +
                   mock_loader = Mock()

     

       489
       489
       +
                   mock_loader.load.return_value = mock_config

     

       490
       490
       +
                   MockConfigLoader.return_value = mock_loader

     

       491
       491
       +
       

     

       492
       492
       +
                   mock_fetcher = Mock()

     

       493
       493
       +
                   single_entry_feed = MagicMock(bozo=0, entries=[mock_rss_feed.entries[0]])

     

       494
       494
       +
                   mock_fetcher.fetch_feed.return_value = single_entry_feed

     

       495
       495
       +
                   MockRSSFetcher.return_value = mock_fetcher

     

       496
       496
       +
       

     

       497
       497
       +
                   mock_parser = Mock()

     

       498
       498
       +
                   mock_parser.parse_to_story.return_value = sample_story

     

       499
       499
       +
                   MockHTMLParser.return_value = mock_parser

     

       500
       500
       +
       

     

       501
       501
       +
                   mock_formatter = Mock()

     

       502
       502
       +
                   mock_formatter.format_full.return_value = {

     

       503
       503
       +
                       "content": "Test content",

     

       504
       504
       +
                       "facets": []

     

       505
       505
       +
                   }

     

       506
       506
       +
                   MockFormatter.return_value = mock_formatter

     

       507
       507
       +
       

     

       508
       508
       +
                   # Run aggregator

     

       509
       509
       +
                   aggregator = Aggregator(

     

       510
       510
       +
                       config_path=Path("config.yaml"),

     

       511
       511
       +
                       state_file=state_file,

     

       512
       512
       +
                       coves_client=mock_client

     

       513
       513
       +
                   )

     

       514
       514
       +
                   aggregator.run()

     

       515
       515
       +
       

     

       516
       516
       +
                   # Verify create_external_embed was called with sources

     

       517
       517
       +
                   mock_client.create_external_embed.assert_called()

     

       518
       518
       +
                   call_kwargs = mock_client.create_external_embed.call_args.kwargs

     

       519
       519
       +
       

     

       520
       520
       +
                   # Verify sources were passed

     

       521
       521
       +
                   assert "sources" in call_kwargs

     

       522
       522
       +
                   assert len(call_kwargs["sources"]) == 1

     

       523
       523
       +
                   assert call_kwargs["sources"][0]["uri"] == "https://example.com/1"

     

       524
       524
       +
                   assert call_kwargs["sources"][0]["title"] == "Source 1"

     

       525
       525
       +
                   assert call_kwargs["sources"][0]["domain"] == "example.com"

     

       526
       526
       +
       

     

       527
       527
       +
           def test_create_post_without_sources(self, mock_config, mock_rss_feed, tmp_path):

     

       528
       528
       +
               """Test that posts without sources don't include sources in embed."""

     

       529
       529
       +
               state_file = tmp_path / "state.json"

     

       530
       530
       +
               mock_client = Mock()

     

       531
       531
       +
               mock_client.create_post.return_value = "at://did:plc:test/social.coves.post/abc123"

     

       532
       532
       +
       

     

       533
       533
       +
               # Create a story without sources

     

       534
       534
       +
               story_without_sources = KagiStory(

     

       535
       535
       +
                   title="Test Story No Sources",

     

       536
       536
       +
                   link="https://kite.kagi.com/test/world/1",

     

       537
       537
       +
                   guid="https://kite.kagi.com/test/world/1",

     

       538
       538
       +
                   pub_date=datetime(2024, 1, 15, 12, 0, 0),

     

       539
       539
       +
                   categories=["World"],

     

       540
       540
       +
                   summary="Test summary",

     

       541
       541
       +
                   highlights=[],

     

       542
       542
       +
                   perspectives=[],

     

       543
       543
       +
                   quote=None,

     

       544
       544
       +
                   sources=[],  # No sources

     

       545
       545
       +
                   image_url=None,

     

       546
       546
       +
                   image_alt=None

     

       547
       547
       +
               )

     

       548
       548
       +
       

     

       549
       549
       +
               # Mock create_external_embed to return proper embed structure without sources

     

       550
       550
       +
               mock_client.create_external_embed.return_value = {

     

       551
       551
       +
                   "$type": "social.coves.embed.external",

     

       552
       552
       +
                   "external": {

     

       553
       553
       +
                       "uri": story_without_sources.link,

     

       554
       554
       +
                       "title": story_without_sources.title,

     

       555
       555
       +
                       "description": story_without_sources.summary

     

       556
       556
       +
                   }

     

       557
       557
       +
               }

     

       558
       558
       +
       

     

       559
       559
       +
               with patch('src.main.ConfigLoader') as MockConfigLoader, \

     

       560
       560
       +
                    patch('src.main.RSSFetcher') as MockRSSFetcher, \

     

       561
       561
       +
                    patch('src.main.KagiHTMLParser') as MockHTMLParser, \

     

       562
       562
       +
                    patch('src.main.RichTextFormatter') as MockFormatter:

     

       563
       563
       +
       

     

       564
       564
       +
                   # Setup mocks

     

       565
       565
       +
                   mock_loader = Mock()

     

       566
       566
       +
                   mock_loader.load.return_value = mock_config

     

       567
       567
       +
                   MockConfigLoader.return_value = mock_loader

     

       568
       568
       +
       

     

       569
       569
       +
                   mock_fetcher = Mock()

     

       570
       570
       +
                   single_entry_feed = MagicMock(bozo=0, entries=[mock_rss_feed.entries[0]])

     

       571
       571
       +
                   mock_fetcher.fetch_feed.return_value = single_entry_feed

     

       572
       572
       +
                   MockRSSFetcher.return_value = mock_fetcher

     

       573
       573
       +
       

     

       574
       574
       +
                   mock_parser = Mock()

     

       575
       575
       +
                   mock_parser.parse_to_story.return_value = story_without_sources

     

       576
       576
       +
                   MockHTMLParser.return_value = mock_parser

     

       577
       577
       +
       

     

       578
       578
       +
                   mock_formatter = Mock()

     

       579
       579
       +
                   mock_formatter.format_full.return_value = {

     

       580
       580
       +
                       "content": "Test content",

     

       581
       581
       +
                       "facets": []

     

       582
       582
       +
                   }

     

       583
       583
       +
                   MockFormatter.return_value = mock_formatter

     

       584
       584
       +
       

     

       585
       585
       +
                   # Run aggregator

     

       586
       586
       +
                   aggregator = Aggregator(

     

       587
       587
       +
                       config_path=Path("config.yaml"),

     

       588
       588
       +
                       state_file=state_file,

     

       589
       589
       +
                       coves_client=mock_client

     

       590
       590
       +
                   )

     

       591
       591
       +
                   aggregator.run()

     

       592
       592
       +
       

     

       593
       593
       +
                   # Verify create_external_embed was called

     

       594
       594
       +
                   mock_client.create_external_embed.assert_called()

     

       595
       595
       +
                   call_kwargs = mock_client.create_external_embed.call_args.kwargs

     

       596
       596
       +
       

     

       597
       597
       +
                   # Verify sources is None (empty list becomes None)

     

       598
       598
       +
                   assert call_kwargs.get("sources") is None

+1188

tests/integration/comment_e2e_test.go

···

       1
       1
       +
       package integration

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/jetstream"

     

       5
       5
       +
       	"Coves/internal/atproto/pds"

     

       6
       6
       +
       	"Coves/internal/atproto/utils"

     

       7
       7
       +
       	"Coves/internal/core/comments"

     

       8
       8
       +
       	"Coves/internal/db/postgres"

     

       9
       9
       +
       	"context"

     

       10
       10
       +
       	"database/sql"

     

       11
       11
       +
       	"encoding/json"

     

       12
       12
       +
       	"fmt"

     

       13
       13
       +
       	"io"

     

       14
       14
       +
       	"net"

     

       15
       15
       +
       	"net/http"

     

       16
       16
       +
       	"os"

     

       17
       17
       +
       	"strings"

     

       18
       18
       +
       	"testing"

     

       19
       19
       +
       	"time"

     

       20
       20
       +
       

     

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

     

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

     

       23
       23
       +
       	"github.com/gorilla/websocket"

     

       24
       24
       +
       	_ "github.com/lib/pq"

     

       25
       25
       +
       	"github.com/pressly/goose/v3"

     

       26
       26
       +
       )

     

       27
       27
       +
       

     

       28
       28
       +
       // TestCommentE2E_CreateWithJetstream tests the full comment creation flow with real Jetstream

     

       29
       29
       +
       // Flow: Client → Service → PDS Write → Jetstream Firehose → Consumer → AppView

     

       30
       30
       +
       func TestCommentE2E_CreateWithJetstream(t *testing.T) {

     

       31
       31
       +
       	if testing.Short() {

     

       32
       32
       +
       		t.Skip("Skipping E2E test in short mode")

     

       33
       33
       +
       	}

     

       34
       34
       +
       

     

       35
       35
       +
       	// Setup test database

     

       36
       36
       +
       	dbURL := os.Getenv("TEST_DATABASE_URL")

     

       37
       37
       +
       	if dbURL == "" {

     

       38
       38
       +
       		dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable"

     

       39
       39
       +
       	}

     

       40
       40
       +
       

     

       41
       41
       +
       	db, err := sql.Open("postgres", dbURL)

     

       42
       42
       +
       	if err != nil {

     

       43
       43
       +
       		t.Fatalf("Failed to connect to test database: %v", err)

     

       44
       44
       +
       	}

     

       45
       45
       +
       	defer func() { _ = db.Close() }()

     

       46
       46
       +
       

     

       47
       47
       +
       	// Run migrations

     

       48
       48
       +
       	if dialectErr := goose.SetDialect("postgres"); dialectErr != nil {

     

       49
       49
       +
       		t.Fatalf("Failed to set goose dialect: %v", dialectErr)

     

       50
       50
       +
       	}

     

       51
       51
       +
       	if migrateErr := goose.Up(db, "../../internal/db/migrations"); migrateErr != nil {

     

       52
       52
       +
       		t.Fatalf("Failed to run migrations: %v", migrateErr)

     

       53
       53
       +
       	}

     

       54
       54
       +
       

     

       55
       55
       +
       	// Check if PDS is running

     

       56
       56
       +
       	pdsURL := getTestPDSURL()

     

       57
       57
       +
       	healthResp, err := http.Get(pdsURL + "/xrpc/_health")

     

       58
       58
       +
       	if err != nil {

     

       59
       59
       +
       		t.Skipf("PDS not running at %s: %v", pdsURL, err)

     

       60
       60
       +
       	}

     

       61
       61
       +
       	_ = healthResp.Body.Close()

     

       62
       62
       +
       

     

       63
       63
       +
       	// Check if Jetstream is running

     

       64
       64
       +
       	pdsHostname := strings.TrimPrefix(pdsURL, "http://")

     

       65
       65
       +
       	pdsHostname = strings.TrimPrefix(pdsHostname, "https://")

     

       66
       66
       +
       	pdsHostname = strings.Split(pdsHostname, ":")[0]

     

       67
       67
       +
       	jetstreamURL := fmt.Sprintf("ws://%s:6008/subscribe?wantedCollections=social.coves.community.comment", pdsHostname)

     

       68
       68
       +
       

     

       69
       69
       +
       	testConn, _, err := websocket.DefaultDialer.Dial(jetstreamURL, nil)

     

       70
       70
       +
       	if err != nil {

     

       71
       71
       +
       		t.Skipf("Jetstream not running at %s: %v. Run 'docker-compose --profile jetstream up' to start.", jetstreamURL, err)

     

       72
       72
       +
       	}

     

       73
       73
       +
       	_ = testConn.Close()

     

       74
       74
       +
       

     

       75
       75
       +
       	ctx := context.Background()

     

       76
       76
       +
       

     

       77
       77
       +
       	// Setup repositories

     

       78
       78
       +
       	commentRepo := postgres.NewCommentRepository(db)

     

       79
       79
       +
       	postRepo := postgres.NewPostRepository(db)

     

       80
       80
       +
       

     

       81
       81
       +
       	// Create test user on PDS

     

       82
       82
       +
       	// Use shorter handle to avoid PDS length limits (max 20 chars for label)

     

       83
       83
       +
       	testUserHandle := fmt.Sprintf("cmt%d.local.coves.dev", time.Now().UnixNano()%1000000)

     

       84
       84
       +
       	testUserEmail := fmt.Sprintf("cmt%d@test.local", time.Now().UnixNano()%1000000)

     

       85
       85
       +
       	testUserPassword := "test-password-123"

     

       86
       86
       +
       

     

       87
       87
       +
       	t.Logf("Creating test user on PDS: %s", testUserHandle)

     

       88
       88
       +
       	pdsAccessToken, userDID, err := createPDSAccount(pdsURL, testUserHandle, testUserEmail, testUserPassword)

     

       89
       89
       +
       	if err != nil {

     

       90
       90
       +
       		t.Fatalf("Failed to create test user on PDS: %v", err)

     

       91
       91
       +
       	}

     

       92
       92
       +
       	t.Logf("Test user created: DID=%s", userDID)

     

       93
       93
       +
       

     

       94
       94
       +
       	// Index user in AppView

     

       95
       95
       +
       	testUser := createTestUser(t, db, testUserHandle, userDID)

     

       96
       96
       +
       

     

       97
       97
       +
       	// Create test community and post to comment on

     

       98
       98
       +
       	testCommunityDID, err := createFeedTestCommunity(db, ctx, "comment-e2e-community", "owner.test")

     

       99
       99
       +
       	if err != nil {

     

       100
       100
       +
       		t.Fatalf("Failed to create test community: %v", err)

     

       101
       101
       +
       	}

     

       102
       102
       +
       

     

       103
       103
       +
       	postURI := createTestPost(t, db, testCommunityDID, testUser.DID, "Test Post for Comments", 0, time.Now())

     

       104
       104
       +
       	postCID := "bafyposte2etest"

     

       105
       105
       +
       

     

       106
       106
       +
       	// Setup comment service with PDS factory

     

       107
       107
       +
       	commentPDSFactory := func(ctx context.Context, session *oauthlib.ClientSessionData) (pds.Client, error) {

     

       108
       108
       +
       		if session.AccessToken == "" {

     

       109
       109
       +
       			return nil, fmt.Errorf("session has no access token")

     

       110
       110
       +
       		}

     

       111
       111
       +
       		if session.HostURL == "" {

     

       112
       112
       +
       			return nil, fmt.Errorf("session has no host URL")

     

       113
       113
       +
       		}

     

       114
       114
       +
       		return pds.NewFromAccessToken(session.HostURL, session.AccountDID.String(), session.AccessToken)

     

       115
       115
       +
       	}

     

       116
       116
       +
       

     

       117
       117
       +
       	commentService := comments.NewCommentServiceWithPDSFactory(

     

       118
       118
       +
       		commentRepo,

     

       119
       119
       +
       		nil,

     

       120
       120
       +
       		postRepo,

     

       121
       121
       +
       		nil,

     

       122
       122
       +
       		nil,

     

       123
       123
       +
       		commentPDSFactory,

     

       124
       124
       +
       	)

     

       125
       125
       +
       

     

       126
       126
       +
       	// Create mock OAuth session

     

       127
       127
       +
       	mockStore := NewMockOAuthStore()

     

       128
       128
       +
       	mockStore.AddSessionWithPDS(userDID, "session-"+userDID, pdsAccessToken, pdsURL)

     

       129
       129
       +
       

     

       130
       130
       +
       	t.Run("create comment with real Jetstream indexing", func(t *testing.T) {

     

       131
       131
       +
       		// Setup Jetstream consumer

     

       132
       132
       +
       		commentConsumer := jetstream.NewCommentEventConsumer(commentRepo, db)

     

       133
       133
       +
       

     

       134
       134
       +
       		// Channels for event communication

     

       135
       135
       +
       		eventChan := make(chan *jetstream.JetstreamEvent, 10)

     

       136
       136
       +
       		errorChan := make(chan error, 1)

     

       137
       137
       +
       		done := make(chan bool)

     

       138
       138
       +
       

     

       139
       139
       +
       		// Start Jetstream consumer in background BEFORE writing to PDS

     

       140
       140
       +
       		t.Logf("\n🔄 Starting Jetstream consumer for comments...")

     

       141
       141
       +
       		go func() {

     

       142
       142
       +
       			subscribeErr := subscribeToJetstreamForComment(ctx, jetstreamURL, userDID, commentConsumer, eventChan, done)

     

       143
       143
       +
       			if subscribeErr != nil {

     

       144
       144
       +
       				errorChan <- subscribeErr

     

       145
       145
       +
       			}

     

       146
       146
       +
       		}()

     

       147
       147
       +
       

     

       148
       148
       +
       		// Give Jetstream a moment to connect

     

       149
       149
       +
       		time.Sleep(500 * time.Millisecond)

     

       150
       150
       +
       

     

       151
       151
       +
       		// Create comment via service (writes to PDS)

     

       152
       152
       +
       		t.Logf("\n📝 Creating comment via service (writes to PDS)...")

     

       153
       153
       +
       

     

       154
       154
       +
       		commentReq := comments.CreateCommentRequest{

     

       155
       155
       +
       			Reply: comments.ReplyRef{

     

       156
       156
       +
       				Root: comments.StrongRef{

     

       157
       157
       +
       					URI: postURI,

     

       158
       158
       +
       					CID: postCID,

     

       159
       159
       +
       				},

     

       160
       160
       +
       				Parent: comments.StrongRef{

     

       161
       161
       +
       					URI: postURI,

     

       162
       162
       +
       					CID: postCID,

     

       163
       163
       +
       				},

     

       164
       164
       +
       			},

     

       165
       165
       +
       			Content: "This is a TRUE E2E test comment via Jetstream!",

     

       166
       166
       +
       			Langs:   []string{"en"},

     

       167
       167
       +
       		}

     

       168
       168
       +
       

     

       169
       169
       +
       		parsedDID, parseErr := syntax.ParseDID(userDID)

     

       170
       170
       +
       		if parseErr != nil {

     

       171
       171
       +
       			t.Fatalf("Failed to parse DID: %v", parseErr)

     

       172
       172
       +
       		}

     

       173
       173
       +
       		session, sessionErr := mockStore.GetSession(ctx, parsedDID, "session-"+userDID)

     

       174
       174
       +
       		if sessionErr != nil {

     

       175
       175
       +
       			t.Fatalf("Failed to get session: %v", sessionErr)

     

       176
       176
       +
       		}

     

       177
       177
       +
       

     

       178
       178
       +
       		commentResp, err := commentService.CreateComment(ctx, session, commentReq)

     

       179
       179
       +
       		if err != nil {

     

       180
       180
       +
       			t.Fatalf("Failed to create comment: %v", err)

     

       181
       181
       +
       		}

     

       182
       182
       +
       

     

       183
       183
       +
       		t.Logf("✅ Comment written to PDS:")

     

       184
       184
       +
       		t.Logf("   URI: %s", commentResp.URI)

     

       185
       185
       +
       		t.Logf("   CID: %s", commentResp.CID)

     

       186
       186
       +
       

     

       187
       187
       +
       		// Wait for Jetstream event

     

       188
       188
       +
       		t.Logf("\n⏳ Waiting for Jetstream event (max 30 seconds)...")

     

       189
       189
       +
       

     

       190
       190
       +
       		select {

     

       191
       191
       +
       		case event := <-eventChan:

     

       192
       192
       +
       			t.Logf("✅ Received real Jetstream event!")

     

       193
       193
       +
       			t.Logf("   Event DID:    %s", event.Did)

     

       194
       194
       +
       			t.Logf("   Collection:   %s", event.Commit.Collection)

     

       195
       195
       +
       			t.Logf("   Operation:    %s", event.Commit.Operation)

     

       196
       196
       +
       			t.Logf("   RKey:         %s", event.Commit.RKey)

     

       197
       197
       +
       

     

       198
       198
       +
       			// Verify it's our comment

     

       199
       199
       +
       			if event.Did != userDID {

     

       200
       200
       +
       				t.Errorf("Expected DID %s, got %s", userDID, event.Did)

     

       201
       201
       +
       			}

     

       202
       202
       +
       			if event.Commit.Collection != "social.coves.community.comment" {

     

       203
       203
       +
       				t.Errorf("Expected collection social.coves.community.comment, got %s", event.Commit.Collection)

     

       204
       204
       +
       			}

     

       205
       205
       +
       			if event.Commit.Operation != "create" {

     

       206
       206
       +
       				t.Errorf("Expected operation create, got %s", event.Commit.Operation)

     

       207
       207
       +
       			}

     

       208
       208
       +
       

     

       209
       209
       +
       			// Verify indexed in AppView database

     

       210
       210
       +
       			t.Logf("\n🔍 Querying AppView database...")

     

       211
       211
       +
       			indexedComment, err := commentRepo.GetByURI(ctx, commentResp.URI)

     

       212
       212
       +
       			if err != nil {

     

       213
       213
       +
       				t.Fatalf("Comment not indexed in AppView: %v", err)

     

       214
       214
       +
       			}

     

       215
       215
       +
       

     

       216
       216
       +
       			t.Logf("✅ Comment indexed in AppView:")

     

       217
       217
       +
       			t.Logf("   CommenterDID: %s", indexedComment.CommenterDID)

     

       218
       218
       +
       			t.Logf("   Content:      %s", indexedComment.Content)

     

       219
       219
       +
       			t.Logf("   RootURI:      %s", indexedComment.RootURI)

     

       220
       220
       +
       			t.Logf("   ParentURI:    %s", indexedComment.ParentURI)

     

       221
       221
       +
       

     

       222
       222
       +
       			// Verify comment details

     

       223
       223
       +
       			if indexedComment.CommenterDID != userDID {

     

       224
       224
       +
       				t.Errorf("Expected commenter_did %s, got %s", userDID, indexedComment.CommenterDID)

     

       225
       225
       +
       			}

     

       226
       226
       +
       			if indexedComment.Content != "This is a TRUE E2E test comment via Jetstream!" {

     

       227
       227
       +
       				t.Errorf("Expected content mismatch, got %s", indexedComment.Content)

     

       228
       228
       +
       			}

     

       229
       229
       +
       

     

       230
       230
       +
       			close(done)

     

       231
       231
       +
       

     

       232
       232
       +
       		case err := <-errorChan:

     

       233
       233
       +
       			t.Fatalf("Jetstream error: %v", err)

     

       234
       234
       +
       

     

       235
       235
       +
       		case <-time.After(30 * time.Second):

     

       236
       236
       +
       			t.Fatalf("Timeout: No Jetstream event received within 30 seconds")

     

       237
       237
       +
       		}

     

       238
       238
       +
       

     

       239
       239
       +
       		t.Logf("\n✅ TRUE E2E COMMENT CREATE FLOW COMPLETE:")

     

       240
       240
       +
       		t.Logf("   Client → Service → PDS → Jetstream → Consumer → AppView ✓")

     

       241
       241
       +
       	})

     

       242
       242
       +
       }

     

       243
       243
       +
       

     

       244
       244
       +
       // TestCommentE2E_UpdateWithJetstream tests comment update with real Jetstream indexing

     

       245
       245
       +
       func TestCommentE2E_UpdateWithJetstream(t *testing.T) {

     

       246
       246
       +
       	if testing.Short() {

     

       247
       247
       +
       		t.Skip("Skipping E2E test in short mode")

     

       248
       248
       +
       	}

     

       249
       249
       +
       

     

       250
       250
       +
       	// Setup test database

     

       251
       251
       +
       	dbURL := os.Getenv("TEST_DATABASE_URL")

     

       252
       252
       +
       	if dbURL == "" {

     

       253
       253
       +
       		dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable"

     

       254
       254
       +
       	}

     

       255
       255
       +
       

     

       256
       256
       +
       	db, err := sql.Open("postgres", dbURL)

     

       257
       257
       +
       	if err != nil {

     

       258
       258
       +
       		t.Fatalf("Failed to connect to test database: %v", err)

     

       259
       259
       +
       	}

     

       260
       260
       +
       	defer func() { _ = db.Close() }()

     

       261
       261
       +
       

     

       262
       262
       +
       	// Run migrations

     

       263
       263
       +
       	if dialectErr := goose.SetDialect("postgres"); dialectErr != nil {

     

       264
       264
       +
       		t.Fatalf("Failed to set goose dialect: %v", dialectErr)

     

       265
       265
       +
       	}

     

       266
       266
       +
       	if migrateErr := goose.Up(db, "../../internal/db/migrations"); migrateErr != nil {

     

       267
       267
       +
       		t.Fatalf("Failed to run migrations: %v", migrateErr)

     

       268
       268
       +
       	}

     

       269
       269
       +
       

     

       270
       270
       +
       	// Check if PDS is running

     

       271
       271
       +
       	pdsURL := getTestPDSURL()

     

       272
       272
       +
       	healthResp, err := http.Get(pdsURL + "/xrpc/_health")

     

       273
       273
       +
       	if err != nil {

     

       274
       274
       +
       		t.Skipf("PDS not running at %s: %v", pdsURL, err)

     

       275
       275
       +
       	}

     

       276
       276
       +
       	_ = healthResp.Body.Close()

     

       277
       277
       +
       

     

       278
       278
       +
       	// Check if Jetstream is running

     

       279
       279
       +
       	pdsHostname := strings.TrimPrefix(pdsURL, "http://")

     

       280
       280
       +
       	pdsHostname = strings.TrimPrefix(pdsHostname, "https://")

     

       281
       281
       +
       	pdsHostname = strings.Split(pdsHostname, ":")[0]

     

       282
       282
       +
       	jetstreamURL := fmt.Sprintf("ws://%s:6008/subscribe?wantedCollections=social.coves.community.comment", pdsHostname)

     

       283
       283
       +
       

     

       284
       284
       +
       	testConn, _, err := websocket.DefaultDialer.Dial(jetstreamURL, nil)

     

       285
       285
       +
       	if err != nil {

     

       286
       286
       +
       		t.Skipf("Jetstream not running at %s: %v", jetstreamURL, err)

     

       287
       287
       +
       	}

     

       288
       288
       +
       	_ = testConn.Close()

     

       289
       289
       +
       

     

       290
       290
       +
       	ctx := context.Background()

     

       291
       291
       +
       

     

       292
       292
       +
       	// Setup repositories

     

       293
       293
       +
       	commentRepo := postgres.NewCommentRepository(db)

     

       294
       294
       +
       	postRepo := postgres.NewPostRepository(db)

     

       295
       295
       +
       

     

       296
       296
       +
       	// Create test user on PDS

     

       297
       297
       +
       	testUserHandle := fmt.Sprintf("cmtup%d.local.coves.dev", time.Now().UnixNano()%1000000)

     

       298
       298
       +
       	testUserEmail := fmt.Sprintf("cmtup%d@test.local", time.Now().UnixNano()%1000000)

     

       299
       299
       +
       	testUserPassword := "test-password-123"

     

       300
       300
       +
       

     

       301
       301
       +
       	pdsAccessToken, userDID, err := createPDSAccount(pdsURL, testUserHandle, testUserEmail, testUserPassword)

     

       302
       302
       +
       	if err != nil {

     

       303
       303
       +
       		t.Fatalf("Failed to create test user on PDS: %v", err)

     

       304
       304
       +
       	}

     

       305
       305
       +
       

     

       306
       306
       +
       	testUser := createTestUser(t, db, testUserHandle, userDID)

     

       307
       307
       +
       

     

       308
       308
       +
       	testCommunityDID, err := createFeedTestCommunity(db, ctx, "comment-upd-community", "owner.test")

     

       309
       309
       +
       	if err != nil {

     

       310
       310
       +
       		t.Fatalf("Failed to create test community: %v", err)

     

       311
       311
       +
       	}

     

       312
       312
       +
       

     

       313
       313
       +
       	postURI := createTestPost(t, db, testCommunityDID, testUser.DID, "Test Post for Update", 0, time.Now())

     

       314
       314
       +
       	postCID := "bafypostupdate"

     

       315
       315
       +
       

     

       316
       316
       +
       	commentPDSFactory := func(ctx context.Context, session *oauthlib.ClientSessionData) (pds.Client, error) {

     

       317
       317
       +
       		if session.AccessToken == "" {

     

       318
       318
       +
       			return nil, fmt.Errorf("session has no access token")

     

       319
       319
       +
       		}

     

       320
       320
       +
       		return pds.NewFromAccessToken(session.HostURL, session.AccountDID.String(), session.AccessToken)

     

       321
       321
       +
       	}

     

       322
       322
       +
       

     

       323
       323
       +
       	commentService := comments.NewCommentServiceWithPDSFactory(

     

       324
       324
       +
       		commentRepo,

     

       325
       325
       +
       		nil,

     

       326
       326
       +
       		postRepo,

     

       327
       327
       +
       		nil,

     

       328
       328
       +
       		nil,

     

       329
       329
       +
       		commentPDSFactory,

     

       330
       330
       +
       	)

     

       331
       331
       +
       

     

       332
       332
       +
       	mockStore := NewMockOAuthStore()

     

       333
       333
       +
       	mockStore.AddSessionWithPDS(userDID, "session-"+userDID, pdsAccessToken, pdsURL)

     

       334
       334
       +
       

     

       335
       335
       +
       	t.Run("update comment with real Jetstream indexing", func(t *testing.T) {

     

       336
       336
       +
       		commentConsumer := jetstream.NewCommentEventConsumer(commentRepo, db)

     

       337
       337
       +
       

     

       338
       338
       +
       		// First, create a comment and wait for it to be indexed

     

       339
       339
       +
       		eventChan := make(chan *jetstream.JetstreamEvent, 10)

     

       340
       340
       +
       		errorChan := make(chan error, 1)

     

       341
       341
       +
       		done := make(chan bool)

     

       342
       342
       +
       

     

       343
       343
       +
       		go func() {

     

       344
       344
       +
       			subscribeErr := subscribeToJetstreamForComment(ctx, jetstreamURL, userDID, commentConsumer, eventChan, done)

     

       345
       345
       +
       			if subscribeErr != nil {

     

       346
       346
       +
       				errorChan <- subscribeErr

     

       347
       347
       +
       			}

     

       348
       348
       +
       		}()

     

       349
       349
       +
       

     

       350
       350
       +
       		time.Sleep(500 * time.Millisecond)

     

       351
       351
       +
       

     

       352
       352
       +
       		// Create initial comment

     

       353
       353
       +
       		t.Logf("\n📝 Creating initial comment...")

     

       354
       354
       +
       		commentReq := comments.CreateCommentRequest{

     

       355
       355
       +
       			Reply: comments.ReplyRef{

     

       356
       356
       +
       				Root:   comments.StrongRef{URI: postURI, CID: postCID},

     

       357
       357
       +
       				Parent: comments.StrongRef{URI: postURI, CID: postCID},

     

       358
       358
       +
       			},

     

       359
       359
       +
       			Content: "Original comment content",

     

       360
       360
       +
       			Langs:   []string{"en"},

     

       361
       361
       +
       		}

     

       362
       362
       +
       

     

       363
       363
       +
       		parsedDID, parseErr := syntax.ParseDID(userDID)

     

       364
       364
       +
       		if parseErr != nil {

     

       365
       365
       +
       			t.Fatalf("Failed to parse DID: %v", parseErr)

     

       366
       366
       +
       		}

     

       367
       367
       +
       		session, sessionErr := mockStore.GetSession(ctx, parsedDID, "session-"+userDID)

     

       368
       368
       +
       		if sessionErr != nil {

     

       369
       369
       +
       			t.Fatalf("Failed to get session: %v", sessionErr)

     

       370
       370
       +
       		}

     

       371
       371
       +
       		commentResp, err := commentService.CreateComment(ctx, session, commentReq)

     

       372
       372
       +
       		if err != nil {

     

       373
       373
       +
       			t.Fatalf("Failed to create comment: %v", err)

     

       374
       374
       +
       		}

     

       375
       375
       +
       

     

       376
       376
       +
       		// Wait for create event

     

       377
       377
       +
       		select {

     

       378
       378
       +
       		case <-eventChan:

     

       379
       379
       +
       			t.Logf("✅ Create event received and indexed")

     

       380
       380
       +
       		case err := <-errorChan:

     

       381
       381
       +
       			t.Fatalf("Jetstream error: %v", err)

     

       382
       382
       +
       		case <-time.After(30 * time.Second):

     

       383
       383
       +
       			t.Fatalf("Timeout waiting for create event")

     

       384
       384
       +
       		}

     

       385
       385
       +
       		close(done)

     

       386
       386
       +
       

     

       387
       387
       +
       		// Now update the comment

     

       388
       388
       +
       		t.Logf("\n📝 Updating comment via service...")

     

       389
       389
       +
       

     

       390
       390
       +
       		// Start new Jetstream subscription for update event

     

       391
       391
       +
       		updateEventChan := make(chan *jetstream.JetstreamEvent, 10)

     

       392
       392
       +
       		updateErrorChan := make(chan error, 1)

     

       393
       393
       +
       		updateDone := make(chan bool)

     

       394
       394
       +
       

     

       395
       395
       +
       		go func() {

     

       396
       396
       +
       			subscribeErr := subscribeToJetstreamForCommentUpdate(ctx, jetstreamURL, userDID, commentConsumer, updateEventChan, updateDone)

     

       397
       397
       +
       			if subscribeErr != nil {

     

       398
       398
       +
       				updateErrorChan <- subscribeErr

     

       399
       399
       +
       			}

     

       400
       400
       +
       		}()

     

       401
       401
       +
       

     

       402
       402
       +
       		time.Sleep(500 * time.Millisecond)

     

       403
       403
       +
       

     

       404
       404
       +
       		// Get existing comment CID from PDS for optimistic locking

     

       405
       405
       +
       		rkey := utils.ExtractRKeyFromURI(commentResp.URI)

     

       406
       406
       +
       		pdsResp, httpErr := http.Get(fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=social.coves.community.comment&rkey=%s",

     

       407
       407
       +
       			pdsURL, userDID, rkey))

     

       408
       408
       +
       		if httpErr != nil {

     

       409
       409
       +
       			t.Fatalf("Failed to get record from PDS: %v", httpErr)

     

       410
       410
       +
       		}

     

       411
       411
       +
       		defer func() { _ = pdsResp.Body.Close() }()

     

       412
       412
       +
       		if pdsResp.StatusCode != http.StatusOK {

     

       413
       413
       +
       			body, _ := io.ReadAll(pdsResp.Body)

     

       414
       414
       +
       			t.Fatalf("Failed to get record from PDS: status=%d body=%s", pdsResp.StatusCode, string(body))

     

       415
       415
       +
       		}

     

       416
       416
       +
       		var pdsRecord struct {

     

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

     

       418
       418
       +
       		}

     

       419
       419
       +
       		if decodeErr := json.NewDecoder(pdsResp.Body).Decode(&pdsRecord); decodeErr != nil {

     

       420
       420
       +
       			t.Fatalf("Failed to decode PDS response: %v", decodeErr)

     

       421
       421
       +
       		}

     

       422
       422
       +
       

     

       423
       423
       +
       		updateReq := comments.UpdateCommentRequest{

     

       424
       424
       +
       			URI:     commentResp.URI,

     

       425
       425
       +
       			Content: "Updated comment content via E2E test!",

     

       426
       426
       +
       			Langs:   []string{"en"},

     

       427
       427
       +
       		}

     

       428
       428
       +
       

     

       429
       429
       +
       		updatedComment, err := commentService.UpdateComment(ctx, session, updateReq)

     

       430
       430
       +
       		if err != nil {

     

       431
       431
       +
       			t.Fatalf("Failed to update comment: %v", err)

     

       432
       432
       +
       		}

     

       433
       433
       +
       

     

       434
       434
       +
       		t.Logf("✅ Comment updated on PDS:")

     

       435
       435
       +
       		t.Logf("   URI: %s", updatedComment.URI)

     

       436
       436
       +
       		t.Logf("   CID: %s", updatedComment.CID)

     

       437
       437
       +
       

     

       438
       438
       +
       		// Wait for update event from Jetstream

     

       439
       439
       +
       		t.Logf("\n⏳ Waiting for update event from Jetstream...")

     

       440
       440
       +
       

     

       441
       441
       +
       		select {

     

       442
       442
       +
       		case event := <-updateEventChan:

     

       443
       443
       +
       			t.Logf("✅ Received update event from Jetstream!")

     

       444
       444
       +
       			t.Logf("   Operation: %s", event.Commit.Operation)

     

       445
       445
       +
       

     

       446
       446
       +
       			if event.Commit.Operation != "update" {

     

       447
       447
       +
       				t.Errorf("Expected operation 'update', got '%s'", event.Commit.Operation)

     

       448
       448
       +
       			}

     

       449
       449
       +
       

     

       450
       450
       +
       			// Verify updated content in AppView

     

       451
       451
       +
       			indexedComment, err := commentRepo.GetByURI(ctx, commentResp.URI)

     

       452
       452
       +
       			if err != nil {

     

       453
       453
       +
       				t.Fatalf("Failed to get updated comment: %v", err)

     

       454
       454
       +
       			}

     

       455
       455
       +
       

     

       456
       456
       +
       			if indexedComment.Content != "Updated comment content via E2E test!" {

     

       457
       457
       +
       				t.Errorf("Expected updated content, got: %s", indexedComment.Content)

     

       458
       458
       +
       			}

     

       459
       459
       +
       

     

       460
       460
       +
       			t.Logf("✅ Comment updated in AppView:")

     

       461
       461
       +
       			t.Logf("   Content: %s", indexedComment.Content)

     

       462
       462
       +
       

     

       463
       463
       +
       			close(updateDone)

     

       464
       464
       +
       

     

       465
       465
       +
       		case err := <-updateErrorChan:

     

       466
       466
       +
       			t.Fatalf("Jetstream error: %v", err)

     

       467
       467
       +
       

     

       468
       468
       +
       		case <-time.After(30 * time.Second):

     

       469
       469
       +
       			t.Fatalf("Timeout: No update event received within 30 seconds")

     

       470
       470
       +
       		}

     

       471
       471
       +
       

     

       472
       472
       +
       		t.Logf("\n✅ TRUE E2E COMMENT UPDATE FLOW COMPLETE:")

     

       473
       473
       +
       		t.Logf("   Client → Service → PDS PutRecord → Jetstream → Consumer → AppView ✓")

     

       474
       474
       +
       	})

     

       475
       475
       +
       }

     

       476
       476
       +
       

     

       477
       477
       +
       // TestCommentE2E_DeleteWithJetstream tests comment deletion with real Jetstream indexing

     

       478
       478
       +
       func TestCommentE2E_DeleteWithJetstream(t *testing.T) {

     

       479
       479
       +
       	if testing.Short() {

     

       480
       480
       +
       		t.Skip("Skipping E2E test in short mode")

     

       481
       481
       +
       	}

     

       482
       482
       +
       

     

       483
       483
       +
       	// Setup test database

     

       484
       484
       +
       	dbURL := os.Getenv("TEST_DATABASE_URL")

     

       485
       485
       +
       	if dbURL == "" {

     

       486
       486
       +
       		dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable"

     

       487
       487
       +
       	}

     

       488
       488
       +
       

     

       489
       489
       +
       	db, err := sql.Open("postgres", dbURL)

     

       490
       490
       +
       	if err != nil {

     

       491
       491
       +
       		t.Fatalf("Failed to connect to test database: %v", err)

     

       492
       492
       +
       	}

     

       493
       493
       +
       	defer func() { _ = db.Close() }()

     

       494
       494
       +
       

     

       495
       495
       +
       	if dialectErr := goose.SetDialect("postgres"); dialectErr != nil {

     

       496
       496
       +
       		t.Fatalf("Failed to set goose dialect: %v", dialectErr)

     

       497
       497
       +
       	}

     

       498
       498
       +
       	if migrateErr := goose.Up(db, "../../internal/db/migrations"); migrateErr != nil {

     

       499
       499
       +
       		t.Fatalf("Failed to run migrations: %v", migrateErr)

     

       500
       500
       +
       	}

     

       501
       501
       +
       

     

       502
       502
       +
       	pdsURL := getTestPDSURL()

     

       503
       503
       +
       	healthResp, err := http.Get(pdsURL + "/xrpc/_health")

     

       504
       504
       +
       	if err != nil {

     

       505
       505
       +
       		t.Skipf("PDS not running at %s: %v", pdsURL, err)

     

       506
       506
       +
       	}

     

       507
       507
       +
       	_ = healthResp.Body.Close()

     

       508
       508
       +
       

     

       509
       509
       +
       	pdsHostname := strings.TrimPrefix(pdsURL, "http://")

     

       510
       510
       +
       	pdsHostname = strings.TrimPrefix(pdsHostname, "https://")

     

       511
       511
       +
       	pdsHostname = strings.Split(pdsHostname, ":")[0]

     

       512
       512
       +
       	jetstreamURL := fmt.Sprintf("ws://%s:6008/subscribe?wantedCollections=social.coves.community.comment", pdsHostname)

     

       513
       513
       +
       

     

       514
       514
       +
       	testConn, _, err := websocket.DefaultDialer.Dial(jetstreamURL, nil)

     

       515
       515
       +
       	if err != nil {

     

       516
       516
       +
       		t.Skipf("Jetstream not running at %s: %v", jetstreamURL, err)

     

       517
       517
       +
       	}

     

       518
       518
       +
       	_ = testConn.Close()

     

       519
       519
       +
       

     

       520
       520
       +
       	ctx := context.Background()

     

       521
       521
       +
       

     

       522
       522
       +
       	commentRepo := postgres.NewCommentRepository(db)

     

       523
       523
       +
       	postRepo := postgres.NewPostRepository(db)

     

       524
       524
       +
       

     

       525
       525
       +
       	testUserHandle := fmt.Sprintf("cmtdl%d.local.coves.dev", time.Now().UnixNano()%1000000)

     

       526
       526
       +
       	testUserEmail := fmt.Sprintf("cmtdl%d@test.local", time.Now().UnixNano()%1000000)

     

       527
       527
       +
       	testUserPassword := "test-password-123"

     

       528
       528
       +
       

     

       529
       529
       +
       	pdsAccessToken, userDID, err := createPDSAccount(pdsURL, testUserHandle, testUserEmail, testUserPassword)

     

       530
       530
       +
       	if err != nil {

     

       531
       531
       +
       		t.Fatalf("Failed to create test user on PDS: %v", err)

     

       532
       532
       +
       	}

     

       533
       533
       +
       

     

       534
       534
       +
       	testUser := createTestUser(t, db, testUserHandle, userDID)

     

       535
       535
       +
       

     

       536
       536
       +
       	testCommunityDID, err := createFeedTestCommunity(db, ctx, "comment-del-community", "owner.test")

     

       537
       537
       +
       	if err != nil {

     

       538
       538
       +
       		t.Fatalf("Failed to create test community: %v", err)

     

       539
       539
       +
       	}

     

       540
       540
       +
       

     

       541
       541
       +
       	postURI := createTestPost(t, db, testCommunityDID, testUser.DID, "Test Post for Delete", 0, time.Now())

     

       542
       542
       +
       	postCID := "bafypostdelete"

     

       543
       543
       +
       

     

       544
       544
       +
       	commentPDSFactory := func(ctx context.Context, session *oauthlib.ClientSessionData) (pds.Client, error) {

     

       545
       545
       +
       		if session.AccessToken == "" {

     

       546
       546
       +
       			return nil, fmt.Errorf("session has no access token")

     

       547
       547
       +
       		}

     

       548
       548
       +
       		return pds.NewFromAccessToken(session.HostURL, session.AccountDID.String(), session.AccessToken)

     

       549
       549
       +
       	}

     

       550
       550
       +
       

     

       551
       551
       +
       	commentService := comments.NewCommentServiceWithPDSFactory(

     

       552
       552
       +
       		commentRepo,

     

       553
       553
       +
       		nil,

     

       554
       554
       +
       		postRepo,

     

       555
       555
       +
       		nil,

     

       556
       556
       +
       		nil,

     

       557
       557
       +
       		commentPDSFactory,

     

       558
       558
       +
       	)

     

       559
       559
       +
       

     

       560
       560
       +
       	mockStore := NewMockOAuthStore()

     

       561
       561
       +
       	mockStore.AddSessionWithPDS(userDID, "session-"+userDID, pdsAccessToken, pdsURL)

     

       562
       562
       +
       

     

       563
       563
       +
       	t.Run("delete comment with real Jetstream indexing", func(t *testing.T) {

     

       564
       564
       +
       		commentConsumer := jetstream.NewCommentEventConsumer(commentRepo, db)

     

       565
       565
       +
       

     

       566
       566
       +
       		// First, create a comment

     

       567
       567
       +
       		eventChan := make(chan *jetstream.JetstreamEvent, 10)

     

       568
       568
       +
       		errorChan := make(chan error, 1)

     

       569
       569
       +
       		done := make(chan bool)

     

       570
       570
       +
       

     

       571
       571
       +
       		go func() {

     

       572
       572
       +
       			subscribeErr := subscribeToJetstreamForComment(ctx, jetstreamURL, userDID, commentConsumer, eventChan, done)

     

       573
       573
       +
       			if subscribeErr != nil {

     

       574
       574
       +
       				errorChan <- subscribeErr

     

       575
       575
       +
       			}

     

       576
       576
       +
       		}()

     

       577
       577
       +
       

     

       578
       578
       +
       		time.Sleep(500 * time.Millisecond)

     

       579
       579
       +
       

     

       580
       580
       +
       		t.Logf("\n📝 Creating comment to delete...")

     

       581
       581
       +
       		commentReq := comments.CreateCommentRequest{

     

       582
       582
       +
       			Reply: comments.ReplyRef{

     

       583
       583
       +
       				Root:   comments.StrongRef{URI: postURI, CID: postCID},

     

       584
       584
       +
       				Parent: comments.StrongRef{URI: postURI, CID: postCID},

     

       585
       585
       +
       			},

     

       586
       586
       +
       			Content: "This comment will be deleted",

     

       587
       587
       +
       			Langs:   []string{"en"},

     

       588
       588
       +
       		}

     

       589
       589
       +
       

     

       590
       590
       +
       		parsedDID, parseErr := syntax.ParseDID(userDID)

     

       591
       591
       +
       		if parseErr != nil {

     

       592
       592
       +
       			t.Fatalf("Failed to parse DID: %v", parseErr)

     

       593
       593
       +
       		}

     

       594
       594
       +
       		session, sessionErr := mockStore.GetSession(ctx, parsedDID, "session-"+userDID)

     

       595
       595
       +
       		if sessionErr != nil {

     

       596
       596
       +
       			t.Fatalf("Failed to get session: %v", sessionErr)

     

       597
       597
       +
       		}

     

       598
       598
       +
       		commentResp, err := commentService.CreateComment(ctx, session, commentReq)

     

       599
       599
       +
       		if err != nil {

     

       600
       600
       +
       			t.Fatalf("Failed to create comment: %v", err)

     

       601
       601
       +
       		}

     

       602
       602
       +
       

     

       603
       603
       +
       		// Wait for create event

     

       604
       604
       +
       		select {

     

       605
       605
       +
       		case <-eventChan:

     

       606
       606
       +
       			t.Logf("✅ Create event received")

     

       607
       607
       +
       		case err := <-errorChan:

     

       608
       608
       +
       			t.Fatalf("Jetstream error: %v", err)

     

       609
       609
       +
       		case <-time.After(30 * time.Second):

     

       610
       610
       +
       			t.Fatalf("Timeout waiting for create event")

     

       611
       611
       +
       		}

     

       612
       612
       +
       		close(done)

     

       613
       613
       +
       

     

       614
       614
       +
       		// Verify comment exists

     

       615
       615
       +
       		_, err = commentRepo.GetByURI(ctx, commentResp.URI)

     

       616
       616
       +
       		if err != nil {

     

       617
       617
       +
       			t.Fatalf("Comment should exist before delete: %v", err)

     

       618
       618
       +
       		}

     

       619
       619
       +
       

     

       620
       620
       +
       		// Now delete the comment

     

       621
       621
       +
       		t.Logf("\n🗑️ Deleting comment via service...")

     

       622
       622
       +
       

     

       623
       623
       +
       		deleteEventChan := make(chan *jetstream.JetstreamEvent, 10)

     

       624
       624
       +
       		deleteErrorChan := make(chan error, 1)

     

       625
       625
       +
       		deleteDone := make(chan bool)

     

       626
       626
       +
       

     

       627
       627
       +
       		go func() {

     

       628
       628
       +
       			subscribeErr := subscribeToJetstreamForCommentDelete(ctx, jetstreamURL, userDID, commentConsumer, deleteEventChan, deleteDone)

     

       629
       629
       +
       			if subscribeErr != nil {

     

       630
       630
       +
       				deleteErrorChan <- subscribeErr

     

       631
       631
       +
       			}

     

       632
       632
       +
       		}()

     

       633
       633
       +
       

     

       634
       634
       +
       		time.Sleep(500 * time.Millisecond)

     

       635
       635
       +
       

     

       636
       636
       +
       		err = commentService.DeleteComment(ctx, session, comments.DeleteCommentRequest{URI: commentResp.URI})

     

       637
       637
       +
       		if err != nil {

     

       638
       638
       +
       			t.Fatalf("Failed to delete comment: %v", err)

     

       639
       639
       +
       		}

     

       640
       640
       +
       

     

       641
       641
       +
       		t.Logf("✅ Comment delete request sent to PDS")

     

       642
       642
       +
       

     

       643
       643
       +
       		// Wait for delete event from Jetstream

     

       644
       644
       +
       		t.Logf("\n⏳ Waiting for delete event from Jetstream...")

     

       645
       645
       +
       

     

       646
       646
       +
       		select {

     

       647
       647
       +
       		case event := <-deleteEventChan:

     

       648
       648
       +
       			t.Logf("✅ Received delete event from Jetstream!")

     

       649
       649
       +
       			t.Logf("   Operation: %s", event.Commit.Operation)

     

       650
       650
       +
       

     

       651
       651
       +
       			if event.Commit.Operation != "delete" {

     

       652
       652
       +
       				t.Errorf("Expected operation 'delete', got '%s'", event.Commit.Operation)

     

       653
       653
       +
       			}

     

       654
       654
       +
       

     

       655
       655
       +
       			// Verify comment is soft-deleted in AppView

     

       656
       656
       +
       			deletedComment, err := commentRepo.GetByURI(ctx, commentResp.URI)

     

       657
       657
       +
       			if err != nil {

     

       658
       658
       +
       				t.Fatalf("Failed to get deleted comment: %v", err)

     

       659
       659
       +
       			}

     

       660
       660
       +
       

     

       661
       661
       +
       			if deletedComment.DeletedAt == nil {

     

       662
       662
       +
       				t.Errorf("Expected comment to be soft-deleted (deleted_at should be set)")

     

       663
       663
       +
       			} else {

     

       664
       664
       +
       				t.Logf("✅ Comment soft-deleted in AppView at: %v", *deletedComment.DeletedAt)

     

       665
       665
       +
       			}

     

       666
       666
       +
       

     

       667
       667
       +
       			close(deleteDone)

     

       668
       668
       +
       

     

       669
       669
       +
       		case err := <-deleteErrorChan:

     

       670
       670
       +
       			t.Fatalf("Jetstream error: %v", err)

     

       671
       671
       +
       

     

       672
       672
       +
       		case <-time.After(30 * time.Second):

     

       673
       673
       +
       			t.Fatalf("Timeout: No delete event received within 30 seconds")

     

       674
       674
       +
       		}

     

       675
       675
       +
       

     

       676
       676
       +
       		t.Logf("\n✅ TRUE E2E COMMENT DELETE FLOW COMPLETE:")

     

       677
       677
       +
       		t.Logf("   Client → Service → PDS DeleteRecord → Jetstream → Consumer → AppView ✓")

     

       678
       678
       +
       	})

     

       679
       679
       +
       }

     

       680
       680
       +
       

     

       681
       681
       +
       // subscribeToJetstreamForComment subscribes to real Jetstream firehose for comment create events

     

       682
       682
       +
       func subscribeToJetstreamForComment(

     

       683
       683
       +
       	ctx context.Context,

     

       684
       684
       +
       	jetstreamURL string,

     

       685
       685
       +
       	targetDID string,

     

       686
       686
       +
       	consumer *jetstream.CommentEventConsumer,

     

       687
       687
       +
       	eventChan chan<- *jetstream.JetstreamEvent,

     

       688
       688
       +
       	done <-chan bool,

     

       689
       689
       +
       ) error {

     

       690
       690
       +
       	conn, _, err := websocket.DefaultDialer.Dial(jetstreamURL, nil)

     

       691
       691
       +
       	if err != nil {

     

       692
       692
       +
       		return fmt.Errorf("failed to connect to Jetstream: %w", err)

     

       693
       693
       +
       	}

     

       694
       694
       +
       	defer func() { _ = conn.Close() }()

     

       695
       695
       +
       

     

       696
       696
       +
       	for {

     

       697
       697
       +
       		select {

     

       698
       698
       +
       		case <-done:

     

       699
       699
       +
       			return nil

     

       700
       700
       +
       		case <-ctx.Done():

     

       701
       701
       +
       			return ctx.Err()

     

       702
       702
       +
       		default:

     

       703
       703
       +
       			if err := conn.SetReadDeadline(time.Now().Add(5 * time.Second)); err != nil {

     

       704
       704
       +
       				return fmt.Errorf("failed to set read deadline: %w", err)

     

       705
       705
       +
       			}

     

       706
       706
       +
       

     

       707
       707
       +
       			var event jetstream.JetstreamEvent

     

       708
       708
       +
       			err := conn.ReadJSON(&event)

     

       709
       709
       +
       			if err != nil {

     

       710
       710
       +
       				if websocket.IsCloseError(err, websocket.CloseNormalClosure) {

     

       711
       711
       +
       					return nil

     

       712
       712
       +
       				}

     

       713
       713
       +
       				if netErr, ok := err.(net.Error); ok && netErr.Timeout() {

     

       714
       714
       +
       					continue

     

       715
       715
       +
       				}

     

       716
       716
       +
       				return fmt.Errorf("failed to read Jetstream message: %w", err)

     

       717
       717
       +
       			}

     

       718
       718
       +
       

     

       719
       719
       +
       			// Check if this is a comment create event for the target DID

     

       720
       720
       +
       			if event.Did == targetDID && event.Kind == "commit" &&

     

       721
       721
       +
       				event.Commit != nil && event.Commit.Collection == "social.coves.community.comment" &&

     

       722
       722
       +
       				event.Commit.Operation == "create" {

     

       723
       723
       +
       

     

       724
       724
       +
       				if err := consumer.HandleEvent(ctx, &event); err != nil {

     

       725
       725
       +
       					return fmt.Errorf("failed to process event: %w", err)

     

       726
       726
       +
       				}

     

       727
       727
       +
       

     

       728
       728
       +
       				select {

     

       729
       729
       +
       				case eventChan <- &event:

     

       730
       730
       +
       					return nil

     

       731
       731
       +
       				case <-time.After(1 * time.Second):

     

       732
       732
       +
       					return fmt.Errorf("timeout sending event to channel")

     

       733
       733
       +
       				}

     

       734
       734
       +
       			}

     

       735
       735
       +
       		}

     

       736
       736
       +
       	}

     

       737
       737
       +
       }

     

       738
       738
       +
       

     

       739
       739
       +
       // subscribeToJetstreamForCommentUpdate subscribes for comment update events

     

       740
       740
       +
       func subscribeToJetstreamForCommentUpdate(

     

       741
       741
       +
       	ctx context.Context,

     

       742
       742
       +
       	jetstreamURL string,

     

       743
       743
       +
       	targetDID string,

     

       744
       744
       +
       	consumer *jetstream.CommentEventConsumer,

     

       745
       745
       +
       	eventChan chan<- *jetstream.JetstreamEvent,

     

       746
       746
       +
       	done <-chan bool,

     

       747
       747
       +
       ) error {

     

       748
       748
       +
       	conn, _, err := websocket.DefaultDialer.Dial(jetstreamURL, nil)

     

       749
       749
       +
       	if err != nil {

     

       750
       750
       +
       		return fmt.Errorf("failed to connect to Jetstream: %w", err)

     

       751
       751
       +
       	}

     

       752
       752
       +
       	defer func() { _ = conn.Close() }()

     

       753
       753
       +
       

     

       754
       754
       +
       	for {

     

       755
       755
       +
       		select {

     

       756
       756
       +
       		case <-done:

     

       757
       757
       +
       			return nil

     

       758
       758
       +
       		case <-ctx.Done():

     

       759
       759
       +
       			return ctx.Err()

     

       760
       760
       +
       		default:

     

       761
       761
       +
       			if err := conn.SetReadDeadline(time.Now().Add(5 * time.Second)); err != nil {

     

       762
       762
       +
       				return fmt.Errorf("failed to set read deadline: %w", err)

     

       763
       763
       +
       			}

     

       764
       764
       +
       

     

       765
       765
       +
       			var event jetstream.JetstreamEvent

     

       766
       766
       +
       			err := conn.ReadJSON(&event)

     

       767
       767
       +
       			if err != nil {

     

       768
       768
       +
       				if websocket.IsCloseError(err, websocket.CloseNormalClosure) {

     

       769
       769
       +
       					return nil

     

       770
       770
       +
       				}

     

       771
       771
       +
       				if netErr, ok := err.(net.Error); ok && netErr.Timeout() {

     

       772
       772
       +
       					continue

     

       773
       773
       +
       				}

     

       774
       774
       +
       				return fmt.Errorf("failed to read Jetstream message: %w", err)

     

       775
       775
       +
       			}

     

       776
       776
       +
       

     

       777
       777
       +
       			if event.Did == targetDID && event.Kind == "commit" &&

     

       778
       778
       +
       				event.Commit != nil && event.Commit.Collection == "social.coves.community.comment" &&

     

       779
       779
       +
       				event.Commit.Operation == "update" {

     

       780
       780
       +
       

     

       781
       781
       +
       				if err := consumer.HandleEvent(ctx, &event); err != nil {

     

       782
       782
       +
       					return fmt.Errorf("failed to process event: %w", err)

     

       783
       783
       +
       				}

     

       784
       784
       +
       

     

       785
       785
       +
       				select {

     

       786
       786
       +
       				case eventChan <- &event:

     

       787
       787
       +
       					return nil

     

       788
       788
       +
       				case <-time.After(1 * time.Second):

     

       789
       789
       +
       					return fmt.Errorf("timeout sending event to channel")

     

       790
       790
       +
       				}

     

       791
       791
       +
       			}

     

       792
       792
       +
       		}

     

       793
       793
       +
       	}

     

       794
       794
       +
       }

     

       795
       795
       +
       

     

       796
       796
       +
       // subscribeToJetstreamForCommentDelete subscribes for comment delete events

     

       797
       797
       +
       func subscribeToJetstreamForCommentDelete(

     

       798
       798
       +
       	ctx context.Context,

     

       799
       799
       +
       	jetstreamURL string,

     

       800
       800
       +
       	targetDID string,

     

       801
       801
       +
       	consumer *jetstream.CommentEventConsumer,

     

       802
       802
       +
       	eventChan chan<- *jetstream.JetstreamEvent,

     

       803
       803
       +
       	done <-chan bool,

     

       804
       804
       +
       ) error {

     

       805
       805
       +
       	conn, _, err := websocket.DefaultDialer.Dial(jetstreamURL, nil)

     

       806
       806
       +
       	if err != nil {

     

       807
       807
       +
       		return fmt.Errorf("failed to connect to Jetstream: %w", err)

     

       808
       808
       +
       	}

     

       809
       809
       +
       	defer func() { _ = conn.Close() }()

     

       810
       810
       +
       

     

       811
       811
       +
       	for {

     

       812
       812
       +
       		select {

     

       813
       813
       +
       		case <-done:

     

       814
       814
       +
       			return nil

     

       815
       815
       +
       		case <-ctx.Done():

     

       816
       816
       +
       			return ctx.Err()

     

       817
       817
       +
       		default:

     

       818
       818
       +
       			if err := conn.SetReadDeadline(time.Now().Add(5 * time.Second)); err != nil {

     

       819
       819
       +
       				return fmt.Errorf("failed to set read deadline: %w", err)

     

       820
       820
       +
       			}

     

       821
       821
       +
       

     

       822
       822
       +
       			var event jetstream.JetstreamEvent

     

       823
       823
       +
       			err := conn.ReadJSON(&event)

     

       824
       824
       +
       			if err != nil {

     

       825
       825
       +
       				if websocket.IsCloseError(err, websocket.CloseNormalClosure) {

     

       826
       826
       +
       					return nil

     

       827
       827
       +
       				}

     

       828
       828
       +
       				if netErr, ok := err.(net.Error); ok && netErr.Timeout() {

     

       829
       829
       +
       					continue

     

       830
       830
       +
       				}

     

       831
       831
       +
       				return fmt.Errorf("failed to read Jetstream message: %w", err)

     

       832
       832
       +
       			}

     

       833
       833
       +
       

     

       834
       834
       +
       			if event.Did == targetDID && event.Kind == "commit" &&

     

       835
       835
       +
       				event.Commit != nil && event.Commit.Collection == "social.coves.community.comment" &&

     

       836
       836
       +
       				event.Commit.Operation == "delete" {

     

       837
       837
       +
       

     

       838
       838
       +
       				if err := consumer.HandleEvent(ctx, &event); err != nil {

     

       839
       839
       +
       					return fmt.Errorf("failed to process event: %w", err)

     

       840
       840
       +
       				}

     

       841
       841
       +
       

     

       842
       842
       +
       				select {

     

       843
       843
       +
       				case eventChan <- &event:

     

       844
       844
       +
       					return nil

     

       845
       845
       +
       				case <-time.After(1 * time.Second):

     

       846
       846
       +
       					return fmt.Errorf("timeout sending event to channel")

     

       847
       847
       +
       				}

     

       848
       848
       +
       			}

     

       849
       849
       +
       		}

     

       850
       850
       +
       	}

     

       851
       851
       +
       }

     

       852
       852
       +
       

     

       853
       853
       +
       // TestCommentE2E_Authorization tests that users cannot modify other users' comments

     

       854
       854
       +
       func TestCommentE2E_Authorization(t *testing.T) {

     

       855
       855
       +
       	if testing.Short() {

     

       856
       856
       +
       		t.Skip("Skipping E2E test in short mode")

     

       857
       857
       +
       	}

     

       858
       858
       +
       

     

       859
       859
       +
       	// Setup test database

     

       860
       860
       +
       	dbURL := os.Getenv("TEST_DATABASE_URL")

     

       861
       861
       +
       	if dbURL == "" {

     

       862
       862
       +
       		dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable"

     

       863
       863
       +
       	}

     

       864
       864
       +
       

     

       865
       865
       +
       	db, err := sql.Open("postgres", dbURL)

     

       866
       866
       +
       	if err != nil {

     

       867
       867
       +
       		t.Fatalf("Failed to connect to test database: %v", err)

     

       868
       868
       +
       	}

     

       869
       869
       +
       	defer func() { _ = db.Close() }()

     

       870
       870
       +
       

     

       871
       871
       +
       	if dialectErr := goose.SetDialect("postgres"); dialectErr != nil {

     

       872
       872
       +
       		t.Fatalf("Failed to set goose dialect: %v", dialectErr)

     

       873
       873
       +
       	}

     

       874
       874
       +
       	if migrateErr := goose.Up(db, "../../internal/db/migrations"); migrateErr != nil {

     

       875
       875
       +
       		t.Fatalf("Failed to run migrations: %v", migrateErr)

     

       876
       876
       +
       	}

     

       877
       877
       +
       

     

       878
       878
       +
       	pdsURL := getTestPDSURL()

     

       879
       879
       +
       	healthResp, err := http.Get(pdsURL + "/xrpc/_health")

     

       880
       880
       +
       	if err != nil {

     

       881
       881
       +
       		t.Skipf("PDS not running at %s: %v", pdsURL, err)

     

       882
       882
       +
       	}

     

       883
       883
       +
       	_ = healthResp.Body.Close()

     

       884
       884
       +
       

     

       885
       885
       +
       	ctx := context.Background()

     

       886
       886
       +
       

     

       887
       887
       +
       	commentRepo := postgres.NewCommentRepository(db)

     

       888
       888
       +
       	postRepo := postgres.NewPostRepository(db)

     

       889
       889
       +
       

     

       890
       890
       +
       	// Create two test users on PDS

     

       891
       891
       +
       	userAHandle := fmt.Sprintf("usera%d.local.coves.dev", time.Now().UnixNano()%1000000)

     

       892
       892
       +
       	userAEmail := fmt.Sprintf("usera%d@test.local", time.Now().UnixNano()%1000000)

     

       893
       893
       +
       	userAPassword := "test-password-123"

     

       894
       894
       +
       

     

       895
       895
       +
       	userBHandle := fmt.Sprintf("userb%d.local.coves.dev", time.Now().UnixNano()%1000000)

     

       896
       896
       +
       	userBEmail := fmt.Sprintf("userb%d@test.local", time.Now().UnixNano()%1000000)

     

       897
       897
       +
       	userBPassword := "test-password-123"

     

       898
       898
       +
       

     

       899
       899
       +
       	pdsAccessTokenA, userADID, err := createPDSAccount(pdsURL, userAHandle, userAEmail, userAPassword)

     

       900
       900
       +
       	if err != nil {

     

       901
       901
       +
       		t.Fatalf("Failed to create test user A on PDS: %v", err)

     

       902
       902
       +
       	}

     

       903
       903
       +
       

     

       904
       904
       +
       	pdsAccessTokenB, userBDID, err := createPDSAccount(pdsURL, userBHandle, userBEmail, userBPassword)

     

       905
       905
       +
       	if err != nil {

     

       906
       906
       +
       		t.Fatalf("Failed to create test user B on PDS: %v", err)

     

       907
       907
       +
       	}

     

       908
       908
       +
       

     

       909
       909
       +
       	testUserA := createTestUser(t, db, userAHandle, userADID)

     

       910
       910
       +
       	_ = createTestUser(t, db, userBHandle, userBDID)

     

       911
       911
       +
       

     

       912
       912
       +
       	testCommunityDID, err := createFeedTestCommunity(db, ctx, "auth-test-community", "owner.test")

     

       913
       913
       +
       	if err != nil {

     

       914
       914
       +
       		t.Fatalf("Failed to create test community: %v", err)

     

       915
       915
       +
       	}

     

       916
       916
       +
       

     

       917
       917
       +
       	postURI := createTestPost(t, db, testCommunityDID, testUserA.DID, "Auth Test Post", 0, time.Now())

     

       918
       918
       +
       	postCID := "bafypostauthtest"

     

       919
       919
       +
       

     

       920
       920
       +
       	commentPDSFactory := func(ctx context.Context, session *oauthlib.ClientSessionData) (pds.Client, error) {

     

       921
       921
       +
       		if session.AccessToken == "" {

     

       922
       922
       +
       			return nil, fmt.Errorf("session has no access token")

     

       923
       923
       +
       		}

     

       924
       924
       +
       		return pds.NewFromAccessToken(session.HostURL, session.AccountDID.String(), session.AccessToken)

     

       925
       925
       +
       	}

     

       926
       926
       +
       

     

       927
       927
       +
       	commentService := comments.NewCommentServiceWithPDSFactory(

     

       928
       928
       +
       		commentRepo,

     

       929
       929
       +
       		nil,

     

       930
       930
       +
       		postRepo,

     

       931
       931
       +
       		nil,

     

       932
       932
       +
       		nil,

     

       933
       933
       +
       		commentPDSFactory,

     

       934
       934
       +
       	)

     

       935
       935
       +
       

     

       936
       936
       +
       	mockStore := NewMockOAuthStore()

     

       937
       937
       +
       	mockStore.AddSessionWithPDS(userADID, "session-"+userADID, pdsAccessTokenA, pdsURL)

     

       938
       938
       +
       	mockStore.AddSessionWithPDS(userBDID, "session-"+userBDID, pdsAccessTokenB, pdsURL)

     

       939
       939
       +
       

     

       940
       940
       +
       	t.Run("user cannot update another user's comment", func(t *testing.T) {

     

       941
       941
       +
       		// User A creates a comment

     

       942
       942
       +
       		parsedDIDA, parseErr := syntax.ParseDID(userADID)

     

       943
       943
       +
       		if parseErr != nil {

     

       944
       944
       +
       			t.Fatalf("Failed to parse DID A: %v", parseErr)

     

       945
       945
       +
       		}

     

       946
       946
       +
       		sessionA, sessionErr := mockStore.GetSession(ctx, parsedDIDA, "session-"+userADID)

     

       947
       947
       +
       		if sessionErr != nil {

     

       948
       948
       +
       			t.Fatalf("Failed to get session A: %v", sessionErr)

     

       949
       949
       +
       		}

     

       950
       950
       +
       

     

       951
       951
       +
       		commentReq := comments.CreateCommentRequest{

     

       952
       952
       +
       			Reply: comments.ReplyRef{

     

       953
       953
       +
       				Root:   comments.StrongRef{URI: postURI, CID: postCID},

     

       954
       954
       +
       				Parent: comments.StrongRef{URI: postURI, CID: postCID},

     

       955
       955
       +
       			},

     

       956
       956
       +
       			Content: "User A's comment",

     

       957
       957
       +
       			Langs:   []string{"en"},

     

       958
       958
       +
       		}

     

       959
       959
       +
       

     

       960
       960
       +
       		commentResp, err := commentService.CreateComment(ctx, sessionA, commentReq)

     

       961
       961
       +
       		if err != nil {

     

       962
       962
       +
       			t.Fatalf("User A failed to create comment: %v", err)

     

       963
       963
       +
       		}

     

       964
       964
       +
       		t.Logf("User A created comment: %s", commentResp.URI)

     

       965
       965
       +
       

     

       966
       966
       +
       		// User B tries to update User A's comment

     

       967
       967
       +
       		parsedDIDB, parseErr := syntax.ParseDID(userBDID)

     

       968
       968
       +
       		if parseErr != nil {

     

       969
       969
       +
       			t.Fatalf("Failed to parse DID B: %v", parseErr)

     

       970
       970
       +
       		}

     

       971
       971
       +
       		sessionB, sessionErr := mockStore.GetSession(ctx, parsedDIDB, "session-"+userBDID)

     

       972
       972
       +
       		if sessionErr != nil {

     

       973
       973
       +
       			t.Fatalf("Failed to get session B: %v", sessionErr)

     

       974
       974
       +
       		}

     

       975
       975
       +
       

     

       976
       976
       +
       		updateReq := comments.UpdateCommentRequest{

     

       977
       977
       +
       			URI:     commentResp.URI,

     

       978
       978
       +
       			Content: "User B trying to update User A's comment",

     

       979
       979
       +
       			Langs:   []string{"en"},

     

       980
       980
       +
       		}

     

       981
       981
       +
       

     

       982
       982
       +
       		_, err = commentService.UpdateComment(ctx, sessionB, updateReq)

     

       983
       983
       +
       		if err == nil {

     

       984
       984
       +
       			t.Errorf("Expected error when User B tries to update User A's comment, got nil")

     

       985
       985
       +
       		} else if err != comments.ErrNotAuthorized {

     

       986
       986
       +
       			t.Errorf("Expected ErrNotAuthorized, got: %v", err)

     

       987
       987
       +
       		} else {

     

       988
       988
       +
       			t.Logf("✅ Correctly rejected: User B cannot update User A's comment")

     

       989
       989
       +
       		}

     

       990
       990
       +
       	})

     

       991
       991
       +
       

     

       992
       992
       +
       	t.Run("user cannot delete another user's comment", func(t *testing.T) {

     

       993
       993
       +
       		// User A creates a comment

     

       994
       994
       +
       		parsedDIDA, parseErr := syntax.ParseDID(userADID)

     

       995
       995
       +
       		if parseErr != nil {

     

       996
       996
       +
       			t.Fatalf("Failed to parse DID A: %v", parseErr)

     

       997
       997
       +
       		}

     

       998
       998
       +
       		sessionA, sessionErr := mockStore.GetSession(ctx, parsedDIDA, "session-"+userADID)

     

       999
       999
       +
       		if sessionErr != nil {

     

       1000
       1000
       +
       			t.Fatalf("Failed to get session A: %v", sessionErr)

     

       1001
       1001
       +
       		}

     

       1002
       1002
       +
       

     

       1003
       1003
       +
       		commentReq := comments.CreateCommentRequest{

     

       1004
       1004
       +
       			Reply: comments.ReplyRef{

     

       1005
       1005
       +
       				Root:   comments.StrongRef{URI: postURI, CID: postCID},

     

       1006
       1006
       +
       				Parent: comments.StrongRef{URI: postURI, CID: postCID},

     

       1007
       1007
       +
       			},

     

       1008
       1008
       +
       			Content: "User A's comment for delete test",

     

       1009
       1009
       +
       			Langs:   []string{"en"},

     

       1010
       1010
       +
       		}

     

       1011
       1011
       +
       

     

       1012
       1012
       +
       		commentResp, err := commentService.CreateComment(ctx, sessionA, commentReq)

     

       1013
       1013
       +
       		if err != nil {

     

       1014
       1014
       +
       			t.Fatalf("User A failed to create comment: %v", err)

     

       1015
       1015
       +
       		}

     

       1016
       1016
       +
       		t.Logf("User A created comment: %s", commentResp.URI)

     

       1017
       1017
       +
       

     

       1018
       1018
       +
       		// User B tries to delete User A's comment

     

       1019
       1019
       +
       		parsedDIDB, parseErr := syntax.ParseDID(userBDID)

     

       1020
       1020
       +
       		if parseErr != nil {

     

       1021
       1021
       +
       			t.Fatalf("Failed to parse DID B: %v", parseErr)

     

       1022
       1022
       +
       		}

     

       1023
       1023
       +
       		sessionB, sessionErr := mockStore.GetSession(ctx, parsedDIDB, "session-"+userBDID)

     

       1024
       1024
       +
       		if sessionErr != nil {

     

       1025
       1025
       +
       			t.Fatalf("Failed to get session B: %v", sessionErr)

     

       1026
       1026
       +
       		}

     

       1027
       1027
       +
       

     

       1028
       1028
       +
       		deleteReq := comments.DeleteCommentRequest{

     

       1029
       1029
       +
       			URI: commentResp.URI,

     

       1030
       1030
       +
       		}

     

       1031
       1031
       +
       

     

       1032
       1032
       +
       		err = commentService.DeleteComment(ctx, sessionB, deleteReq)

     

       1033
       1033
       +
       		if err == nil {

     

       1034
       1034
       +
       			t.Errorf("Expected error when User B tries to delete User A's comment, got nil")

     

       1035
       1035
       +
       		} else if err != comments.ErrNotAuthorized {

     

       1036
       1036
       +
       			t.Errorf("Expected ErrNotAuthorized, got: %v", err)

     

       1037
       1037
       +
       		} else {

     

       1038
       1038
       +
       			t.Logf("✅ Correctly rejected: User B cannot delete User A's comment")

     

       1039
       1039
       +
       		}

     

       1040
       1040
       +
       	})

     

       1041
       1041
       +
       }

     

       1042
       1042
       +
       

     

       1043
       1043
       +
       // TestCommentE2E_ValidationErrors tests that validation errors are properly returned

     

       1044
       1044
       +
       func TestCommentE2E_ValidationErrors(t *testing.T) {

     

       1045
       1045
       +
       	if testing.Short() {

     

       1046
       1046
       +
       		t.Skip("Skipping E2E test in short mode")

     

       1047
       1047
       +
       	}

     

       1048
       1048
       +
       

     

       1049
       1049
       +
       	// Setup test database

     

       1050
       1050
       +
       	dbURL := os.Getenv("TEST_DATABASE_URL")

     

       1051
       1051
       +
       	if dbURL == "" {

     

       1052
       1052
       +
       		dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable"

     

       1053
       1053
       +
       	}

     

       1054
       1054
       +
       

     

       1055
       1055
       +
       	db, err := sql.Open("postgres", dbURL)

     

       1056
       1056
       +
       	if err != nil {

     

       1057
       1057
       +
       		t.Fatalf("Failed to connect to test database: %v", err)

     

       1058
       1058
       +
       	}

     

       1059
       1059
       +
       	defer func() { _ = db.Close() }()

     

       1060
       1060
       +
       

     

       1061
       1061
       +
       	if dialectErr := goose.SetDialect("postgres"); dialectErr != nil {

     

       1062
       1062
       +
       		t.Fatalf("Failed to set goose dialect: %v", dialectErr)

     

       1063
       1063
       +
       	}

     

       1064
       1064
       +
       	if migrateErr := goose.Up(db, "../../internal/db/migrations"); migrateErr != nil {

     

       1065
       1065
       +
       		t.Fatalf("Failed to run migrations: %v", migrateErr)

     

       1066
       1066
       +
       	}

     

       1067
       1067
       +
       

     

       1068
       1068
       +
       	pdsURL := getTestPDSURL()

     

       1069
       1069
       +
       	healthResp, err := http.Get(pdsURL + "/xrpc/_health")

     

       1070
       1070
       +
       	if err != nil {

     

       1071
       1071
       +
       		t.Skipf("PDS not running at %s: %v", pdsURL, err)

     

       1072
       1072
       +
       	}

     

       1073
       1073
       +
       	_ = healthResp.Body.Close()

     

       1074
       1074
       +
       

     

       1075
       1075
       +
       	ctx := context.Background()

     

       1076
       1076
       +
       

     

       1077
       1077
       +
       	commentRepo := postgres.NewCommentRepository(db)

     

       1078
       1078
       +
       	postRepo := postgres.NewPostRepository(db)

     

       1079
       1079
       +
       

     

       1080
       1080
       +
       	// Create test user on PDS

     

       1081
       1081
       +
       	testUserHandle := fmt.Sprintf("valtest%d.local.coves.dev", time.Now().UnixNano()%1000000)

     

       1082
       1082
       +
       	testUserEmail := fmt.Sprintf("valtest%d@test.local", time.Now().UnixNano()%1000000)

     

       1083
       1083
       +
       	testUserPassword := "test-password-123"

     

       1084
       1084
       +
       

     

       1085
       1085
       +
       	pdsAccessToken, userDID, err := createPDSAccount(pdsURL, testUserHandle, testUserEmail, testUserPassword)

     

       1086
       1086
       +
       	if err != nil {

     

       1087
       1087
       +
       		t.Fatalf("Failed to create test user on PDS: %v", err)

     

       1088
       1088
       +
       	}

     

       1089
       1089
       +
       

     

       1090
       1090
       +
       	testUser := createTestUser(t, db, testUserHandle, userDID)

     

       1091
       1091
       +
       

     

       1092
       1092
       +
       	testCommunityDID, err := createFeedTestCommunity(db, ctx, "val-test-community", "owner.test")

     

       1093
       1093
       +
       	if err != nil {

     

       1094
       1094
       +
       		t.Fatalf("Failed to create test community: %v", err)

     

       1095
       1095
       +
       	}

     

       1096
       1096
       +
       

     

       1097
       1097
       +
       	postURI := createTestPost(t, db, testCommunityDID, testUser.DID, "Validation Test Post", 0, time.Now())

     

       1098
       1098
       +
       	postCID := "bafypostvaltest"

     

       1099
       1099
       +
       

     

       1100
       1100
       +
       	commentPDSFactory := func(ctx context.Context, session *oauthlib.ClientSessionData) (pds.Client, error) {

     

       1101
       1101
       +
       		if session.AccessToken == "" {

     

       1102
       1102
       +
       			return nil, fmt.Errorf("session has no access token")

     

       1103
       1103
       +
       		}

     

       1104
       1104
       +
       		return pds.NewFromAccessToken(session.HostURL, session.AccountDID.String(), session.AccessToken)

     

       1105
       1105
       +
       	}

     

       1106
       1106
       +
       

     

       1107
       1107
       +
       	commentService := comments.NewCommentServiceWithPDSFactory(

     

       1108
       1108
       +
       		commentRepo,

     

       1109
       1109
       +
       		nil,

     

       1110
       1110
       +
       		postRepo,

     

       1111
       1111
       +
       		nil,

     

       1112
       1112
       +
       		nil,

     

       1113
       1113
       +
       		commentPDSFactory,

     

       1114
       1114
       +
       	)

     

       1115
       1115
       +
       

     

       1116
       1116
       +
       	mockStore := NewMockOAuthStore()

     

       1117
       1117
       +
       	mockStore.AddSessionWithPDS(userDID, "session-"+userDID, pdsAccessToken, pdsURL)

     

       1118
       1118
       +
       

     

       1119
       1119
       +
       	parsedDID, parseErr := syntax.ParseDID(userDID)

     

       1120
       1120
       +
       	if parseErr != nil {

     

       1121
       1121
       +
       		t.Fatalf("Failed to parse DID: %v", parseErr)

     

       1122
       1122
       +
       	}

     

       1123
       1123
       +
       	session, sessionErr := mockStore.GetSession(ctx, parsedDID, "session-"+userDID)

     

       1124
       1124
       +
       	if sessionErr != nil {

     

       1125
       1125
       +
       		t.Fatalf("Failed to get session: %v", sessionErr)

     

       1126
       1126
       +
       	}

     

       1127
       1127
       +
       

     

       1128
       1128
       +
       	t.Run("empty content returns ErrContentEmpty", func(t *testing.T) {

     

       1129
       1129
       +
       		commentReq := comments.CreateCommentRequest{

     

       1130
       1130
       +
       			Reply: comments.ReplyRef{

     

       1131
       1131
       +
       				Root:   comments.StrongRef{URI: postURI, CID: postCID},

     

       1132
       1132
       +
       				Parent: comments.StrongRef{URI: postURI, CID: postCID},

     

       1133
       1133
       +
       			},

     

       1134
       1134
       +
       			Content: "",

     

       1135
       1135
       +
       			Langs:   []string{"en"},

     

       1136
       1136
       +
       		}

     

       1137
       1137
       +
       

     

       1138
       1138
       +
       		_, err := commentService.CreateComment(ctx, session, commentReq)

     

       1139
       1139
       +
       		if err == nil {

     

       1140
       1140
       +
       			t.Errorf("Expected error for empty content, got nil")

     

       1141
       1141
       +
       		} else if err != comments.ErrContentEmpty {

     

       1142
       1142
       +
       			t.Errorf("Expected ErrContentEmpty, got: %v", err)

     

       1143
       1143
       +
       		} else {

     

       1144
       1144
       +
       			t.Logf("✅ Correctly rejected: empty content returns ErrContentEmpty")

     

       1145
       1145
       +
       		}

     

       1146
       1146
       +
       	})

     

       1147
       1147
       +
       

     

       1148
       1148
       +
       	t.Run("whitespace-only content returns ErrContentEmpty", func(t *testing.T) {

     

       1149
       1149
       +
       		commentReq := comments.CreateCommentRequest{

     

       1150
       1150
       +
       			Reply: comments.ReplyRef{

     

       1151
       1151
       +
       				Root:   comments.StrongRef{URI: postURI, CID: postCID},

     

       1152
       1152
       +
       				Parent: comments.StrongRef{URI: postURI, CID: postCID},

     

       1153
       1153
       +
       			},

     

       1154
       1154
       +
       			Content: "   \t\n   ",

     

       1155
       1155
       +
       			Langs:   []string{"en"},

     

       1156
       1156
       +
       		}

     

       1157
       1157
       +
       

     

       1158
       1158
       +
       		_, err := commentService.CreateComment(ctx, session, commentReq)

     

       1159
       1159
       +
       		if err == nil {

     

       1160
       1160
       +
       			t.Errorf("Expected error for whitespace-only content, got nil")

     

       1161
       1161
       +
       		} else if err != comments.ErrContentEmpty {

     

       1162
       1162
       +
       			t.Errorf("Expected ErrContentEmpty, got: %v", err)

     

       1163
       1163
       +
       		} else {

     

       1164
       1164
       +
       			t.Logf("✅ Correctly rejected: whitespace-only content returns ErrContentEmpty")

     

       1165
       1165
       +
       		}

     

       1166
       1166
       +
       	})

     

       1167
       1167
       +
       

     

       1168
       1168
       +
       	t.Run("invalid reply reference returns ErrInvalidReply", func(t *testing.T) {

     

       1169
       1169
       +
       		commentReq := comments.CreateCommentRequest{

     

       1170
       1170
       +
       			Reply: comments.ReplyRef{

     

       1171
       1171
       +
       				Root:   comments.StrongRef{URI: "", CID: ""},

     

       1172
       1172
       +
       				Parent: comments.StrongRef{URI: "", CID: ""},

     

       1173
       1173
       +
       			},

     

       1174
       1174
       +
       			Content: "Valid content",

     

       1175
       1175
       +
       			Langs:   []string{"en"},

     

       1176
       1176
       +
       		}

     

       1177
       1177
       +
       

     

       1178
       1178
       +
       		_, err := commentService.CreateComment(ctx, session, commentReq)

     

       1179
       1179
       +
       		if err == nil {

     

       1180
       1180
       +
       			t.Errorf("Expected error for invalid reply, got nil")

     

       1181
       1181
       +
       		} else if err != comments.ErrInvalidReply {

     

       1182
       1182
       +
       			t.Errorf("Expected ErrInvalidReply, got: %v", err)

     

       1183
       1183
       +
       		} else {

     

       1184
       1184
       +
       			t.Logf("✅ Correctly rejected: invalid reply returns ErrInvalidReply")

     

       1185
       1185
       +
       		}

     

       1186
       1186
       +
       	})

     

       1187
       1187
       +
       }

     

       1188
       1188
       +

+43 -12

internal/atproto/jetstream/community_consumer.go

···

       50
       50
        
       	cache, err := lru.New[string, cachedDIDDoc](1000)

     

       51
       51
        
       	if err != nil {

     

       52
       52
        
       		// This should never happen with a valid size, but handle gracefully

     

       53
       53
       -
       		log.Printf("WARNING: Failed to create DID cache, verification will be slower: %v", err)

     

       53
       53
       +
       		log.Printf("WARNING: Failed to create DID cache (size=1000), verification will be slower: %v", err)

     

       54
       54
        
       		// Create minimal cache to avoid nil pointer

     

       55
       55
       -
       		cache, _ = lru.New[string, cachedDIDDoc](1)

     

       55
       55
       +
       		cache, fallbackErr := lru.New[string, cachedDIDDoc](1)

     

       56
       56
       +
       		if fallbackErr != nil {

     

       57
       57
       +
       			// Both attempts failed - this indicates a serious issue with the LRU library

     

       58
       58
       +
       			log.Printf("CRITICAL: Failed to create fallback DID cache (size=1): %v", fallbackErr)

     

       59
       59
       +
       			panic(fmt.Sprintf("cannot create LRU cache: primary error=%v, fallback error=%v", err, fallbackErr))

     

       60
       60
       +
       		}

     

       61
       61
       +
       		return &CommunityEventConsumer{

     

       62
       62
       +
       			repo:             repo,

     

       63
       63
       +
       			identityResolver: identityResolver,

     

       64
       64
       +
       			instanceDID:      instanceDID,

     

       65
       65
       +
       			skipVerification: skipVerification,

     

       66
       66
       +
       			httpClient: &http.Client{

     

       67
       67
       +
       				Timeout: 10 * time.Second,

     

       68
       68
       +
       				Transport: &http.Transport{

     

       69
       69
       +
       					MaxIdleConns:        100,

     

       70
       70
       +
       					MaxIdleConnsPerHost: 10,

     

       71
       71
       +
       					IdleConnTimeout:     90 * time.Second,

     

       72
       72
       +
       				},

     

       73
       73
       +
       			},

     

       74
       74
       +
       			didCache:         cache,

     

       75
       75
       +
       			wellKnownLimiter: rate.NewLimiter(10, 20),

     

       76
       76
       +
       		}

     

       56
       77
        
       	}

     

       57
       78
        
       

     

       58
       79
        
       	return &CommunityEventConsumer{

     
···

       219
       240
        
       	// Handle description facets (rich text)

     

       220
       241
        
       	if profile.DescriptionFacets != nil {

     

       221
       242
        
       		facetsJSON, marshalErr := json.Marshal(profile.DescriptionFacets)

     

       222
       222
       -
       		if marshalErr == nil {

     

       243
       243
       +
       		if marshalErr != nil {

     

       244
       244
       +
       			log.Printf("WARNING: Failed to marshal description facets for community %s: %v (facets will be omitted)", did, marshalErr)

     

       245
       245
       +
       		} else {

     

       223
       246
        
       			community.DescriptionFacets = facetsJSON

     

       224
       247
        
       		}

     

       225
       248
        
       	}

     
···

       508
       531
        
       // extractDomainFromHandle extracts the registrable domain from a community handle

     

       509
       532
        
       // Handles both formats:

     

       510
       533
        
       //   - Bluesky-style: "!gaming@coves.social" → "coves.social"

     

       511
       511
       -
       //   - DNS-style: "gaming.community.coves.social" → "coves.social"

     

       534
       534
       +
       //   - DNS-style: "c-gaming.coves.social" → "coves.social"

     

       512
       535
        
       //

     

       513
       536
        
       // Uses golang.org/x/net/publicsuffix to correctly handle multi-part TLDs:

     

       514
       514
       -
       //   - "gaming.community.coves.co.uk" → "coves.co.uk" (not "co.uk")

     

       515
       515
       -
       //   - "gaming.community.example.com.au" → "example.com.au" (not "com.au")

     

       537
       537
       +
       //   - "c-gaming.coves.co.uk" → "coves.co.uk" (not "co.uk")

     

       538
       538
       +
       //   - "c-gaming.example.com.au" → "example.com.au" (not "com.au")

     

       516
       539
        
       func extractDomainFromHandle(handle string) string {

     

       517
       540
        
       	// Remove leading ! if present

     

       518
       541
        
       	handle = strings.TrimPrefix(handle, "!")

     
···

       527
       550
        
       			if err != nil {

     

       528
       551
        
       				// If publicsuffix fails, fall back to returning the full domain part

     

       529
       552
        
       				// This handles edge cases like localhost, IP addresses, etc.

     

       553
       553
       +
       				log.Printf("DEBUG: publicsuffix failed for @-format handle domain %q, using raw domain: %v", domain, err)

     

       530
       554
        
       				return domain

     

       531
       555
        
       			}

     

       532
       556
        
       			return registrable

     
···

       534
       558
        
       		return ""

     

       535
       559
        
       	}

     

       536
       560
        
       

     

       537
       537
       -
       	// For DNS-style handles (e.g., "gaming.community.coves.social")

     

       561
       561
       +
       	// For DNS-style handles (e.g., "c-gaming.coves.social")

     

       538
       562
        
       	// Extract the registrable domain (eTLD+1) using publicsuffix

     

       539
       563
        
       	// This correctly handles multi-part TLDs like .co.uk, .com.au, etc.

     

       540
       564
        
       	registrable, err := publicsuffix.EffectiveTLDPlusOne(handle)

     

       541
       565
        
       	if err != nil {

     

       542
       566
        
       		// If publicsuffix fails (e.g., invalid TLD, localhost, IP address)

     

       543
       567
        
       		// fall back to naive extraction (last 2 parts)

     

       544
       544
       -
       		// This maintains backward compatibility for edge cases

     

       568
       568
       +
       		// WARNING: This is incorrect for multi-part TLDs (.co.uk -> would return "co.uk")

     

       569
       569
       +
       		// but maintains compatibility for localhost/dev environments

     

       545
       570
        
       		parts := strings.Split(handle, ".")

     

       546
       571
        
       		if len(parts) < 2 {

     

       572
       572
       +
       			log.Printf("DEBUG: Invalid handle format (no dots): %q", handle)

     

       547
       573
        
       			return "" // Invalid handle

     

       548
       574
        
       		}

     

       549
       549
       -
       		return strings.Join(parts[len(parts)-2:], ".")

     

       575
       575
       +
       		fallbackDomain := strings.Join(parts[len(parts)-2:], ".")

     

       576
       576
       +
       		log.Printf("DEBUG: publicsuffix failed for handle %q, using naive fallback: %q (error: %v)", handle, fallbackDomain, err)

     

       577
       577
       +
       		return fallbackDomain

     

       550
       578
        
       	}

     

       551
       579
        
       

     

       552
       580
        
       	return registrable

     
···

       788
       816
        
       }

     

       789
       817
        
       

     

       790
       818
        
       // constructHandleFromProfile constructs a deterministic handle from profile data

     

       791
       791
       -
       // Format: {name}.community.{instanceDomain}

     

       792
       792
       -
       // Example: gaming.community.coves.social

     

       819
       819
       +
       // Format: c-{name}.{instanceDomain}

     

       820
       820
       +
       // Example: c-gaming.coves.social

     

       793
       821
        
       // This is ONLY used in test mode (when identity resolver is nil)

     

       794
       822
        
       // Production MUST resolve handles from PLC (source of truth)

     

       795
       823
        
       // Returns empty string if hostedBy is not did:web format (caller will fail validation)

     

       796
       824
        
       func constructHandleFromProfile(profile *CommunityProfile) string {

     

       797
       825
        
       	if !strings.HasPrefix(profile.HostedBy, "did:web:") {

     

       798
       826
        
       		// hostedBy must be did:web format for handle construction

     

       827
       827
       +
       		// Log warning since this indicates invalid community data

     

       828
       828
       +
       		log.Printf("WARNING: constructHandleFromProfile: hostedBy %q is not did:web format, cannot construct handle for community %q",

     

       829
       829
       +
       			profile.HostedBy, profile.Name)

     

       799
       830
        
       		// Return empty to trigger validation error in repository

     

       800
       831
        
       		return ""

     

       801
       832
        
       	}

     

       802
       833
        
       	instanceDomain := strings.TrimPrefix(profile.HostedBy, "did:web:")

     

       803
       803
       -
       	return fmt.Sprintf("%s.community.%s", profile.Name, instanceDomain)

     

       834
       834
       +
       	return fmt.Sprintf("c-%s.%s", profile.Name, instanceDomain)

     

       804
       835
        
       }

     

       805
       836
        
       

     

       806
       837
        
       // extractContentVisibility extracts contentVisibility from subscription record with clamping

+5 -6

internal/core/communities/pds_provisioning.go

···

       67
       67
        
       	}

     

       68
       68
        
       

     

       69
       69
        
       	// 1. Generate unique handle for the community

     

       70
       70
       -
       	// Format: {name}.community.{instance-domain}

     

       71
       71
       -
       	// Example: "gaming.community.coves.social"

     

       72
       72
       -
       	// NOTE: Using SINGULAR "community" to follow atProto lexicon conventions

     

       73
       73
       -
       	// (all record types use singular: app.bsky.feed.post, app.bsky.graph.follow, etc.)

     

       74
       74
       -
       	handle := fmt.Sprintf("%s.community.%s", strings.ToLower(communityName), p.instanceDomain)

     

       70
       70
       +
       	// Format: c-{name}.{instance-domain}

     

       71
       71
       +
       	// Example: "c-gaming.coves.social"

     

       72
       72
       +
       	// Uses c- prefix to distinguish from user handles while keeping single-level subdomain

     

       73
       73
       +
       	handle := fmt.Sprintf("c-%s.%s", strings.ToLower(communityName), p.instanceDomain)

     

       75
       74
        
       

     

       76
       75
        
       	// 2. Generate system email for PDS account management

     

       77
       76
        
       	// This email is used for account operations, not for user communication

     

       78
       78
       -
       	email := fmt.Sprintf("community-%s@community.%s", strings.ToLower(communityName), p.instanceDomain)

     

       77
       77
       +
       	email := fmt.Sprintf("c-%s@%s", strings.ToLower(communityName), p.instanceDomain)

     

       79
       78
        
       

     

       80
       79
        
       	// 3. Generate secure random password (32 characters)

     

       81
       80
        
       	// This password is never shown to users - it's for Coves to authenticate as the community

+49

internal/db/migrations/022_migrate_community_handles_to_c_prefix.sql

···

       1
       1
       +
       -- +goose Up

     

       2
       2
       +
       -- +goose StatementBegin

     

       3
       3
       +
       

     

       4
       4
       +
       -- Migration: Change community handles from .community. subdomain to c- prefix

     

       5
       5
       +
       -- This simplifies DNS/Caddy configuration (works with *.coves.social wildcard)

     

       6
       6
       +
       --

     

       7
       7
       +
       -- Examples:

     

       8
       8
       +
       --   gardening.community.coves.social -> c-gardening.coves.social

     

       9
       9
       +
       --   gaming.community.coves.social -> c-gaming.coves.social

     

       10
       10
       +
       --

     

       11
       11
       +
       -- Also updates the system email format:

     

       12
       12
       +
       --   community-gardening@community.coves.social -> c-gardening@coves.social

     

       13
       13
       +
       

     

       14
       14
       +
       -- Update community handles in the communities table

     

       15
       15
       +
       UPDATE communities

     

       16
       16
       +
       SET handle = 'c-' || SPLIT_PART(handle, '.community.', 1) || '.' || SPLIT_PART(handle, '.community.', 2)

     

       17
       17
       +
       WHERE handle LIKE '%.community.%';

     

       18
       18
       +
       

     

       19
       19
       +
       -- Update email addresses to match new format

     

       20
       20
       +
       -- Old: community-{name}@community.{instance}

     

       21
       21
       +
       -- New: c-{name}@{instance}

     

       22
       22
       +
       UPDATE communities

     

       23
       23
       +
       SET pds_email = 'c-' || SUBSTRING(pds_email FROM 11 FOR POSITION('@' IN pds_email) - 11) || '@' || SUBSTRING(pds_email FROM POSITION('@community.' IN pds_email) + 11)

     

       24
       24
       +
       WHERE pds_email LIKE 'community-%@community.%';

     

       25
       25
       +
       

     

       26
       26
       +
       -- +goose StatementEnd

     

       27
       27
       +
       

     

       28
       28
       +
       -- +goose Down

     

       29
       29
       +
       -- +goose StatementBegin

     

       30
       30
       +
       

     

       31
       31
       +
       -- Rollback: Revert handles from c- prefix back to .community. subdomain

     

       32
       32
       +
       -- Parse: c-{name}.{instance} -> {name}.community.{instance}

     

       33
       33
       +
       

     

       34
       34
       +
       UPDATE communities

     

       35
       35
       +
       SET handle = SUBSTRING(handle FROM 3 FOR POSITION('.' IN SUBSTRING(handle FROM 3)) - 1)

     

       36
       36
       +
                    || '.community.'

     

       37
       37
       +
                    || SUBSTRING(handle FROM POSITION('.' IN SUBSTRING(handle FROM 3)) + 3)

     

       38
       38
       +
       WHERE handle LIKE 'c-%' AND handle NOT LIKE '%.community.%';

     

       39
       39
       +
       

     

       40
       40
       +
       -- Revert email addresses

     

       41
       41
       +
       -- New: c-{name}@{instance}

     

       42
       42
       +
       -- Old: community-{name}@community.{instance}

     

       43
       43
       +
       UPDATE communities

     

       44
       44
       +
       SET pds_email = 'community-' || SUBSTRING(pds_email FROM 3 FOR POSITION('@' IN pds_email) - 3)

     

       45
       45
       +
                       || '@community.'

     

       46
       46
       +
                       || SUBSTRING(pds_email FROM POSITION('@' IN pds_email) + 1)

     

       47
       47
       +
       WHERE pds_email LIKE 'c-%@%' AND pds_email NOT LIKE 'community-%@community.%';

     

       48
       48
       +
       

     

       49
       49
       +
       -- +goose StatementEnd

+5 -5

tests/integration/community_consumer_test.go

···

       27
       27
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       28
       28
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       29
       29
        
       		communityName := fmt.Sprintf("test-community-%s", uniqueSuffix)

     

       30
       30
       -
       		expectedHandle := fmt.Sprintf("%s.community.coves.local", communityName)

     

       30
       30
       +
       		expectedHandle := fmt.Sprintf("c-%s.coves.local", communityName)

     

       31
       31
        
       

     

       32
       32
        
       		// Set up mock resolver for this test DID

     

       33
       33
        
       		mockResolver := newMockIdentityResolver()

     
···

       89
       89
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       90
       90
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       91
       91
        
       		communityName := fmt.Sprintf("update-test-%s", uniqueSuffix)

     

       92
       92
       -
       		expectedHandle := fmt.Sprintf("%s.community.coves.local", communityName)

     

       92
       92
       +
       		expectedHandle := fmt.Sprintf("c-%s.coves.local", communityName)

     

       93
       93
        
       

     

       94
       94
        
       		// Set up mock resolver for this test DID

     

       95
       95
        
       		mockResolver := newMockIdentityResolver()

     
···

       174
       174
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       175
       175
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       176
       176
        
       		communityName := fmt.Sprintf("delete-test-%s", uniqueSuffix)

     

       177
       177
       -
       		expectedHandle := fmt.Sprintf("%s.community.coves.local", communityName)

     

       177
       177
       +
       		expectedHandle := fmt.Sprintf("c-%s.coves.local", communityName)

     

       178
       178
        
       

     

       179
       179
        
       		// Set up mock resolver for this test DID

     

       180
       180
        
       		mockResolver := newMockIdentityResolver()

     
···

       239
       239
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       240
       240
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       241
       241
        
       		communityName := fmt.Sprintf("sub-test-%s", uniqueSuffix)

     

       242
       242
       -
       		expectedHandle := fmt.Sprintf("%s.community.coves.local", communityName)

     

       242
       242
       +
       		expectedHandle := fmt.Sprintf("c-%s.coves.local", communityName)

     

       243
       243
        
       

     

       244
       244
        
       		// Set up mock resolver for this test DID

     

       245
       245
        
       		mockResolver := newMockIdentityResolver()

     
···

       418
       418
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       419
       419
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       420
       420
        
       		communityName := fmt.Sprintf("test-plc-%s", uniqueSuffix)

     

       421
       421
       -
       		expectedHandle := fmt.Sprintf("%s.community.coves.social", communityName)

     

       421
       421
       +
       		expectedHandle := fmt.Sprintf("c-%s.coves.social", communityName)

     

       422
       422
        
       

     

       423
       423
        
       		// Create mock resolver

     

       424
       424
        
       		mockResolver := newMockIdentityResolver()

+8 -8

tests/integration/community_v2_validation_test.go

···

       29
       29
        
       		// Use unique DID and handle to avoid conflicts with other test runs

     

       30
       30
        
       		timestamp := time.Now().UnixNano()

     

       31
       31
        
       		testDID := fmt.Sprintf("did:plc:testv2rkey%d", timestamp)

     

       32
       32
       -
       		testHandle := fmt.Sprintf("testv2rkey%d.community.coves.social", timestamp)

     

       32
       32
       +
       		testHandle := fmt.Sprintf("c-testv2rkey%d.coves.social", timestamp)

     

       33
       33
        
       

     

       34
       34
        
       		event := &jetstream.JetstreamEvent{

     

       35
       35
        
       			Did:  testDID,

     
···

       90
       90
        
       				CID:        "bafyreiv1community",

     

       91
       91
        
       				Record: map[string]interface{}{

     

       92
       92
        
       					"$type":      "social.coves.community.profile",

     

       93
       93
       -
       					"handle":     "v1community.community.coves.social",

     

       93
       93
       +
       					"handle":     "c-v1community.coves.social",

     

       94
       94
        
       					"name":       "v1community",

     

       95
       95
        
       					"createdBy":  "did:plc:user456",

     

       96
       96
        
       					"hostedBy":   "did:web:coves.social",

     
···

       136
       136
        
       				CID:        "bafyreicustom",

     

       137
       137
        
       				Record: map[string]interface{}{

     

       138
       138
        
       					"$type":      "social.coves.community.profile",

     

       139
       139
       -
       					"handle":     "custom.community.coves.social",

     

       139
       139
       +
       					"handle":     "c-custom.coves.social",

     

       140
       140
        
       					"name":       "custom",

     

       141
       141
        
       					"createdBy":  "did:plc:user789",

     

       142
       142
        
       					"hostedBy":   "did:web:coves.social",

     
···

       175
       175
        
       				CID:        "bafyreiupdate1",

     

       176
       176
        
       				Record: map[string]interface{}{

     

       177
       177
        
       					"$type":      "social.coves.community.profile",

     

       178
       178
       -
       					"handle":     "updatetest.community.coves.social",

     

       178
       178
       +
       					"handle":     "c-updatetest.coves.social",

     

       179
       179
        
       					"name":       "updatetest",

     

       180
       180
        
       					"createdBy":  "did:plc:userUpdate",

     

       181
       181
        
       					"hostedBy":   "did:web:coves.social",

     
···

       206
       206
        
       				CID:        "bafyreiupdate2",

     

       207
       207
        
       				Record: map[string]interface{}{

     

       208
       208
        
       					"$type":       "social.coves.community.profile",

     

       209
       209
       -
       					"handle":      "updatetest.community.coves.social",

     

       209
       209
       +
       					"handle":      "c-updatetest.coves.social",

     

       210
       210
        
       					"name":        "updatetest",

     

       211
       211
        
       					"displayName": "Updated Name",

     

       212
       212
        
       					"createdBy":   "did:plc:userUpdate",

     
···

       266
       266
        
       				CID:        "bafyreihandle",

     

       267
       267
        
       				Record: map[string]interface{}{

     

       268
       268
        
       					"$type":      "social.coves.community.profile",

     

       269
       269
       -
       					"handle":     "gamingtest.community.coves.social", // atProto handle (DNS-resolvable)

     

       269
       269
       +
       					"handle":     "c-gamingtest.coves.social", // atProto handle (DNS-resolvable)

     

       270
       270
        
       					"name":       "gamingtest",                        // Short name for !mentions

     

       271
       271
        
       					"createdBy":  "did:plc:user123",

     

       272
       272
        
       					"hostedBy":   "did:web:coves.social",

     
···

       292
       292
        
       		}

     

       293
       293
        
       

     

       294
       294
        
       		// Verify the atProto handle is stored

     

       295
       295
       -
       		if community.Handle != "gamingtest.community.coves.social" {

     

       296
       296
       -
       			t.Errorf("Expected handle gamingtest.community.coves.social, got %s", community.Handle)

     

       295
       295
       +
       		if community.Handle != "c-gamingtest.coves.social" {

     

       296
       296
       +
       			t.Errorf("Expected handle c-gamingtest.coves.social, got %s", community.Handle)

     

       297
       297
        
       		}

     

       298
       298
        
       

     

       299
       299
        
       		// Note: The DID is the authoritative identifier for atProto resolution

+2 -2

tests/integration/token_refresh_test.go

···

       110
       110
        
       	// Create a test community first

     

       111
       111
        
       	community := &communities.Community{

     

       112
       112
        
       		DID:             "did:plc:test123",

     

       113
       113
       -
       		Handle:          "test.community.coves.social",

     

       113
       113
       +
       		Handle:          "c-test.coves.social",

     

       114
       114
        
       		Name:            "test",

     

       115
       115
        
       		OwnerDID:        "did:plc:test123",

     

       116
       116
        
       		CreatedByDID:    "did:plc:creator",

     
···

       186
       186
        
       

     

       187
       187
        
       	community := &communities.Community{

     

       188
       188
        
       		DID:             "did:plc:expiring123",

     

       189
       189
       -
       		Handle:          "expiring.community.coves.social",

     

       189
       189
       +
       		Handle:          "c-expiring.coves.social",

     

       190
       190
        
       		Name:            "expiring",

     

       191
       191
        
       		OwnerDID:        "did:plc:expiring123",

     

       192
       192
        
       		CreatedByDID:    "did:plc:creator",

internal/atproto/oauth/store_test.go

···

       335
       335
        
       func TestPostgresOAuthStore_CleanupExpiredSessions(t *testing.T) {

     

       336
       336
        
       	db := setupTestDB(t)

     

       337
       337
        
       	defer func() { _ = db.Close() }()

     

       338
       338
       +
       	// Clean up before AND after to ensure test isolation

     

       339
       339
       +
       	cleanupOAuth(t, db)

     

       338
       340
        
       	defer cleanupOAuth(t, db)

     

       339
       341
        
       

     

       340
       342
        
       	storeInterface := NewPostgresOAuthStore(db, 0) // Use default TTL

+5 -5

internal/db/postgres/vote_repo_test.go

···

       271
       271
        
       	err = repo.Delete(ctx, vote.URI)

     

       272
       272
        
       	assert.NoError(t, err)

     

       273
       273
        
       

     

       274
       274
       -
       	// Verify vote is soft-deleted (still exists but has deleted_at)

     

       275
       275
       -
       	retrieved, err := repo.GetByURI(ctx, vote.URI)

     

       276
       276
       -
       	assert.NoError(t, err)

     

       277
       277
       -
       	assert.NotNil(t, retrieved.DeletedAt, "DeletedAt should be set after deletion")

     

       274
       274
       +
       	// Verify vote is soft-deleted by checking it's no longer retrievable

     

       275
       275
       +
       	// GetByURI excludes deleted votes (returns ErrVoteNotFound)

     

       276
       276
       +
       	_, err = repo.GetByURI(ctx, vote.URI)

     

       277
       277
       +
       	assert.ErrorIs(t, err, votes.ErrVoteNotFound, "GetByURI should not return deleted votes")

     

       278
       278
        
       

     

       279
       279
       -
       	// GetByVoterAndSubject should not find deleted votes

     

       279
       279
       +
       	// GetByVoterAndSubject should also not find deleted votes

     

       280
       280
        
       	_, err = repo.GetByVoterAndSubject(ctx, voterDID, vote.SubjectURI)

     

       281
       281
        
       	assert.ErrorIs(t, err, votes.ErrVoteNotFound, "GetByVoterAndSubject should not return deleted votes")

     

       282
       282
        
       }

+26 -3

tests/integration/oauth_e2e_test.go

···

       195
       195
        
       	assert.Equal(t, oauth.ErrSessionNotFound, err, "Should return ErrSessionNotFound for expired session")

     

       196
       196
        
       

     

       197
       197
        
       	// Test cleanup of expired sessions

     

       198
       198
       -
       	cleaned, err := store.(*oauth.PostgresOAuthStore).CleanupExpiredSessions(ctx)

     

       198
       198
       +
       	// Need to access the underlying PostgresOAuthStore through the wrapper

     

       199
       199
       +
       	var pgStore *oauth.PostgresOAuthStore

     

       200
       200
       +
       	if wrapper, ok := store.(*oauth.MobileAwareStoreWrapper); ok {

     

       201
       201
       +
       		pgStore, _ = wrapper.ClientAuthStore.(*oauth.PostgresOAuthStore)

     

       202
       202
       +
       	} else {

     

       203
       203
       +
       		pgStore, _ = store.(*oauth.PostgresOAuthStore)

     

       204
       204
       +
       	}

     

       205
       205
       +
       	require.NotNil(t, pgStore, "Should be able to access PostgresOAuthStore")

     

       206
       206
       +
       

     

       207
       207
       +
       	cleaned, err := pgStore.CleanupExpiredSessions(ctx)

     

       199
       208
        
       	require.NoError(t, err, "Cleanup should succeed")

     

       200
       209
        
       	assert.Greater(t, cleaned, int64(0), "Should have cleaned up at least one session")

     

       201
       210
        
       

     
···

       464
       473
        
       

     

       465
       474
        
       	// Test cleanup of expired auth requests

     

       466
       475
        
       	// Create an auth request and manually set created_at to the past

     

       476
       476
       +
       	// Use unique state to avoid conflicts with previous test runs

     

       477
       477
       +
       	oldState := fmt.Sprintf("old-state-%d", time.Now().UnixNano())

     

       467
       478
        
       	oldAuthRequest := oauthlib.AuthRequestData{

     

       468
       468
       -
       		State:         "old-state-12345",

     

       479
       479
       +
       		State:         oldState,

     

       469
       480
        
       		PKCEVerifier:  "old-verifier",

     

       470
       481
        
       		AuthServerURL: "http://localhost:3001",

     

       471
       482
        
       		Scopes:        []string{"atproto"},

     

       472
       483
        
       	}

     

       473
       484
        
       

     

       485
       485
       +
       	// Clean up any existing state first

     

       486
       486
       +
       	_ = store.DeleteAuthRequestInfo(ctx, oldState)

     

       487
       487
       +
       

     

       474
       488
        
       	err = store.SaveAuthRequestInfo(ctx, oldAuthRequest)

     

       475
       489
        
       	require.NoError(t, err)

     

       476
       490
        
       

     
···

       481
       495
        
       	require.NoError(t, err)

     

       482
       496
        
       

     

       483
       497
        
       	// Cleanup expired requests

     

       484
       484
       -
       	cleaned, err := store.(*oauth.PostgresOAuthStore).CleanupExpiredAuthRequests(ctx)

     

       498
       498
       +
       	// Need to access the underlying PostgresOAuthStore through the wrapper

     

       499
       499
       +
       	var pgStore *oauth.PostgresOAuthStore

     

       500
       500
       +
       	if wrapper, ok := store.(*oauth.MobileAwareStoreWrapper); ok {

     

       501
       501
       +
       		pgStore, _ = wrapper.ClientAuthStore.(*oauth.PostgresOAuthStore)

     

       502
       502
       +
       	} else {

     

       503
       503
       +
       		pgStore, _ = store.(*oauth.PostgresOAuthStore)

     

       504
       504
       +
       	}

     

       505
       505
       +
       	require.NotNil(t, pgStore, "Should be able to access PostgresOAuthStore")

     

       506
       506
       +
       

     

       507
       507
       +
       	cleaned, err := pgStore.CleanupExpiredAuthRequests(ctx)

     

       485
       508
        
       	require.NoError(t, err, "Cleanup should succeed")

     

       486
       509
        
       	assert.Greater(t, cleaned, int64(0), "Should have cleaned up at least one auth request")

     

       487
       510

+5 -5

tests/integration/vote_e2e_test.go

···

       84
       84
        
       	voteService := votes.NewServiceWithPDSFactory(voteRepo, nil, nil, PasswordAuthPDSClientFactory())

     

       85
       85
        
       

     

       86
       86
        
       	// Create test user on PDS

     

       87
       87
       -
       	testUserHandle := fmt.Sprintf("voter-%d.local.coves.dev", time.Now().Unix())

     

       87
       87
       +
       	testUserHandle := fmt.Sprintf("vot%d.local.coves.dev", time.Now().UnixNano()%1000000)

     

       88
       88
        
       	testUserEmail := fmt.Sprintf("voter-%d@test.local", time.Now().Unix())

     

       89
       89
        
       	testUserPassword := "test-password-123"

     

       90
       90
        
       

     
···

       307
       307
        
       	voteService := votes.NewServiceWithPDSFactory(voteRepo, nil, nil, PasswordAuthPDSClientFactory())

     

       308
       308
        
       

     

       309
       309
        
       	// Create test user

     

       310
       310
       -
       	testUserHandle := fmt.Sprintf("toggle-%d.local.coves.dev", time.Now().Unix())

     

       310
       310
       +
       	testUserHandle := fmt.Sprintf("tog%d.local.coves.dev", time.Now().UnixNano()%1000000)

     

       311
       311
        
       	testUserEmail := fmt.Sprintf("toggle-%d@test.local", time.Now().Unix())

     

       312
       312
        
       	testUserPassword := "test-password-123"

     

       313
       313
        
       

     
···

       476
       476
        
       	voteService := votes.NewServiceWithPDSFactory(voteRepo, nil, nil, PasswordAuthPDSClientFactory())

     

       477
       477
        
       

     

       478
       478
        
       	// Create test user

     

       479
       479
       -
       	testUserHandle := fmt.Sprintf("flip-%d.local.coves.dev", time.Now().Unix())

     

       479
       479
       +
       	testUserHandle := fmt.Sprintf("flp%d.local.coves.dev", time.Now().UnixNano()%1000000)

     

       480
       480
        
       	testUserEmail := fmt.Sprintf("flip-%d@test.local", time.Now().Unix())

     

       481
       481
        
       	testUserPassword := "test-password-123"

     

       482
       482
        
       

     
···

       701
       701
        
       	voteService := votes.NewServiceWithPDSFactory(voteRepo, nil, nil, PasswordAuthPDSClientFactory())

     

       702
       702
        
       

     

       703
       703
        
       	// Create test user

     

       704
       704
       -
       	testUserHandle := fmt.Sprintf("delete-%d.local.coves.dev", time.Now().Unix())

     

       704
       704
       +
       	testUserHandle := fmt.Sprintf("dlt%d.local.coves.dev", time.Now().UnixNano()%1000000)

     

       705
       705
        
       	testUserEmail := fmt.Sprintf("delete-%d@test.local", time.Now().Unix())

     

       706
       706
        
       	testUserPassword := "test-password-123"

     

       707
       707
        
       

     
···

       888
       888
        
       	voteRepo := postgres.NewVoteRepository(db)

     

       889
       889
        
       

     

       890
       890
        
       	// Create test user on PDS

     

       891
       891
       -
       	testUserHandle := fmt.Sprintf("jetstream-%d.local.coves.dev", time.Now().Unix())

     

       891
       891
       +
       	testUserHandle := fmt.Sprintf("jet%d.local.coves.dev", time.Now().UnixNano()%1000000)

     

       892
       892
        
       	testUserEmail := fmt.Sprintf("jetstream-%d@test.local", time.Now().Unix())

     

       893
       893
        
       	testUserPassword := "test-password-123"

     

       894
       894

+13 -6

internal/api/handlers/aggregator/list_for_community.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"Coves/internal/core/aggregators"

     

       5
       5
       +
       	"Coves/internal/core/communities"

     

       5
       6
        
       	"encoding/json"

     

       6
       7
        
       	"log"

     

       7
       8
        
       	"net/http"

     
···

       10
       11
        
       

     

       11
       12
        
       // ListForCommunityHandler handles listing aggregators for a community

     

       12
       13
        
       type ListForCommunityHandler struct {

     

       13
       13
       -
       	service aggregators.Service

     

       14
       14
       +
       	service          aggregators.Service

     

       15
       15
       +
       	communityService communities.Service

     

       14
       16
        
       }

     

       15
       17
        
       

     

       16
       18
        
       // NewListForCommunityHandler creates a new list for community handler

     

       17
       17
       -
       func NewListForCommunityHandler(service aggregators.Service) *ListForCommunityHandler {

     

       19
       19
       +
       func NewListForCommunityHandler(service aggregators.Service, communityService communities.Service) *ListForCommunityHandler {

     

       18
       20
        
       	return &ListForCommunityHandler{

     

       19
       19
       -
       		service: service,

     

       21
       21
       +
       		service:          service,

     

       22
       22
       +
       		communityService: communityService,

     

       20
       23
        
       	}

     

       21
       24
        
       }

     

       22
       25
        
       

     
···

       36
       39
        
       		return

     

       37
       40
        
       	}

     

       38
       41
        
       

     

       39
       39
       -
       	// Resolve community identifier to DID (handles both DIDs and handles)

     

       40
       40
       -
       	// TODO: Implement identifier resolution service - for now, assume it's a DID

     

       41
       41
       -
       	req.CommunityDID = communityIdentifier

     

       42
       42
       +
       	// Resolve community identifier to DID (supports DIDs, handles, scoped identifiers)

     

       43
       43
       +
       	communityDID, err := h.communityService.ResolveCommunityIdentifier(r.Context(), communityIdentifier)

     

       44
       44
       +
       	if err != nil {

     

       45
       45
       +
       		handleServiceError(w, err)

     

       46
       46
       +
       		return

     

       47
       47
       +
       	}

     

       48
       48
       +
       	req.CommunityDID = communityDID

     

       42
       49
        
       

     

       43
       50
        
       	// Get authorizations from service

     

       44
       51
        
       	// Note: Community handle/name fields will be empty until we integrate with communities service

+18 -10

internal/api/handlers/communityFeed/get_community.go

···

       1
       1
        
       package communityFeed

     

       2
       2
        
       

     

       3
       3
        
       import (

     

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

     

       5
       5
       -
       	"Coves/internal/core/communityFeeds"

     

       6
       6
       -
       	"Coves/internal/core/posts"

     

       7
       7
       -
       	"Coves/internal/core/votes"

     

       8
       4
        
       	"encoding/json"

     

       9
       5
        
       	"log"

     

       10
       6
        
       	"net/http"

     

       11
       7
        
       	"strconv"

     

       8
       8
       +
       

     

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

     

       10
       10
       +
       	"Coves/internal/core/blueskypost"

     

       11
       11
       +
       	"Coves/internal/core/communityFeeds"

     

       12
       12
       +
       	"Coves/internal/core/posts"

     

       13
       13
       +
       	"Coves/internal/core/votes"

     

       12
       14
        
       )

     

       13
       15
        
       

     

       14
       16
        
       // GetCommunityHandler handles community feed retrieval

     

       15
       17
        
       type GetCommunityHandler struct {

     

       16
       16
       -
       	service     communityFeeds.Service

     

       17
       17
       -
       	voteService votes.Service

     

       18
       18
       +
       	service        communityFeeds.Service

     

       19
       19
       +
       	voteService    votes.Service

     

       20
       20
       +
       	blueskyService blueskypost.Service

     

       18
       21
        
       }

     

       19
       22
        
       

     

       20
       23
        
       // NewGetCommunityHandler creates a new community feed handler

     

       21
       21
       -
       func NewGetCommunityHandler(service communityFeeds.Service, voteService votes.Service) *GetCommunityHandler {

     

       24
       24
       +
       func NewGetCommunityHandler(service communityFeeds.Service, voteService votes.Service, blueskyService blueskypost.Service) *GetCommunityHandler {

     

       25
       25
       +
       	if blueskyService == nil {

     

       26
       26
       +
       		log.Printf("[COMMUNITY-HANDLER] WARNING: blueskyService is nil - Bluesky post embeds will not be resolved")

     

       27
       27
       +
       	}

     

       22
       28
        
       	return &GetCommunityHandler{

     

       23
       23
       -
       		service:     service,

     

       24
       24
       -
       		voteService: voteService,

     

       29
       29
       +
       		service:        service,

     

       30
       30
       +
       		voteService:    voteService,

     

       31
       31
       +
       		blueskyService: blueskyService,

     

       25
       32
        
       	}

     

       26
       33
        
       }

     

       27
       34
        
       

     
···

       50
       57
        
       	// Populate viewer vote state if authenticated

     

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

     

       52
       59
        
       

     

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

     

       60
       60
       +
       	// Transform blob refs to URLs and resolve post embeds for all posts

     

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

     

       55
       62
        
       		if feedPost.Post != nil {

     

       56
       63
        
       			posts.TransformBlobRefsToURLs(feedPost.Post)

     

       64
       64
       +
       			posts.TransformPostEmbeds(r.Context(), feedPost.Post, h.blueskyService)

     

       57
       65
        
       		}

     

       58
       66
        
       	}

     

       59
       67

+19 -11

internal/api/handlers/timeline/get_timeline.go

···

       1
       1
        
       package timeline

     

       2
       2
        
       

     

       3
       3
        
       import (

     

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

     

       5
       5
       -
       	"Coves/internal/api/middleware"

     

       6
       6
       -
       	"Coves/internal/core/posts"

     

       7
       7
       -
       	"Coves/internal/core/timeline"

     

       8
       8
       -
       	"Coves/internal/core/votes"

     

       9
       4
        
       	"encoding/json"

     

       10
       5
        
       	"log"

     

       11
       6
        
       	"net/http"

     

       12
       7
        
       	"strconv"

     

       13
       8
        
       	"strings"

     

       9
       9
       +
       

     

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

     

       11
       11
       +
       	"Coves/internal/api/middleware"

     

       12
       12
       +
       	"Coves/internal/core/blueskypost"

     

       13
       13
       +
       	"Coves/internal/core/posts"

     

       14
       14
       +
       	"Coves/internal/core/timeline"

     

       15
       15
       +
       	"Coves/internal/core/votes"

     

       14
       16
        
       )

     

       15
       17
        
       

     

       16
       18
        
       // GetTimelineHandler handles timeline feed retrieval

     

       17
       19
        
       type GetTimelineHandler struct {

     

       18
       18
       -
       	service     timeline.Service

     

       19
       19
       -
       	voteService votes.Service

     

       20
       20
       +
       	service        timeline.Service

     

       21
       21
       +
       	voteService    votes.Service

     

       22
       22
       +
       	blueskyService blueskypost.Service

     

       20
       23
        
       }

     

       21
       24
        
       

     

       22
       25
        
       // NewGetTimelineHandler creates a new timeline handler

     

       23
       23
       -
       func NewGetTimelineHandler(service timeline.Service, voteService votes.Service) *GetTimelineHandler {

     

       26
       26
       +
       func NewGetTimelineHandler(service timeline.Service, voteService votes.Service, blueskyService blueskypost.Service) *GetTimelineHandler {

     

       27
       27
       +
       	if blueskyService == nil {

     

       28
       28
       +
       		log.Printf("[TIMELINE-HANDLER] WARNING: blueskyService is nil - Bluesky post embeds will not be resolved")

     

       29
       29
       +
       	}

     

       24
       30
        
       	return &GetTimelineHandler{

     

       25
       25
       -
       		service:     service,

     

       26
       26
       -
       		voteService: voteService,

     

       31
       31
       +
       		service:        service,

     

       32
       32
       +
       		voteService:    voteService,

     

       33
       33
       +
       		blueskyService: blueskyService,

     

       27
       34
        
       	}

     

       28
       35
        
       }

     

       29
       36
        
       

     
···

       60
       67
        
       	// Populate viewer vote state if authenticated

     

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

     

       62
       69
        
       

     

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

     

       70
       70
       +
       	// Transform blob refs to URLs and resolve post embeds for all posts

     

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

     

       65
       72
        
       		if feedPost.Post != nil {

     

       66
       73
        
       			posts.TransformBlobRefsToURLs(feedPost.Post)

     

       74
       74
       +
       			posts.TransformPostEmbeds(r.Context(), feedPost.Post, h.blueskyService)

     

       67
       75
        
       		}

     

       68
       76
        
       	}

     

       69
       77

+178

internal/core/blueskypost/circuit_breaker.go

···

       1
       1
       +
       package blueskypost

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"log"

     

       6
       6
       +
       	"sync"

     

       7
       7
       +
       	"time"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       // circuitState represents the state of a circuit breaker

     

       11
       11
       +
       type circuitState int

     

       12
       12
       +
       

     

       13
       13
       +
       const (

     

       14
       14
       +
       	stateClosed   circuitState = iota // Normal operation

     

       15
       15
       +
       	stateOpen                         // Circuit is open (provider failing)

     

       16
       16
       +
       	stateHalfOpen                     // Testing if provider recovered

     

       17
       17
       +
       )

     

       18
       18
       +
       

     

       19
       19
       +
       // circuitBreaker tracks failures per provider and stops trying failing providers

     

       20
       20
       +
       type circuitBreaker struct {

     

       21
       21
       +
       	failures         map[string]int

     

       22
       22
       +
       	lastFailure      map[string]time.Time

     

       23
       23
       +
       	state            map[string]circuitState

     

       24
       24
       +
       	lastStateLog     map[string]time.Time

     

       25
       25
       +
       	failureThreshold int

     

       26
       26
       +
       	openDuration     time.Duration

     

       27
       27
       +
       	mu               sync.RWMutex

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       // newCircuitBreaker creates a circuit breaker with default settings

     

       31
       31
       +
       func newCircuitBreaker() *circuitBreaker {

     

       32
       32
       +
       	return &circuitBreaker{

     

       33
       33
       +
       		failureThreshold: 3,               // Open after 3 consecutive failures

     

       34
       34
       +
       		openDuration:     5 * time.Minute, // Keep open for 5 minutes

     

       35
       35
       +
       		failures:         make(map[string]int),

     

       36
       36
       +
       		lastFailure:      make(map[string]time.Time),

     

       37
       37
       +
       		state:            make(map[string]circuitState),

     

       38
       38
       +
       		lastStateLog:     make(map[string]time.Time),

     

       39
       39
       +
       	}

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       // canAttempt checks if we should attempt to call this provider

     

       43
       43
       +
       // Returns true if circuit is closed or half-open (ready to retry)

     

       44
       44
       +
       func (cb *circuitBreaker) canAttempt(provider string) (bool, error) {

     

       45
       45
       +
       	// First check under read lock if we need to transition

     

       46
       46
       +
       	cb.mu.RLock()

     

       47
       47
       +
       	state := cb.getState(provider)

     

       48
       48
       +
       	lastFail := cb.lastFailure[provider]

     

       49
       49
       +
       	needsTransition := state == stateOpen && time.Since(lastFail) > cb.openDuration

     

       50
       50
       +
       	cb.mu.RUnlock()

     

       51
       51
       +
       

     

       52
       52
       +
       	// If we need to transition, acquire write lock and re-check

     

       53
       53
       +
       	if needsTransition {

     

       54
       54
       +
       		cb.mu.Lock()

     

       55
       55
       +
       		// Re-check state in case another goroutine already transitioned

     

       56
       56
       +
       		state = cb.getState(provider)

     

       57
       57
       +
       		lastFail = cb.lastFailure[provider]

     

       58
       58
       +
       		if state == stateOpen && time.Since(lastFail) > cb.openDuration {

     

       59
       59
       +
       			cb.state[provider] = stateHalfOpen

     

       60
       60
       +
       			cb.logStateChange(provider, stateHalfOpen)

     

       61
       61
       +
       		}

     

       62
       62
       +
       		state = cb.state[provider]

     

       63
       63
       +
       		cb.mu.Unlock()

     

       64
       64
       +
       		// Return based on new state

     

       65
       65
       +
       		if state == stateHalfOpen {

     

       66
       66
       +
       			return true, nil

     

       67
       67
       +
       		}

     

       68
       68
       +
       	}

     

       69
       69
       +
       

     

       70
       70
       +
       	// Now check state under read lock

     

       71
       71
       +
       	cb.mu.RLock()

     

       72
       72
       +
       	defer cb.mu.RUnlock()

     

       73
       73
       +
       

     

       74
       74
       +
       	state = cb.getState(provider)

     

       75
       75
       +
       

     

       76
       76
       +
       	switch state {

     

       77
       77
       +
       	case stateClosed:

     

       78
       78
       +
       		return true, nil

     

       79
       79
       +
       	case stateOpen:

     

       80
       80
       +
       		// Still in open period

     

       81
       81
       +
       		failCount := cb.failures[provider]

     

       82
       82
       +
       		nextRetry := cb.lastFailure[provider].Add(cb.openDuration)

     

       83
       83
       +
       		return false, fmt.Errorf(

     

       84
       84
       +
       			"%w for provider '%s' (failures: %d, next retry: %s)",

     

       85
       85
       +
       			ErrCircuitOpen,

     

       86
       86
       +
       			provider,

     

       87
       87
       +
       			failCount,

     

       88
       88
       +
       			nextRetry.Format("15:04:05"),

     

       89
       89
       +
       		)

     

       90
       90
       +
       	case stateHalfOpen:

     

       91
       91
       +
       		return true, nil

     

       92
       92
       +
       	default:

     

       93
       93
       +
       		return true, nil

     

       94
       94
       +
       	}

     

       95
       95
       +
       }

     

       96
       96
       +
       

     

       97
       97
       +
       // recordSuccess records a successful fetch, resetting failure count

     

       98
       98
       +
       func (cb *circuitBreaker) recordSuccess(provider string) {

     

       99
       99
       +
       	cb.mu.Lock()

     

       100
       100
       +
       	defer cb.mu.Unlock()

     

       101
       101
       +
       

     

       102
       102
       +
       	oldState := cb.getState(provider)

     

       103
       103
       +
       

     

       104
       104
       +
       	// Reset failure tracking

     

       105
       105
       +
       	delete(cb.failures, provider)

     

       106
       106
       +
       	delete(cb.lastFailure, provider)

     

       107
       107
       +
       	cb.state[provider] = stateClosed

     

       108
       108
       +
       

     

       109
       109
       +
       	// Log recovery if we were in a failure state

     

       110
       110
       +
       	if oldState != stateClosed {

     

       111
       111
       +
       		cb.logStateChange(provider, stateClosed)

     

       112
       112
       +
       	}

     

       113
       113
       +
       }

     

       114
       114
       +
       

     

       115
       115
       +
       // recordFailure records a failed fetch attempt

     

       116
       116
       +
       func (cb *circuitBreaker) recordFailure(provider string, err error) {

     

       117
       117
       +
       	cb.mu.Lock()

     

       118
       118
       +
       	defer cb.mu.Unlock()

     

       119
       119
       +
       

     

       120
       120
       +
       	// Increment failure count

     

       121
       121
       +
       	cb.failures[provider]++

     

       122
       122
       +
       	cb.lastFailure[provider] = time.Now()

     

       123
       123
       +
       

     

       124
       124
       +
       	failCount := cb.failures[provider]

     

       125
       125
       +
       

     

       126
       126
       +
       	// Check if we should open the circuit

     

       127
       127
       +
       	if failCount >= cb.failureThreshold {

     

       128
       128
       +
       		oldState := cb.getState(provider)

     

       129
       129
       +
       		cb.state[provider] = stateOpen

     

       130
       130
       +
       		if oldState != stateOpen {

     

       131
       131
       +
       			log.Printf(

     

       132
       132
       +
       				"[BLUESKY-CIRCUIT] Opening circuit for provider '%s' after %d consecutive failures. Last error: %v",

     

       133
       133
       +
       				provider,

     

       134
       134
       +
       				failCount,

     

       135
       135
       +
       				err,

     

       136
       136
       +
       			)

     

       137
       137
       +
       			cb.lastStateLog[provider] = time.Now()

     

       138
       138
       +
       		}

     

       139
       139
       +
       	} else {

     

       140
       140
       +
       		log.Printf(

     

       141
       141
       +
       			"[BLUESKY-CIRCUIT] Failure %d/%d for provider '%s': %v",

     

       142
       142
       +
       			failCount,

     

       143
       143
       +
       			cb.failureThreshold,

     

       144
       144
       +
       			provider,

     

       145
       145
       +
       			err,

     

       146
       146
       +
       		)

     

       147
       147
       +
       	}

     

       148
       148
       +
       }

     

       149
       149
       +
       

     

       150
       150
       +
       // getState returns the current state (must be called with lock held)

     

       151
       151
       +
       func (cb *circuitBreaker) getState(provider string) circuitState {

     

       152
       152
       +
       	if state, exists := cb.state[provider]; exists {

     

       153
       153
       +
       		return state

     

       154
       154
       +
       	}

     

       155
       155
       +
       	return stateClosed

     

       156
       156
       +
       }

     

       157
       157
       +
       

     

       158
       158
       +
       // logStateChange logs state transitions (must be called with lock held)

     

       159
       159
       +
       // Debounced to avoid log spam (max once per minute per provider)

     

       160
       160
       +
       func (cb *circuitBreaker) logStateChange(provider string, newState circuitState) {

     

       161
       161
       +
       	lastLog, exists := cb.lastStateLog[provider]

     

       162
       162
       +
       	if exists && time.Since(lastLog) < time.Minute {

     

       163
       163
       +
       		return // Don't spam logs

     

       164
       164
       +
       	}

     

       165
       165
       +
       

     

       166
       166
       +
       	var stateStr string

     

       167
       167
       +
       	switch newState {

     

       168
       168
       +
       	case stateClosed:

     

       169
       169
       +
       		stateStr = "CLOSED (recovered)"

     

       170
       170
       +
       	case stateOpen:

     

       171
       171
       +
       		stateStr = "OPEN (failing)"

     

       172
       172
       +
       	case stateHalfOpen:

     

       173
       173
       +
       		stateStr = "HALF-OPEN (testing)"

     

       174
       174
       +
       	}

     

       175
       175
       +
       

     

       176
       176
       +
       	log.Printf("[BLUESKY-CIRCUIT] Circuit for provider '%s' is now %s", provider, stateStr)

     

       177
       177
       +
       	cb.lastStateLog[provider] = time.Now()

     

       178
       178
       +
       }

+410

internal/core/blueskypost/circuit_breaker_test.go

···

       1
       1
       +
       package blueskypost

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"errors"

     

       5
       5
       +
       	"sync"

     

       6
       6
       +
       	"testing"

     

       7
       7
       +
       	"time"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       func TestCircuitBreaker_InitialState(t *testing.T) {

     

       11
       11
       +
       	cb := newCircuitBreaker()

     

       12
       12
       +
       

     

       13
       13
       +
       	// Circuit should start in closed state

     

       14
       14
       +
       	canAttempt, err := cb.canAttempt("test-provider")

     

       15
       15
       +
       	if !canAttempt {

     

       16
       16
       +
       		t.Error("Circuit breaker should start in closed state")

     

       17
       17
       +
       	}

     

       18
       18
       +
       	if err != nil {

     

       19
       19
       +
       		t.Errorf("canAttempt() should not return error for closed circuit, got: %v", err)

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       func TestCircuitBreaker_OpensAfterThresholdFailures(t *testing.T) {

     

       24
       24
       +
       	cb := newCircuitBreaker()

     

       25
       25
       +
       	provider := "test-provider"

     

       26
       26
       +
       	testErr := errors.New("test error")

     

       27
       27
       +
       

     

       28
       28
       +
       	// Record failures up to threshold (default is 3)

     

       29
       29
       +
       	for i := 0; i < cb.failureThreshold; i++ {

     

       30
       30
       +
       		cb.recordFailure(provider, testErr)

     

       31
       31
       +
       	}

     

       32
       32
       +
       

     

       33
       33
       +
       	// Circuit should now be open

     

       34
       34
       +
       	canAttempt, err := cb.canAttempt(provider)

     

       35
       35
       +
       	if canAttempt {

     

       36
       36
       +
       		t.Error("Circuit breaker should be open after threshold failures")

     

       37
       37
       +
       	}

     

       38
       38
       +
       	if err == nil {

     

       39
       39
       +
       		t.Error("canAttempt() should return error when circuit is open")

     

       40
       40
       +
       	}

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       func TestCircuitBreaker_StaysClosedBelowThreshold(t *testing.T) {

     

       44
       44
       +
       	cb := newCircuitBreaker()

     

       45
       45
       +
       	provider := "test-provider"

     

       46
       46
       +
       	testErr := errors.New("test error")

     

       47
       47
       +
       

     

       48
       48
       +
       	// Record failures below threshold

     

       49
       49
       +
       	for i := 0; i < cb.failureThreshold-1; i++ {

     

       50
       50
       +
       		cb.recordFailure(provider, testErr)

     

       51
       51
       +
       	}

     

       52
       52
       +
       

     

       53
       53
       +
       	// Circuit should still be closed

     

       54
       54
       +
       	canAttempt, err := cb.canAttempt(provider)

     

       55
       55
       +
       	if !canAttempt {

     

       56
       56
       +
       		t.Error("Circuit breaker should remain closed below threshold")

     

       57
       57
       +
       	}

     

       58
       58
       +
       	if err != nil {

     

       59
       59
       +
       		t.Errorf("canAttempt() should not return error below threshold, got: %v", err)

     

       60
       60
       +
       	}

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       func TestCircuitBreaker_TransitionsToHalfOpenAfterTimeout(t *testing.T) {

     

       64
       64
       +
       	cb := newCircuitBreaker()

     

       65
       65
       +
       	// Set a very short open duration for testing

     

       66
       66
       +
       	cb.openDuration = 10 * time.Millisecond

     

       67
       67
       +
       	provider := "test-provider"

     

       68
       68
       +
       	testErr := errors.New("test error")

     

       69
       69
       +
       

     

       70
       70
       +
       	// Open the circuit

     

       71
       71
       +
       	for i := 0; i < cb.failureThreshold; i++ {

     

       72
       72
       +
       		cb.recordFailure(provider, testErr)

     

       73
       73
       +
       	}

     

       74
       74
       +
       

     

       75
       75
       +
       	// Verify circuit is open

     

       76
       76
       +
       	canAttempt, err := cb.canAttempt(provider)

     

       77
       77
       +
       	if canAttempt || err == nil {

     

       78
       78
       +
       		t.Fatal("Circuit should be open after threshold failures")

     

       79
       79
       +
       	}

     

       80
       80
       +
       

     

       81
       81
       +
       	// Wait for the open duration to pass

     

       82
       82
       +
       	time.Sleep(cb.openDuration + 5*time.Millisecond)

     

       83
       83
       +
       

     

       84
       84
       +
       	// Circuit should transition to half-open and allow attempt

     

       85
       85
       +
       	canAttempt, err = cb.canAttempt(provider)

     

       86
       86
       +
       	if !canAttempt {

     

       87
       87
       +
       		t.Error("Circuit breaker should transition to half-open after timeout")

     

       88
       88
       +
       	}

     

       89
       89
       +
       	if err != nil {

     

       90
       90
       +
       		t.Errorf("canAttempt() should not return error in half-open state, got: %v", err)

     

       91
       91
       +
       	}

     

       92
       92
       +
       }

     

       93
       93
       +
       

     

       94
       94
       +
       func TestCircuitBreaker_ClosesOnSuccessAfterHalfOpen(t *testing.T) {

     

       95
       95
       +
       	cb := newCircuitBreaker()

     

       96
       96
       +
       	cb.openDuration = 10 * time.Millisecond

     

       97
       97
       +
       	provider := "test-provider"

     

       98
       98
       +
       	testErr := errors.New("test error")

     

       99
       99
       +
       

     

       100
       100
       +
       	// Open the circuit

     

       101
       101
       +
       	for i := 0; i < cb.failureThreshold; i++ {

     

       102
       102
       +
       		cb.recordFailure(provider, testErr)

     

       103
       103
       +
       	}

     

       104
       104
       +
       

     

       105
       105
       +
       	// Wait for half-open

     

       106
       106
       +
       	time.Sleep(cb.openDuration + 5*time.Millisecond)

     

       107
       107
       +
       

     

       108
       108
       +
       	// Verify we can attempt

     

       109
       109
       +
       	canAttempt, _ := cb.canAttempt(provider)

     

       110
       110
       +
       	if !canAttempt {

     

       111
       111
       +
       		t.Fatal("Circuit should be half-open")

     

       112
       112
       +
       	}

     

       113
       113
       +
       

     

       114
       114
       +
       	// Record a success

     

       115
       115
       +
       	cb.recordSuccess(provider)

     

       116
       116
       +
       

     

       117
       117
       +
       	// Circuit should now be closed

     

       118
       118
       +
       	cb.mu.RLock()

     

       119
       119
       +
       	state := cb.getState(provider)

     

       120
       120
       +
       	cb.mu.RUnlock()

     

       121
       121
       +
       

     

       122
       122
       +
       	if state != stateClosed {

     

       123
       123
       +
       		t.Errorf("Circuit should be closed after success in half-open state, got state: %v", state)

     

       124
       124
       +
       	}

     

       125
       125
       +
       

     

       126
       126
       +
       	// Should allow attempts without error

     

       127
       127
       +
       	canAttempt, err := cb.canAttempt(provider)

     

       128
       128
       +
       	if !canAttempt {

     

       129
       129
       +
       		t.Error("Circuit should be closed and allow attempts")

     

       130
       130
       +
       	}

     

       131
       131
       +
       	if err != nil {

     

       132
       132
       +
       		t.Errorf("canAttempt() should not return error when closed, got: %v", err)

     

       133
       133
       +
       	}

     

       134
       134
       +
       }

     

       135
       135
       +
       

     

       136
       136
       +
       func TestCircuitBreaker_SuccessResetsFailureCount(t *testing.T) {

     

       137
       137
       +
       	cb := newCircuitBreaker()

     

       138
       138
       +
       	provider := "test-provider"

     

       139
       139
       +
       	testErr := errors.New("test error")

     

       140
       140
       +
       

     

       141
       141
       +
       	// Record some failures (but below threshold)

     

       142
       142
       +
       	for i := 0; i < cb.failureThreshold-1; i++ {

     

       143
       143
       +
       		cb.recordFailure(provider, testErr)

     

       144
       144
       +
       	}

     

       145
       145
       +
       

     

       146
       146
       +
       	// Verify failure count

     

       147
       147
       +
       	cb.mu.RLock()

     

       148
       148
       +
       	failCount := cb.failures[provider]

     

       149
       149
       +
       	cb.mu.RUnlock()

     

       150
       150
       +
       	if failCount != cb.failureThreshold-1 {

     

       151
       151
       +
       		t.Errorf("Expected %d failures, got %d", cb.failureThreshold-1, failCount)

     

       152
       152
       +
       	}

     

       153
       153
       +
       

     

       154
       154
       +
       	// Record a success

     

       155
       155
       +
       	cb.recordSuccess(provider)

     

       156
       156
       +
       

     

       157
       157
       +
       	// Failure count should be reset

     

       158
       158
       +
       	cb.mu.RLock()

     

       159
       159
       +
       	failCount = cb.failures[provider]

     

       160
       160
       +
       	cb.mu.RUnlock()

     

       161
       161
       +
       	if failCount != 0 {

     

       162
       162
       +
       		t.Errorf("Expected 0 failures after success, got %d", failCount)

     

       163
       163
       +
       	}

     

       164
       164
       +
       }

     

       165
       165
       +
       

     

       166
       166
       +
       func TestCircuitBreaker_IndependentProviders(t *testing.T) {

     

       167
       167
       +
       	cb := newCircuitBreaker()

     

       168
       168
       +
       	provider1 := "provider-1"

     

       169
       169
       +
       	provider2 := "provider-2"

     

       170
       170
       +
       	testErr := errors.New("test error")

     

       171
       171
       +
       

     

       172
       172
       +
       	// Open circuit for provider1

     

       173
       173
       +
       	for i := 0; i < cb.failureThreshold; i++ {

     

       174
       174
       +
       		cb.recordFailure(provider1, testErr)

     

       175
       175
       +
       	}

     

       176
       176
       +
       

     

       177
       177
       +
       	// Provider1 should be open

     

       178
       178
       +
       	canAttempt1, err1 := cb.canAttempt(provider1)

     

       179
       179
       +
       	if canAttempt1 || err1 == nil {

     

       180
       180
       +
       		t.Error("Provider1 circuit should be open")

     

       181
       181
       +
       	}

     

       182
       182
       +
       

     

       183
       183
       +
       	// Provider2 should still be closed

     

       184
       184
       +
       	canAttempt2, err2 := cb.canAttempt(provider2)

     

       185
       185
       +
       	if !canAttempt2 {

     

       186
       186
       +
       		t.Error("Provider2 circuit should be closed")

     

       187
       187
       +
       	}

     

       188
       188
       +
       	if err2 != nil {

     

       189
       189
       +
       		t.Errorf("Provider2 canAttempt() should not return error, got: %v", err2)

     

       190
       190
       +
       	}

     

       191
       191
       +
       }

     

       192
       192
       +
       

     

       193
       193
       +
       func TestCircuitBreaker_ConcurrentAccess(t *testing.T) {

     

       194
       194
       +
       	cb := newCircuitBreaker()

     

       195
       195
       +
       	provider := "test-provider"

     

       196
       196
       +
       	testErr := errors.New("test error")

     

       197
       197
       +
       

     

       198
       198
       +
       	// Number of concurrent goroutines

     

       199
       199
       +
       	numGoroutines := 100

     

       200
       200
       +
       	var wg sync.WaitGroup

     

       201
       201
       +
       	wg.Add(numGoroutines)

     

       202
       202
       +
       

     

       203
       203
       +
       	// Concurrently record failures and check state

     

       204
       204
       +
       	for i := 0; i < numGoroutines; i++ {

     

       205
       205
       +
       		go func(idx int) {

     

       206
       206
       +
       			defer wg.Done()

     

       207
       207
       +
       

     

       208
       208
       +
       			// Mix of operations

     

       209
       209
       +
       			if idx%3 == 0 {

     

       210
       210
       +
       				cb.recordFailure(provider, testErr)

     

       211
       211
       +
       			} else if idx%3 == 1 {

     

       212
       212
       +
       				cb.recordSuccess(provider)

     

       213
       213
       +
       			} else {

     

       214
       214
       +
       				_, _ = cb.canAttempt(provider)

     

       215
       215
       +
       			}

     

       216
       216
       +
       		}(i)

     

       217
       217
       +
       	}

     

       218
       218
       +
       

     

       219
       219
       +
       	wg.Wait()

     

       220
       220
       +
       

     

       221
       221
       +
       	// No panic or race conditions should occur

     

       222
       222
       +
       	// Final state check - just ensure we can call canAttempt

     

       223
       223
       +
       	_, _ = cb.canAttempt(provider)

     

       224
       224
       +
       }

     

       225
       225
       +
       

     

       226
       226
       +
       func TestCircuitBreaker_MultipleProvidersThreadSafety(t *testing.T) {

     

       227
       227
       +
       	cb := newCircuitBreaker()

     

       228
       228
       +
       	testErr := errors.New("test error")

     

       229
       229
       +
       	numProviders := 10

     

       230
       230
       +
       	numOpsPerProvider := 100

     

       231
       231
       +
       

     

       232
       232
       +
       	var wg sync.WaitGroup

     

       233
       233
       +
       	wg.Add(numProviders)

     

       234
       234
       +
       

     

       235
       235
       +
       	// Concurrent operations on different providers

     

       236
       236
       +
       	for i := 0; i < numProviders; i++ {

     

       237
       237
       +
       		go func(providerID int) {

     

       238
       238
       +
       			defer wg.Done()

     

       239
       239
       +
       			provider := "provider-" + string(rune('0'+providerID))

     

       240
       240
       +
       

     

       241
       241
       +
       			for j := 0; j < numOpsPerProvider; j++ {

     

       242
       242
       +
       				switch j % 4 {

     

       243
       243
       +
       				case 0:

     

       244
       244
       +
       					cb.recordFailure(provider, testErr)

     

       245
       245
       +
       				case 1:

     

       246
       246
       +
       					cb.recordSuccess(provider)

     

       247
       247
       +
       				case 2:

     

       248
       248
       +
       					_, _ = cb.canAttempt(provider)

     

       249
       249
       +
       				case 3:

     

       250
       250
       +
       					// Read state

     

       251
       251
       +
       					cb.mu.RLock()

     

       252
       252
       +
       					_ = cb.getState(provider)

     

       253
       253
       +
       					cb.mu.RUnlock()

     

       254
       254
       +
       				}

     

       255
       255
       +
       			}

     

       256
       256
       +
       		}(i)

     

       257
       257
       +
       	}

     

       258
       258
       +
       

     

       259
       259
       +
       	wg.Wait()

     

       260
       260
       +
       

     

       261
       261
       +
       	// Verify all providers are accessible without panic

     

       262
       262
       +
       	for i := 0; i < numProviders; i++ {

     

       263
       263
       +
       		provider := "provider-" + string(rune('0'+i))

     

       264
       264
       +
       		_, _ = cb.canAttempt(provider)

     

       265
       265
       +
       	}

     

       266
       266
       +
       }

     

       267
       267
       +
       

     

       268
       268
       +
       func TestCircuitBreaker_StateTransitions(t *testing.T) {

     

       269
       269
       +
       	cb := newCircuitBreaker()

     

       270
       270
       +
       	cb.openDuration = 10 * time.Millisecond

     

       271
       271
       +
       	provider := "test-provider"

     

       272
       272
       +
       	testErr := errors.New("test error")

     

       273
       273
       +
       

     

       274
       274
       +
       	// Initial state: closed

     

       275
       275
       +
       	cb.mu.RLock()

     

       276
       276
       +
       	if cb.getState(provider) != stateClosed {

     

       277
       277
       +
       		t.Error("Initial state should be closed")

     

       278
       278
       +
       	}

     

       279
       279
       +
       	cb.mu.RUnlock()

     

       280
       280
       +
       

     

       281
       281
       +
       	// Transition to open

     

       282
       282
       +
       	for i := 0; i < cb.failureThreshold; i++ {

     

       283
       283
       +
       		cb.recordFailure(provider, testErr)

     

       284
       284
       +
       	}

     

       285
       285
       +
       

     

       286
       286
       +
       	cb.mu.RLock()

     

       287
       287
       +
       	if cb.getState(provider) != stateOpen {

     

       288
       288
       +
       		t.Error("State should be open after threshold failures")

     

       289
       289
       +
       	}

     

       290
       290
       +
       	cb.mu.RUnlock()

     

       291
       291
       +
       

     

       292
       292
       +
       	// Wait for half-open transition

     

       293
       293
       +
       	time.Sleep(cb.openDuration + 5*time.Millisecond)

     

       294
       294
       +
       	_, _ = cb.canAttempt(provider) // Trigger state check

     

       295
       295
       +
       

     

       296
       296
       +
       	cb.mu.RLock()

     

       297
       297
       +
       	state := cb.getState(provider)

     

       298
       298
       +
       	cb.mu.RUnlock()

     

       299
       299
       +
       	if state != stateHalfOpen {

     

       300
       300
       +
       		t.Errorf("State should be half-open after timeout, got: %v", state)

     

       301
       301
       +
       	}

     

       302
       302
       +
       

     

       303
       303
       +
       	// Transition back to closed

     

       304
       304
       +
       	cb.recordSuccess(provider)

     

       305
       305
       +
       

     

       306
       306
       +
       	cb.mu.RLock()

     

       307
       307
       +
       	if cb.getState(provider) != stateClosed {

     

       308
       308
       +
       		t.Error("State should be closed after success in half-open")

     

       309
       309
       +
       	}

     

       310
       310
       +
       	cb.mu.RUnlock()

     

       311
       311
       +
       }

     

       312
       312
       +
       

     

       313
       313
       +
       func TestCircuitBreaker_ErrorMessage(t *testing.T) {

     

       314
       314
       +
       	cb := newCircuitBreaker()

     

       315
       315
       +
       	provider := "test-provider"

     

       316
       316
       +
       	testErr := errors.New("test error")

     

       317
       317
       +
       

     

       318
       318
       +
       	// Open the circuit

     

       319
       319
       +
       	for i := 0; i < cb.failureThreshold; i++ {

     

       320
       320
       +
       		cb.recordFailure(provider, testErr)

     

       321
       321
       +
       	}

     

       322
       322
       +
       

     

       323
       323
       +
       	// Check error message contains useful information

     

       324
       324
       +
       	_, err := cb.canAttempt(provider)

     

       325
       325
       +
       	if err == nil {

     

       326
       326
       +
       		t.Fatal("Expected error when circuit is open")

     

       327
       327
       +
       	}

     

       328
       328
       +
       

     

       329
       329
       +
       	errMsg := err.Error()

     

       330
       330
       +
       	if !contains(errMsg, "circuit breaker open") {

     

       331
       331
       +
       		t.Errorf("Error message should mention circuit breaker, got: %s", errMsg)

     

       332
       332
       +
       	}

     

       333
       333
       +
       	if !contains(errMsg, provider) {

     

       334
       334
       +
       		t.Errorf("Error message should contain provider name, got: %s", errMsg)

     

       335
       335
       +
       	}

     

       336
       336
       +
       }

     

       337
       337
       +
       

     

       338
       338
       +
       func TestCircuitBreaker_HalfOpenFailureReopens(t *testing.T) {

     

       339
       339
       +
       	cb := newCircuitBreaker()

     

       340
       340
       +
       	cb.openDuration = 10 * time.Millisecond

     

       341
       341
       +
       	provider := "test-provider"

     

       342
       342
       +
       	testErr := errors.New("test error")

     

       343
       343
       +
       

     

       344
       344
       +
       	// Open the circuit

     

       345
       345
       +
       	for i := 0; i < cb.failureThreshold; i++ {

     

       346
       346
       +
       		cb.recordFailure(provider, testErr)

     

       347
       347
       +
       	}

     

       348
       348
       +
       

     

       349
       349
       +
       	// Wait for half-open

     

       350
       350
       +
       	time.Sleep(cb.openDuration + 5*time.Millisecond)

     

       351
       351
       +
       	_, _ = cb.canAttempt(provider)

     

       352
       352
       +
       

     

       353
       353
       +
       	// Record another failure in half-open state

     

       354
       354
       +
       	cb.recordFailure(provider, testErr)

     

       355
       355
       +
       

     

       356
       356
       +
       	// Circuit should be open again (failure count incremented)

     

       357
       357
       +
       	cb.mu.RLock()

     

       358
       358
       +
       	failCount := cb.failures[provider]

     

       359
       359
       +
       	cb.mu.RUnlock()

     

       360
       360
       +
       

     

       361
       361
       +
       	if failCount < cb.failureThreshold {

     

       362
       362
       +
       		t.Errorf("Expected failure count >= %d after half-open failure, got: %d", cb.failureThreshold, failCount)

     

       363
       363
       +
       	}

     

       364
       364
       +
       }

     

       365
       365
       +
       

     

       366
       366
       +
       func TestCircuitBreaker_CustomThresholdAndDuration(t *testing.T) {

     

       367
       367
       +
       	cb := &circuitBreaker{

     

       368
       368
       +
       		failureThreshold: 5,

     

       369
       369
       +
       		openDuration:     20 * time.Millisecond,

     

       370
       370
       +
       		failures:         make(map[string]int),

     

       371
       371
       +
       		lastFailure:      make(map[string]time.Time),

     

       372
       372
       +
       		state:            make(map[string]circuitState),

     

       373
       373
       +
       		lastStateLog:     make(map[string]time.Time),

     

       374
       374
       +
       	}

     

       375
       375
       +
       

     

       376
       376
       +
       	provider := "test-provider"

     

       377
       377
       +
       	testErr := errors.New("test error")

     

       378
       378
       +
       

     

       379
       379
       +
       	// Should not open until 5 failures

     

       380
       380
       +
       	for i := 0; i < 4; i++ {

     

       381
       381
       +
       		cb.recordFailure(provider, testErr)

     

       382
       382
       +
       	}

     

       383
       383
       +
       

     

       384
       384
       +
       	canAttempt, err := cb.canAttempt(provider)

     

       385
       385
       +
       	if !canAttempt || err != nil {

     

       386
       386
       +
       		t.Error("Circuit should remain closed before threshold")

     

       387
       387
       +
       	}

     

       388
       388
       +
       

     

       389
       389
       +
       	// 5th failure should open it

     

       390
       390
       +
       	cb.recordFailure(provider, testErr)

     

       391
       391
       +
       

     

       392
       392
       +
       	canAttempt, err = cb.canAttempt(provider)

     

       393
       393
       +
       	if canAttempt || err == nil {

     

       394
       394
       +
       		t.Error("Circuit should be open after 5 failures")

     

       395
       395
       +
       	}

     

       396
       396
       +
       

     

       397
       397
       +
       	// Should not transition to half-open before 20ms

     

       398
       398
       +
       	time.Sleep(10 * time.Millisecond)

     

       399
       399
       +
       	canAttempt, _ = cb.canAttempt(provider)

     

       400
       400
       +
       	if canAttempt {

     

       401
       401
       +
       		t.Error("Circuit should still be open before timeout")

     

       402
       402
       +
       	}

     

       403
       403
       +
       

     

       404
       404
       +
       	// Should transition after 20ms

     

       405
       405
       +
       	time.Sleep(15 * time.Millisecond)

     

       406
       406
       +
       	canAttempt, _ = cb.canAttempt(provider)

     

       407
       407
       +
       	if !canAttempt {

     

       408
       408
       +
       		t.Error("Circuit should be half-open after timeout")

     

       409
       409
       +
       	}

     

       410
       410
       +
       }

+39

internal/core/blueskypost/interfaces.go

···

       1
       1
       +
       package blueskypost

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"time"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       // Service defines the interface for Bluesky post resolution and caching.

     

       9
       9
       +
       // It orchestrates URL parsing, cache lookups, API fetching, and circuit breaking.

     

       10
       10
       +
       type Service interface {

     

       11
       11
       +
       	// ResolvePost fetches and resolves a Bluesky post by AT-URI.

     

       12
       12
       +
       	// It checks the cache first, then fetches from public.api.bsky.app if needed.

     

       13
       13
       +
       	// Returns BlueskyPostResult with Unavailable=true if the post cannot be resolved.

     

       14
       14
       +
       	ResolvePost(ctx context.Context, atURI string) (*BlueskyPostResult, error)

     

       15
       15
       +
       

     

       16
       16
       +
       	// ParseBlueskyURL converts a bsky.app URL to an AT-URI.

     

       17
       17
       +
       	// Example: https://bsky.app/profile/user.bsky.social/post/abc123

     

       18
       18
       +
       	//       -> at://did:plc:xxx/app.bsky.feed.post/abc123

     

       19
       19
       +
       	// Returns error if the URL is invalid or handle resolution fails.

     

       20
       20
       +
       	ParseBlueskyURL(ctx context.Context, url string) (string, error)

     

       21
       21
       +
       

     

       22
       22
       +
       	// IsBlueskyURL checks if a URL is a valid bsky.app post URL.

     

       23
       23
       +
       	// Returns true for URLs matching https://bsky.app/profile/{handle}/post/{rkey}

     

       24
       24
       +
       	IsBlueskyURL(url string) bool

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       // Repository defines the interface for Bluesky post cache persistence.

     

       28
       28
       +
       // This follows the same pattern as the unfurl cache repository.

     

       29
       29
       +
       type Repository interface {

     

       30
       30
       +
       	// Get retrieves a cached Bluesky post result for the given AT-URI.

     

       31
       31
       +
       	// Returns ErrCacheMiss if not found or expired (not an error condition).

     

       32
       32
       +
       	// Returns error only on database failures.

     

       33
       33
       +
       	Get(ctx context.Context, atURI string) (*BlueskyPostResult, error)

     

       34
       34
       +
       

     

       35
       35
       +
       	// Set stores a Bluesky post result in the cache with the specified TTL.

     

       36
       36
       +
       	// If an entry already exists for the AT-URI, it will be updated.

     

       37
       37
       +
       	// The expires_at is calculated as NOW() + ttl.

     

       38
       38
       +
       	Set(ctx context.Context, atURI string, result *BlueskyPostResult, ttl time.Duration) error

     

       39
       39
       +
       }

+131

internal/core/blueskypost/repository.go

···

       1
       1
       +
       package blueskypost

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"database/sql"

     

       6
       6
       +
       	"encoding/json"

     

       7
       7
       +
       	"errors"

     

       8
       8
       +
       	"fmt"

     

       9
       9
       +
       	"strings"

     

       10
       10
       +
       	"time"

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       // ErrCacheMiss is returned when a cache entry is not found or has expired

     

       14
       14
       +
       var ErrCacheMiss = errors.New("cache miss")

     

       15
       15
       +
       

     

       16
       16
       +
       type postgresBlueskyPostRepo struct {

     

       17
       17
       +
       	db *sql.DB

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       // NewRepository creates a new PostgreSQL Bluesky post cache repository

     

       21
       21
       +
       func NewRepository(db *sql.DB) Repository {

     

       22
       22
       +
       	if db == nil {

     

       23
       23
       +
       		panic("blueskypost: db cannot be nil")

     

       24
       24
       +
       	}

     

       25
       25
       +
       	return &postgresBlueskyPostRepo{db: db}

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       // Get retrieves a cached Bluesky post result for the given AT-URI.

     

       29
       29
       +
       // Returns ErrCacheMiss if not found or expired.

     

       30
       30
       +
       // Returns error only on database failures.

     

       31
       31
       +
       func (r *postgresBlueskyPostRepo) Get(ctx context.Context, atURI string) (*BlueskyPostResult, error) {

     

       32
       32
       +
       	query := `

     

       33
       33
       +
       		SELECT metadata

     

       34
       34
       +
       		FROM bluesky_post_cache

     

       35
       35
       +
       		WHERE at_uri = $1 AND expires_at > NOW()

     

       36
       36
       +
       	`

     

       37
       37
       +
       

     

       38
       38
       +
       	var metadataJSON []byte

     

       39
       39
       +
       

     

       40
       40
       +
       	err := r.db.QueryRowContext(ctx, query, atURI).Scan(&metadataJSON)

     

       41
       41
       +
       	if err == sql.ErrNoRows {

     

       42
       42
       +
       		// Not found or expired is a cache miss

     

       43
       43
       +
       		return nil, ErrCacheMiss

     

       44
       44
       +
       	}

     

       45
       45
       +
       	if err != nil {

     

       46
       46
       +
       		return nil, fmt.Errorf("failed to get bluesky post cache entry: %w", err)

     

       47
       47
       +
       	}

     

       48
       48
       +
       

     

       49
       49
       +
       	// Unmarshal metadata JSONB to BlueskyPostResult

     

       50
       50
       +
       	var result BlueskyPostResult

     

       51
       51
       +
       	if err := json.Unmarshal(metadataJSON, &result); err != nil {

     

       52
       52
       +
       		return nil, fmt.Errorf("failed to unmarshal metadata: %w", err)

     

       53
       53
       +
       	}

     

       54
       54
       +
       

     

       55
       55
       +
       	return &result, nil

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       // Set stores a Bluesky post result in the cache with the specified TTL.

     

       59
       59
       +
       // If an entry already exists for the AT-URI, it will be updated.

     

       60
       60
       +
       // The expires_at is calculated as NOW() + ttl.

     

       61
       61
       +
       func (r *postgresBlueskyPostRepo) Set(ctx context.Context, atURI string, result *BlueskyPostResult, ttl time.Duration) error {

     

       62
       62
       +
       	// Validate AT-URI format to prevent cache pollution

     

       63
       63
       +
       	if err := validateATURI(atURI); err != nil {

     

       64
       64
       +
       		return err

     

       65
       65
       +
       	}

     

       66
       66
       +
       

     

       67
       67
       +
       	// Marshal BlueskyPostResult to JSON for metadata column

     

       68
       68
       +
       	metadataJSON, err := json.Marshal(result)

     

       69
       69
       +
       	if err != nil {

     

       70
       70
       +
       		return fmt.Errorf("failed to marshal metadata: %w", err)

     

       71
       71
       +
       	}

     

       72
       72
       +
       

     

       73
       73
       +
       	// Convert Go duration to PostgreSQL interval string

     

       74
       74
       +
       	// e.g., "1 hour", "24 hours", "7 days"

     

       75
       75
       +
       	intervalStr := formatInterval(ttl)

     

       76
       76
       +
       

     

       77
       77
       +
       	query := `

     

       78
       78
       +
       		INSERT INTO bluesky_post_cache (at_uri, metadata, expires_at)

     

       79
       79
       +
       		VALUES ($1, $2, NOW() + $3::interval)

     

       80
       80
       +
       		ON CONFLICT (at_uri) DO UPDATE

     

       81
       81
       +
       		SET metadata = EXCLUDED.metadata,

     

       82
       82
       +
       		    expires_at = EXCLUDED.expires_at,

     

       83
       83
       +
       		    fetched_at = NOW()

     

       84
       84
       +
       	`

     

       85
       85
       +
       

     

       86
       86
       +
       	_, err = r.db.ExecContext(ctx, query, atURI, metadataJSON, intervalStr)

     

       87
       87
       +
       	if err != nil {

     

       88
       88
       +
       		return fmt.Errorf("failed to insert/update bluesky post cache entry: %w", err)

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	return nil

     

       92
       92
       +
       }

     

       93
       93
       +
       

     

       94
       94
       +
       // formatInterval converts a Go duration to a PostgreSQL interval string

     

       95
       95
       +
       // PostgreSQL accepts intervals like "1 hour", "24 hours", "7 days"

     

       96
       96
       +
       func formatInterval(d time.Duration) string {

     

       97
       97
       +
       	seconds := int64(d.Seconds())

     

       98
       98
       +
       

     

       99
       99
       +
       	// Convert to appropriate unit for readability

     

       100
       100
       +
       	switch {

     

       101
       101
       +
       	case seconds >= 86400: // >= 1 day

     

       102
       102
       +
       		days := seconds / 86400

     

       103
       103
       +
       		return fmt.Sprintf("%d days", days)

     

       104
       104
       +
       	case seconds >= 3600: // >= 1 hour

     

       105
       105
       +
       		hours := seconds / 3600

     

       106
       106
       +
       		return fmt.Sprintf("%d hours", hours)

     

       107
       107
       +
       	case seconds >= 60: // >= 1 minute

     

       108
       108
       +
       		minutes := seconds / 60

     

       109
       109
       +
       		return fmt.Sprintf("%d minutes", minutes)

     

       110
       110
       +
       	default:

     

       111
       111
       +
       		return fmt.Sprintf("%d seconds", seconds)

     

       112
       112
       +
       	}

     

       113
       113
       +
       }

     

       114
       114
       +
       

     

       115
       115
       +
       // validateATURI validates that a string is a properly formatted AT-URI for a Bluesky post.

     

       116
       116
       +
       // AT-URIs for Bluesky posts must:

     

       117
       117
       +
       //   - Start with "at://"

     

       118
       118
       +
       //   - Contain "/app.bsky.feed.post/"

     

       119
       119
       +
       //

     

       120
       120
       +
       // Example valid URI: at://did:plc:abc123/app.bsky.feed.post/xyz789

     

       121
       121
       +
       func validateATURI(atURI string) error {

     

       122
       122
       +
       	if !strings.HasPrefix(atURI, "at://") {

     

       123
       123
       +
       		return fmt.Errorf("invalid AT-URI: must start with 'at://'")

     

       124
       124
       +
       	}

     

       125
       125
       +
       

     

       126
       126
       +
       	if !strings.Contains(atURI, "/app.bsky.feed.post/") {

     

       127
       127
       +
       		return fmt.Errorf("invalid AT-URI: must contain '/app.bsky.feed.post/'")

     

       128
       128
       +
       	}

     

       129
       129
       +
       

     

       130
       130
       +
       	return nil

     

       131
       131
       +
       }

+48

internal/core/blueskypost/repository_test.go

···

       1
       1
       +
       package blueskypost

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"testing"

     

       5
       5
       +
       )

     

       6
       6
       +
       

     

       7
       7
       +
       func TestValidateATURI(t *testing.T) {

     

       8
       8
       +
       	tests := []struct {

     

       9
       9
       +
       		name    string

     

       10
       10
       +
       		atURI   string

     

       11
       11
       +
       		wantErr bool

     

       12
       12
       +
       	}{

     

       13
       13
       +
       		{

     

       14
       14
       +
       			name:    "valid AT-URI",

     

       15
       15
       +
       			atURI:   "at://did:plc:abc123/app.bsky.feed.post/xyz789",

     

       16
       16
       +
       			wantErr: false,

     

       17
       17
       +
       		},

     

       18
       18
       +
       		{

     

       19
       19
       +
       			name:    "missing at:// prefix",

     

       20
       20
       +
       			atURI:   "did:plc:abc123/app.bsky.feed.post/xyz789",

     

       21
       21
       +
       			wantErr: true,

     

       22
       22
       +
       		},

     

       23
       23
       +
       		{

     

       24
       24
       +
       			name:    "missing /app.bsky.feed.post/",

     

       25
       25
       +
       			atURI:   "at://did:plc:abc123/some.other.collection/xyz789",

     

       26
       26
       +
       			wantErr: true,

     

       27
       27
       +
       		},

     

       28
       28
       +
       		{

     

       29
       29
       +
       			name:    "empty string",

     

       30
       30
       +
       			atURI:   "",

     

       31
       31
       +
       			wantErr: true,

     

       32
       32
       +
       		},

     

       33
       33
       +
       		{

     

       34
       34
       +
       			name:    "http URL instead of AT-URI",

     

       35
       35
       +
       			atURI:   "https://bsky.app/profile/user.bsky.social/post/abc123",

     

       36
       36
       +
       			wantErr: true,

     

       37
       37
       +
       		},

     

       38
       38
       +
       	}

     

       39
       39
       +
       

     

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

     

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

     

       42
       42
       +
       			err := validateATURI(tt.atURI)

     

       43
       43
       +
       			if (err != nil) != tt.wantErr {

     

       44
       44
       +
       				t.Errorf("validateATURI() error = %v, wantErr %v", err, tt.wantErr)

     

       45
       45
       +
       			}

     

       46
       46
       +
       		})

     

       47
       47
       +
       	}

     

       48
       48
       +
       }

+101

internal/core/blueskypost/url_parser.go

···

       1
       1
       +
       package blueskypost

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/identity"

     

       5
       5
       +
       	"context"

     

       6
       6
       +
       	"fmt"

     

       7
       7
       +
       	"net/url"

     

       8
       8
       +
       	"regexp"

     

       9
       9
       +
       	"strings"

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       // blueskyPostURLPattern matches https://bsky.app/profile/{handle}/post/{rkey}

     

       13
       13
       +
       var blueskyPostURLPattern = regexp.MustCompile(`^https://bsky\.app/profile/([^/]+)/post/([^/]+)$`)

     

       14
       14
       +
       

     

       15
       15
       +
       // IsBlueskyURL checks if a URL is a valid bsky.app post URL.

     

       16
       16
       +
       // Returns true for URLs matching https://bsky.app/profile/{handle}/post/{rkey}

     

       17
       17
       +
       func IsBlueskyURL(urlStr string) bool {

     

       18
       18
       +
       	return blueskyPostURLPattern.MatchString(urlStr)

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       // ParseBlueskyURL converts a bsky.app URL to an AT-URI.

     

       22
       22
       +
       // Example: https://bsky.app/profile/user.bsky.social/post/abc123

     

       23
       23
       +
       //

     

       24
       24
       +
       //	-> at://did:plc:xxx/app.bsky.feed.post/abc123

     

       25
       25
       +
       //

     

       26
       26
       +
       // Returns error if the URL is invalid or handle resolution fails.

     

       27
       27
       +
       func ParseBlueskyURL(ctx context.Context, urlStr string, resolver identity.Resolver) (string, error) {

     

       28
       28
       +
       	// Parse and validate the URL

     

       29
       29
       +
       	parsedURL, err := url.Parse(urlStr)

     

       30
       30
       +
       	if err != nil {

     

       31
       31
       +
       		return "", fmt.Errorf("invalid URL: %w", err)

     

       32
       32
       +
       	}

     

       33
       33
       +
       

     

       34
       34
       +
       	// Validate URL scheme and host

     

       35
       35
       +
       	if parsedURL.Scheme != "https" {

     

       36
       36
       +
       		return "", fmt.Errorf("URL must use HTTPS scheme")

     

       37
       37
       +
       	}

     

       38
       38
       +
       	if parsedURL.Host != "bsky.app" {

     

       39
       39
       +
       		return "", fmt.Errorf("URL must be from bsky.app")

     

       40
       40
       +
       	}

     

       41
       41
       +
       

     

       42
       42
       +
       	// Extract handle and rkey using regex

     

       43
       43
       +
       	matches := blueskyPostURLPattern.FindStringSubmatch(urlStr)

     

       44
       44
       +
       	if matches == nil || len(matches) != 3 {

     

       45
       45
       +
       		return "", fmt.Errorf("invalid bsky.app URL format, expected: https://bsky.app/profile/{handle}/post/{rkey}")

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       48
       48
       +
       	handle := matches[1]

     

       49
       49
       +
       	rkey := matches[2]

     

       50
       50
       +
       

     

       51
       51
       +
       	// Validate handle and rkey are not empty

     

       52
       52
       +
       	if handle == "" || rkey == "" {

     

       53
       53
       +
       		return "", fmt.Errorf("handle and rkey cannot be empty")

     

       54
       54
       +
       	}

     

       55
       55
       +
       

     

       56
       56
       +
       	// Validate rkey format

     

       57
       57
       +
       	// TID format: base32-sortable timestamp IDs are typically 13 characters

     

       58
       58
       +
       	// Allow alphanumeric characters, reasonable length (3-20 chars to be permissive)

     

       59
       59
       +
       	if err := validateRkey(rkey); err != nil {

     

       60
       60
       +
       		return "", fmt.Errorf("invalid rkey: %w", err)

     

       61
       61
       +
       	}

     

       62
       62
       +
       

     

       63
       63
       +
       	// Resolve handle to DID

     

       64
       64
       +
       	// If the handle is already a DID (starts with "did:"), use it directly

     

       65
       65
       +
       	var did string

     

       66
       66
       +
       	if strings.HasPrefix(handle, "did:") {

     

       67
       67
       +
       		did = handle

     

       68
       68
       +
       	} else {

     

       69
       69
       +
       		// Resolve handle to DID using identity resolver

     

       70
       70
       +
       		resolvedDID, _, err := resolver.ResolveHandle(ctx, handle)

     

       71
       71
       +
       		if err != nil {

     

       72
       72
       +
       			return "", fmt.Errorf("failed to resolve handle %s: %w", handle, err)

     

       73
       73
       +
       		}

     

       74
       74
       +
       		did = resolvedDID

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	// Construct AT-URI

     

       78
       78
       +
       	// Format: at://{did}/app.bsky.feed.post/{rkey}

     

       79
       79
       +
       	atURI := fmt.Sprintf("at://%s/app.bsky.feed.post/%s", did, rkey)

     

       80
       80
       +
       

     

       81
       81
       +
       	return atURI, nil

     

       82
       82
       +
       }

     

       83
       83
       +
       

     

       84
       84
       +
       // rkeyPattern matches valid rkey formats (alphanumeric, typically base32 TID format)

     

       85
       85
       +
       var rkeyPattern = regexp.MustCompile(`^[a-zA-Z0-9]+$`)

     

       86
       86
       +
       

     

       87
       87
       +
       // validateRkey validates the rkey (record key) format.

     

       88
       88
       +
       // TIDs (Timestamp Identifiers) are typically 13 characters in base32-sortable format.

     

       89
       89
       +
       // We allow 3-20 characters to be permissive while preventing abuse.

     

       90
       90
       +
       func validateRkey(rkey string) error {

     

       91
       91
       +
       	if len(rkey) < 3 {

     

       92
       92
       +
       		return fmt.Errorf("rkey too short (minimum 3 characters)")

     

       93
       93
       +
       	}

     

       94
       94
       +
       	if len(rkey) > 20 {

     

       95
       95
       +
       		return fmt.Errorf("rkey too long (maximum 20 characters)")

     

       96
       96
       +
       	}

     

       97
       97
       +
       	if !rkeyPattern.MatchString(rkey) {

     

       98
       98
       +
       		return fmt.Errorf("rkey contains invalid characters (must be alphanumeric)")

     

       99
       99
       +
       	}

     

       100
       100
       +
       	return nil

     

       101
       101
       +
       }

+327

internal/core/blueskypost/url_parser_test.go

···

       1
       1
       +
       package blueskypost

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/identity"

     

       5
       5
       +
       	"context"

     

       6
       6
       +
       	"errors"

     

       7
       7
       +
       	"testing"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       // mockIdentityResolver implements identity.Resolver for testing

     

       11
       11
       +
       type mockIdentityResolver struct {

     

       12
       12
       +
       	handleToDID map[string]string

     

       13
       13
       +
       	err         error

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       func (m *mockIdentityResolver) ResolveHandle(ctx context.Context, handle string) (string, string, error) {

     

       17
       17
       +
       	if m.err != nil {

     

       18
       18
       +
       		return "", "", m.err

     

       19
       19
       +
       	}

     

       20
       20
       +
       	did, ok := m.handleToDID[handle]

     

       21
       21
       +
       	if !ok {

     

       22
       22
       +
       		return "", "", errors.New("handle not found")

     

       23
       23
       +
       	}

     

       24
       24
       +
       	return did, "", nil

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       func (m *mockIdentityResolver) Resolve(ctx context.Context, identifier string) (*identity.Identity, error) {

     

       28
       28
       +
       	if m.err != nil {

     

       29
       29
       +
       		return nil, m.err

     

       30
       30
       +
       	}

     

       31
       31
       +
       	did, _, err := m.ResolveHandle(ctx, identifier)

     

       32
       32
       +
       	if err != nil {

     

       33
       33
       +
       		return nil, err

     

       34
       34
       +
       	}

     

       35
       35
       +
       	return &identity.Identity{

     

       36
       36
       +
       		DID:    did,

     

       37
       37
       +
       		Handle: identifier,

     

       38
       38
       +
       	}, nil

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       func (m *mockIdentityResolver) ResolveDID(ctx context.Context, did string) (*identity.DIDDocument, error) {

     

       42
       42
       +
       	return nil, errors.New("not implemented")

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       func (m *mockIdentityResolver) Purge(ctx context.Context, identifier string) error {

     

       46
       46
       +
       	return nil

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       func TestIsBlueskyURL(t *testing.T) {

     

       50
       50
       +
       	tests := []struct {

     

       51
       51
       +
       		name     string

     

       52
       52
       +
       		url      string

     

       53
       53
       +
       		expected bool

     

       54
       54
       +
       	}{

     

       55
       55
       +
       		{

     

       56
       56
       +
       			name:     "valid bsky.app URL with handle",

     

       57
       57
       +
       			url:      "https://bsky.app/profile/user.bsky.social/post/abc123xyz",

     

       58
       58
       +
       			expected: true,

     

       59
       59
       +
       		},

     

       60
       60
       +
       		{

     

       61
       61
       +
       			name:     "valid bsky.app URL with DID",

     

       62
       62
       +
       			url:      "https://bsky.app/profile/did:plc:abc123/post/xyz789",

     

       63
       63
       +
       			expected: true,

     

       64
       64
       +
       		},

     

       65
       65
       +
       		{

     

       66
       66
       +
       			name:     "valid bsky.app URL with alphanumeric rkey",

     

       67
       67
       +
       			url:      "https://bsky.app/profile/alice.example/post/3k2j4h5g6f7d8s9a",

     

       68
       68
       +
       			expected: true,

     

       69
       69
       +
       		},

     

       70
       70
       +
       		{

     

       71
       71
       +
       			name:     "wrong domain",

     

       72
       72
       +
       			url:      "https://twitter.com/profile/user/post/abc123",

     

       73
       73
       +
       			expected: false,

     

       74
       74
       +
       		},

     

       75
       75
       +
       		{

     

       76
       76
       +
       			name:     "wrong path format - missing post",

     

       77
       77
       +
       			url:      "https://bsky.app/profile/user.bsky.social/abc123",

     

       78
       78
       +
       			expected: false,

     

       79
       79
       +
       		},

     

       80
       80
       +
       		{

     

       81
       81
       +
       			name:     "wrong path format - extra segments",

     

       82
       82
       +
       			url:      "https://bsky.app/profile/user.bsky.social/post/abc123/extra",

     

       83
       83
       +
       			expected: false,

     

       84
       84
       +
       		},

     

       85
       85
       +
       		{

     

       86
       86
       +
       			name:     "missing handle",

     

       87
       87
       +
       			url:      "https://bsky.app/profile//post/abc123",

     

       88
       88
       +
       			expected: false,

     

       89
       89
       +
       		},

     

       90
       90
       +
       		{

     

       91
       91
       +
       			name:     "missing rkey",

     

       92
       92
       +
       			url:      "https://bsky.app/profile/user.bsky.social/post/",

     

       93
       93
       +
       			expected: false,

     

       94
       94
       +
       		},

     

       95
       95
       +
       		{

     

       96
       96
       +
       			name:     "empty string",

     

       97
       97
       +
       			url:      "",

     

       98
       98
       +
       			expected: false,

     

       99
       99
       +
       		},

     

       100
       100
       +
       		{

     

       101
       101
       +
       			name:     "malformed URL",

     

       102
       102
       +
       			url:      "not-a-url",

     

       103
       103
       +
       			expected: false,

     

       104
       104
       +
       		},

     

       105
       105
       +
       		{

     

       106
       106
       +
       			name:     "http instead of https",

     

       107
       107
       +
       			url:      "http://bsky.app/profile/user.bsky.social/post/abc123",

     

       108
       108
       +
       			expected: false,

     

       109
       109
       +
       		},

     

       110
       110
       +
       		{

     

       111
       111
       +
       			name:     "AT-URI instead of bsky.app URL",

     

       112
       112
       +
       			url:      "at://did:plc:abc123/app.bsky.feed.post/xyz789",

     

       113
       113
       +
       			expected: false,

     

       114
       114
       +
       		},

     

       115
       115
       +
       	}

     

       116
       116
       +
       

     

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

     

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

     

       119
       119
       +
       			result := IsBlueskyURL(tt.url)

     

       120
       120
       +
       			if result != tt.expected {

     

       121
       121
       +
       				t.Errorf("IsBlueskyURL(%q) = %v, want %v", tt.url, result, tt.expected)

     

       122
       122
       +
       			}

     

       123
       123
       +
       		})

     

       124
       124
       +
       	}

     

       125
       125
       +
       }

     

       126
       126
       +
       

     

       127
       127
       +
       func TestParseBlueskyURL(t *testing.T) {

     

       128
       128
       +
       	ctx := context.Background()

     

       129
       129
       +
       

     

       130
       130
       +
       	tests := []struct {

     

       131
       131
       +
       		resolver    *mockIdentityResolver

     

       132
       132
       +
       		name        string

     

       133
       133
       +
       		url         string

     

       134
       134
       +
       		expectedURI string

     

       135
       135
       +
       		errContains string

     

       136
       136
       +
       		wantErr     bool

     

       137
       137
       +
       	}{

     

       138
       138
       +
       		{

     

       139
       139
       +
       			name: "valid URL with handle",

     

       140
       140
       +
       			url:  "https://bsky.app/profile/alice.bsky.social/post/abc123xyz",

     

       141
       141
       +
       			resolver: &mockIdentityResolver{

     

       142
       142
       +
       				handleToDID: map[string]string{

     

       143
       143
       +
       					"alice.bsky.social": "did:plc:alice123",

     

       144
       144
       +
       				},

     

       145
       145
       +
       			},

     

       146
       146
       +
       			expectedURI: "at://did:plc:alice123/app.bsky.feed.post/abc123xyz",

     

       147
       147
       +
       			wantErr:     false,

     

       148
       148
       +
       		},

     

       149
       149
       +
       		{

     

       150
       150
       +
       			name: "valid URL with DID (no resolution needed)",

     

       151
       151
       +
       			url:  "https://bsky.app/profile/did:plc:bob456/post/xyz789",

     

       152
       152
       +
       			resolver: &mockIdentityResolver{

     

       153
       153
       +
       				handleToDID: map[string]string{},

     

       154
       154
       +
       			},

     

       155
       155
       +
       			expectedURI: "at://did:plc:bob456/app.bsky.feed.post/xyz789",

     

       156
       156
       +
       			wantErr:     false,

     

       157
       157
       +
       		},

     

       158
       158
       +
       		{

     

       159
       159
       +
       			name: "handle resolution fails",

     

       160
       160
       +
       			url:  "https://bsky.app/profile/unknown.bsky.social/post/abc123",

     

       161
       161
       +
       			resolver: &mockIdentityResolver{

     

       162
       162
       +
       				handleToDID: map[string]string{},

     

       163
       163
       +
       			},

     

       164
       164
       +
       			wantErr:     true,

     

       165
       165
       +
       			errContains: "failed to resolve handle",

     

       166
       166
       +
       		},

     

       167
       167
       +
       		{

     

       168
       168
       +
       			name: "resolver returns error",

     

       169
       169
       +
       			url:  "https://bsky.app/profile/error.bsky.social/post/abc123",

     

       170
       170
       +
       			resolver: &mockIdentityResolver{

     

       171
       171
       +
       				err: errors.New("network error"),

     

       172
       172
       +
       			},

     

       173
       173
       +
       			wantErr:     true,

     

       174
       174
       +
       			errContains: "failed to resolve handle",

     

       175
       175
       +
       		},

     

       176
       176
       +
       		{

     

       177
       177
       +
       			name:        "invalid URL - wrong scheme",

     

       178
       178
       +
       			url:         "http://bsky.app/profile/alice.bsky.social/post/abc123",

     

       179
       179
       +
       			resolver:    &mockIdentityResolver{},

     

       180
       180
       +
       			wantErr:     true,

     

       181
       181
       +
       			errContains: "must use HTTPS scheme",

     

       182
       182
       +
       		},

     

       183
       183
       +
       		{

     

       184
       184
       +
       			name:        "invalid URL - wrong host",

     

       185
       185
       +
       			url:         "https://twitter.com/profile/alice/post/abc123",

     

       186
       186
       +
       			resolver:    &mockIdentityResolver{},

     

       187
       187
       +
       			wantErr:     true,

     

       188
       188
       +
       			errContains: "must be from bsky.app",

     

       189
       189
       +
       		},

     

       190
       190
       +
       		{

     

       191
       191
       +
       			name:        "invalid URL - wrong path format",

     

       192
       192
       +
       			url:         "https://bsky.app/feed/alice.bsky.social/post/abc123",

     

       193
       193
       +
       			resolver:    &mockIdentityResolver{},

     

       194
       194
       +
       			wantErr:     true,

     

       195
       195
       +
       			errContains: "invalid bsky.app URL format",

     

       196
       196
       +
       		},

     

       197
       197
       +
       		{

     

       198
       198
       +
       			name:        "invalid URL - missing rkey",

     

       199
       199
       +
       			url:         "https://bsky.app/profile/alice.bsky.social/post/",

     

       200
       200
       +
       			resolver:    &mockIdentityResolver{},

     

       201
       201
       +
       			wantErr:     true,

     

       202
       202
       +
       			errContains: "invalid bsky.app URL format",

     

       203
       203
       +
       		},

     

       204
       204
       +
       		{

     

       205
       205
       +
       			name:        "invalid URL - empty string",

     

       206
       206
       +
       			url:         "",

     

       207
       207
       +
       			resolver:    &mockIdentityResolver{},

     

       208
       208
       +
       			wantErr:     true,

     

       209
       209
       +
       			errContains: "HTTPS scheme",

     

       210
       210
       +
       		},

     

       211
       211
       +
       		{

     

       212
       212
       +
       			name:        "malformed URL",

     

       213
       213
       +
       			url:         "not-a-valid-url",

     

       214
       214
       +
       			resolver:    &mockIdentityResolver{},

     

       215
       215
       +
       			wantErr:     true,

     

       216
       216
       +
       			errContains: "HTTPS scheme",

     

       217
       217
       +
       		},

     

       218
       218
       +
       		{

     

       219
       219
       +
       			name: "valid URL with complex handle",

     

       220
       220
       +
       			url:  "https://bsky.app/profile/user.subdomain.example.com/post/3k2j4h5g",

     

       221
       221
       +
       			resolver: &mockIdentityResolver{

     

       222
       222
       +
       				handleToDID: map[string]string{

     

       223
       223
       +
       					"user.subdomain.example.com": "did:plc:complex789",

     

       224
       224
       +
       				},

     

       225
       225
       +
       			},

     

       226
       226
       +
       			expectedURI: "at://did:plc:complex789/app.bsky.feed.post/3k2j4h5g",

     

       227
       227
       +
       			wantErr:     false,

     

       228
       228
       +
       		},

     

       229
       229
       +
       	}

     

       230
       230
       +
       

     

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

     

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

     

       233
       233
       +
       			result, err := ParseBlueskyURL(ctx, tt.url, tt.resolver)

     

       234
       234
       +
       

     

       235
       235
       +
       			if tt.wantErr {

     

       236
       236
       +
       				if err == nil {

     

       237
       237
       +
       					t.Errorf("ParseBlueskyURL() expected error containing %q, got nil", tt.errContains)

     

       238
       238
       +
       					return

     

       239
       239
       +
       				}

     

       240
       240
       +
       				if tt.errContains != "" && !contains(err.Error(), tt.errContains) {

     

       241
       241
       +
       					t.Errorf("ParseBlueskyURL() error = %q, expected to contain %q", err.Error(), tt.errContains)

     

       242
       242
       +
       				}

     

       243
       243
       +
       				return

     

       244
       244
       +
       			}

     

       245
       245
       +
       

     

       246
       246
       +
       			if err != nil {

     

       247
       247
       +
       				t.Errorf("ParseBlueskyURL() unexpected error: %v", err)

     

       248
       248
       +
       				return

     

       249
       249
       +
       			}

     

       250
       250
       +
       

     

       251
       251
       +
       			if result != tt.expectedURI {

     

       252
       252
       +
       				t.Errorf("ParseBlueskyURL() = %q, want %q", result, tt.expectedURI)

     

       253
       253
       +
       			}

     

       254
       254
       +
       		})

     

       255
       255
       +
       	}

     

       256
       256
       +
       }

     

       257
       257
       +
       

     

       258
       258
       +
       func TestParseBlueskyURL_EdgeCases(t *testing.T) {

     

       259
       259
       +
       	ctx := context.Background()

     

       260
       260
       +
       

     

       261
       261
       +
       	t.Run("rkey with special characters should still match pattern", func(t *testing.T) {

     

       262
       262
       +
       		// Bluesky rkeys are base32-like and should be alphanumeric

     

       263
       263
       +
       		// but let's test that our regex handles them

     

       264
       264
       +
       		resolver := &mockIdentityResolver{

     

       265
       265
       +
       			handleToDID: map[string]string{

     

       266
       266
       +
       				"alice.bsky.social": "did:plc:alice123",

     

       267
       267
       +
       			},

     

       268
       268
       +
       		}

     

       269
       269
       +
       

     

       270
       270
       +
       		url := "https://bsky.app/profile/alice.bsky.social/post/3km3l4n5m6k7j8h9"

     

       271
       271
       +
       		result, err := ParseBlueskyURL(ctx, url, resolver)

     

       272
       272
       +
       		if err != nil {

     

       273
       273
       +
       			t.Errorf("ParseBlueskyURL() with alphanumeric rkey failed: %v", err)

     

       274
       274
       +
       		}

     

       275
       275
       +
       

     

       276
       276
       +
       		expected := "at://did:plc:alice123/app.bsky.feed.post/3km3l4n5m6k7j8h9"

     

       277
       277
       +
       		if result != expected {

     

       278
       278
       +
       			t.Errorf("ParseBlueskyURL() = %q, want %q", result, expected)

     

       279
       279
       +
       		}

     

       280
       280
       +
       	})

     

       281
       281
       +
       

     

       282
       282
       +
       	t.Run("handle that looks like DID should not be resolved", func(t *testing.T) {

     

       283
       283
       +
       		// If handle starts with "did:", treat it as DID

     

       284
       284
       +
       		resolver := &mockIdentityResolver{

     

       285
       285
       +
       			handleToDID: map[string]string{

     

       286
       286
       +
       				// Empty map - should not be called

     

       287
       287
       +
       			},

     

       288
       288
       +
       		}

     

       289
       289
       +
       

     

       290
       290
       +
       		url := "https://bsky.app/profile/did:plc:direct123/post/abc123"

     

       291
       291
       +
       		result, err := ParseBlueskyURL(ctx, url, resolver)

     

       292
       292
       +
       		if err != nil {

     

       293
       293
       +
       			t.Errorf("ParseBlueskyURL() with DID should not need resolution: %v", err)

     

       294
       294
       +
       		}

     

       295
       295
       +
       

     

       296
       296
       +
       		expected := "at://did:plc:direct123/app.bsky.feed.post/abc123"

     

       297
       297
       +
       		if result != expected {

     

       298
       298
       +
       			t.Errorf("ParseBlueskyURL() = %q, want %q", result, expected)

     

       299
       299
       +
       		}

     

       300
       300
       +
       	})

     

       301
       301
       +
       

     

       302
       302
       +
       	t.Run("empty handle after split should fail", func(t *testing.T) {

     

       303
       303
       +
       		// This is caught by the regex, but testing defensive validation

     

       304
       304
       +
       		resolver := &mockIdentityResolver{}

     

       305
       305
       +
       		url := "https://bsky.app/profile//post/abc123"

     

       306
       306
       +
       

     

       307
       307
       +
       		_, err := ParseBlueskyURL(ctx, url, resolver)

     

       308
       308
       +
       		if err == nil {

     

       309
       309
       +
       			t.Error("ParseBlueskyURL() with empty handle should fail")

     

       310
       310
       +
       		}

     

       311
       311
       +
       	})

     

       312
       312
       +
       }

     

       313
       313
       +
       

     

       314
       314
       +
       // Helper function to check if a string contains a substring

     

       315
       315
       +
       func contains(s, substr string) bool {

     

       316
       316
       +
       	return len(s) >= len(substr) && (s == substr || len(substr) == 0 ||

     

       317
       317
       +
       		(len(s) > 0 && len(substr) > 0 && containsHelper(s, substr)))

     

       318
       318
       +
       }

     

       319
       319
       +
       

     

       320
       320
       +
       func containsHelper(s, substr string) bool {

     

       321
       321
       +
       	for i := 0; i <= len(s)-len(substr); i++ {

     

       322
       322
       +
       		if s[i:i+len(substr)] == substr {

     

       323
       323
       +
       			return true

     

       324
       324
       +
       		}

     

       325
       325
       +
       	}

     

       326
       326
       +
       	return false

     

       327
       327
       +
       }

+93

internal/core/posts/blob_transform.go

···

       1
       1
        
       package posts

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"errors"

     

       4
       6
        
       	"fmt"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"strings"

     

       9
       9
       +
       

     

       10
       10
       +
       	"Coves/internal/core/blueskypost"

     

       5
       11
        
       )

     

       6
       12
        
       

     

       7
       13
        
       // TransformBlobRefsToURLs transforms all blob references in a PostView to PDS URLs

     
···

       79
       85
        
       	// Replace blob ref with URL string

     

       80
       86
        
       	external["thumb"] = blobURL

     

       81
       87
        
       }

     

       88
       88
       +
       

     

       89
       89
       +
       // TransformPostEmbeds enriches post embeds with resolved Bluesky post data

     

       90
       90
       +
       // This modifies the Embed field in-place, adding a "resolved" field with BlueskyPostResult

     

       91
       91
       +
       // Only processes social.coves.embed.post embeds with app.bsky.feed.post URIs

     

       92
       92
       +
       func TransformPostEmbeds(ctx context.Context, postView *PostView, blueskyService blueskypost.Service) {

     

       93
       93
       +
       	if postView == nil || postView.Embed == nil || blueskyService == nil {

     

       94
       94
       +
       		log.Printf("[DEBUG] [TRANSFORM-EMBED] Skipping: postView nil=%v, embed nil=%v, blueskyService nil=%v",

     

       95
       95
       +
       			postView == nil, postView == nil || postView.Embed == nil, blueskyService == nil)

     

       96
       96
       +
       		return

     

       97
       97
       +
       	}

     

       98
       98
       +
       

     

       99
       99
       +
       	// Check if embed is a map (should be for post embeds)

     

       100
       100
       +
       	embedMap, ok := postView.Embed.(map[string]interface{})

     

       101
       101
       +
       	if !ok {

     

       102
       102
       +
       		log.Printf("[DEBUG] [TRANSFORM-EMBED] Skipping: embed is not a map (type: %T)", postView.Embed)

     

       103
       103
       +
       		return

     

       104
       104
       +
       	}

     

       105
       105
       +
       

     

       106
       106
       +
       	// Check embed type

     

       107
       107
       +
       	embedType, ok := embedMap["$type"].(string)

     

       108
       108
       +
       	if !ok || embedType != "social.coves.embed.post" {

     

       109
       109
       +
       		log.Printf("[DEBUG] [TRANSFORM-EMBED] Skipping: embed type is not social.coves.embed.post (type: %v)", embedType)

     

       110
       110
       +
       		return

     

       111
       111
       +
       	}

     

       112
       112
       +
       

     

       113
       113
       +
       	// Extract the post reference

     

       114
       114
       +
       	postRef, ok := embedMap["post"].(map[string]interface{})

     

       115
       115
       +
       	if !ok {

     

       116
       116
       +
       		log.Printf("[DEBUG] [TRANSFORM-EMBED] Skipping: post reference is not a map")

     

       117
       117
       +
       		return

     

       118
       118
       +
       	}

     

       119
       119
       +
       

     

       120
       120
       +
       	// Get the AT-URI from the post reference

     

       121
       121
       +
       	atURI, ok := postRef["uri"].(string)

     

       122
       122
       +
       	if !ok || atURI == "" {

     

       123
       123
       +
       		log.Printf("[DEBUG] [TRANSFORM-EMBED] Skipping: AT-URI is missing or not a string")

     

       124
       124
       +
       		return

     

       125
       125
       +
       	}

     

       126
       126
       +
       

     

       127
       127
       +
       	// Only process app.bsky.feed.post URIs (Bluesky posts)

     

       128
       128
       +
       	// Format: at://did:plc:xxx/app.bsky.feed.post/abc123

     

       129
       129
       +
       	if len(atURI) < 20 || atURI[:5] != "at://" {

     

       130
       130
       +
       		log.Printf("[DEBUG] [TRANSFORM-EMBED] Skipping: invalid AT-URI format: %s", atURI)

     

       131
       131
       +
       		return

     

       132
       132
       +
       	}

     

       133
       133
       +
       

     

       134
       134
       +
       	// Simple check for app.bsky.feed.post collection

     

       135
       135
       +
       	// We don't want to process other types of embeds (e.g., Coves posts)

     

       136
       136
       +
       	if !strings.Contains(atURI, "/app.bsky.feed.post/") {

     

       137
       137
       +
       		log.Printf("[DEBUG] [TRANSFORM-EMBED] Skipping: not a Bluesky post (URI: %s)", atURI)

     

       138
       138
       +
       		return

     

       139
       139
       +
       	}

     

       140
       140
       +
       

     

       141
       141
       +
       	// Resolve the Bluesky post

     

       142
       142
       +
       	result, err := blueskyService.ResolvePost(ctx, atURI)

     

       143
       143
       +
       	if err != nil {

     

       144
       144
       +
       		// Log the error but don't fail - set unavailable instead

     

       145
       145
       +
       		log.Printf("[TRANSFORM-EMBED] Failed to resolve Bluesky post %s: %v", atURI, err)

     

       146
       146
       +
       

     

       147
       147
       +
       		// Differentiate between temporary and permanent failures using typed errors

     

       148
       148
       +
       		errorMessage := "This Bluesky post is unavailable"

     

       149
       149
       +
       		retryable := false

     

       150
       150
       +
       

     

       151
       151
       +
       		// Check if it's a circuit breaker error (temporary/retryable)

     

       152
       152
       +
       		if errors.Is(err, blueskypost.ErrCircuitOpen) {

     

       153
       153
       +
       			errorMessage = "Bluesky is temporarily unavailable, please try again later"

     

       154
       154
       +
       			retryable = true

     

       155
       155
       +
       		} else if errors.Is(err, context.DeadlineExceeded) {

     

       156
       156
       +
       			errorMessage = "Failed to load Bluesky post, please try again"

     

       157
       157
       +
       			retryable = true

     

       158
       158
       +
       		} else if strings.Contains(err.Error(), "timeout") ||

     

       159
       159
       +
       			strings.Contains(err.Error(), "temporary failure") {

     

       160
       160
       +
       			errorMessage = "Failed to load Bluesky post, please try again"

     

       161
       161
       +
       			retryable = true

     

       162
       162
       +
       		}

     

       163
       163
       +
       

     

       164
       164
       +
       		embedMap["resolved"] = map[string]interface{}{

     

       165
       165
       +
       			"unavailable": true,

     

       166
       166
       +
       			"message":     errorMessage,

     

       167
       167
       +
       			"retryable":   retryable,

     

       168
       168
       +
       		}

     

       169
       169
       +
       		return

     

       170
       170
       +
       	}

     

       171
       171
       +
       

     

       172
       172
       +
       	// Add resolved data to embed

     

       173
       173
       +
       	embedMap["resolved"] = result

     

       174
       174
       +
       }

+18

internal/db/migrations/023_create_bluesky_post_cache.sql

···

       1
       1
       +
       -- +goose Up

     

       2
       2
       +
       CREATE TABLE bluesky_post_cache (

     

       3
       3
       +
           at_uri TEXT PRIMARY KEY,

     

       4
       4
       +
           metadata JSONB NOT NULL,

     

       5
       5
       +
           fetched_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),

     

       6
       6
       +
           expires_at TIMESTAMPTZ NOT NULL

     

       7
       7
       +
       );

     

       8
       8
       +
       

     

       9
       9
       +
       CREATE INDEX idx_bluesky_post_cache_expires ON bluesky_post_cache(expires_at);

     

       10
       10
       +
       

     

       11
       11
       +
       COMMENT ON TABLE bluesky_post_cache IS 'Cache for Bluesky post data fetched from public.api.bsky.app';

     

       12
       12
       +
       COMMENT ON COLUMN bluesky_post_cache.at_uri IS 'AT-URI of the Bluesky post (e.g., at://did:plc:xxx/app.bsky.feed.post/abc123)';

     

       13
       13
       +
       COMMENT ON COLUMN bluesky_post_cache.metadata IS 'Full BlueskyPostResult as JSON (text, author, stats, etc.)';

     

       14
       14
       +
       COMMENT ON COLUMN bluesky_post_cache.expires_at IS 'When this cache entry should be refetched (shorter TTL than unfurl since posts can be edited/deleted)';

     

       15
       15
       +
       

     

       16
       16
       +
       -- +goose Down

     

       17
       17
       +
       DROP INDEX IF EXISTS idx_bluesky_post_cache_expires;

     

       18
       18
       +
       DROP TABLE IF EXISTS bluesky_post_cache;

-9

.beads/beads.base.jsonl

···

       1
       1
       -
       {"id":"Coves-8b1","content_hash":"a949ba526ad819badab625c0d5fdbc6a7994d22f059f4a4f7e68635750bd5ea3","title":"Apply functional options pattern to NewGetDiscoverHandler","description":"Location: internal/api/handlers/discover/get.go\n\nApply functional options pattern for optional dependencies (votes, bluesky).\n\nDepends on: Coves-jdf (NewPostService refactor should be done first to establish pattern)\nParent: Coves-8k1","status":"open","priority":3,"issue_type":"task","created_at":"2025-12-22T21:35:27.315877238-08:00","updated_at":"2025-12-22T21:35:58.061823373-08:00","source_repo":"."}

     

       2
       2
       -
       {"id":"Coves-8k1","content_hash":"a10053af68636b722a86aa75dd483ece4509d0de4884230beb52453585895589","title":"Refactor service constructors to use functional options pattern","description":"Multiple service constructors have grown to accept many optional dependencies, leading to hard-to-read nil chains:\n```go\nposts.NewPostService(repo, communityService, nil, nil, nil, nil, \"http://localhost:3001\")\n```\n\nApply the functional options pattern to all affected constructors:\n- NewPostService (7 params, 4 optional)\n- NewGetDiscoverHandler (3 params, 2 optional)\n- NewGetCommunityHandler (3 params, 2 optional)\n- NewGetTimelineHandler (3 params, 2 optional)\n- RegisterTimelineRoutes (5 params, 2 optional)\n\nThis will improve readability, make tests self-documenting, and prevent breakage when adding new optional params.\n\nScope: ~20 files, ~50 call sites\nRisk: Low (purely mechanical, no logic changes)","status":"open","priority":2,"issue_type":"feature","created_at":"2025-12-22T21:35:19.91257167-08:00","updated_at":"2025-12-22T21:35:39.69736147-08:00","source_repo":"."}

     

       3
       3
       -
       {"id":"Coves-95q","content_hash":"8ec99d598f067780436b985f9ad57f0fa19632026981038df4f65f192186620b","title":"Add comprehensive API documentation","description":"","status":"open","priority":2,"issue_type":"task","created_at":"2025-11-17T20:30:34.835721854-08:00","updated_at":"2025-11-17T20:30:34.835721854-08:00","source_repo":".","dependencies":[{"issue_id":"Coves-95q","depends_on_id":"Coves-e16","type":"blocks","created_at":"2025-11-17T20:30:46.273899399-08:00","created_by":"daemon"}]}

     

       4
       4
       -
       {"id":"Coves-e16","content_hash":"7c5d0fc8f0e7f626be3dad62af0e8412467330bad01a244e5a7e52ac5afff1c1","title":"Complete post creation and moderation features","description":"","status":"open","priority":1,"issue_type":"feature","created_at":"2025-11-17T20:30:12.885991306-08:00","updated_at":"2025-11-17T20:30:12.885991306-08:00","source_repo":"."}

     

       5
       5
       -
       {"id":"Coves-f9q","content_hash":"a1a38759edc37d11227d5992cdbed1b8cf27e09496165e45c542b208f58d34ce","title":"Apply functional options pattern to NewGetTimelineHandler and RegisterTimelineRoutes","description":"Locations:\n- internal/api/handlers/timeline/get.go (NewGetTimelineHandler)\n- internal/api/routes/timeline.go (RegisterTimelineRoutes)\n\nApply functional options pattern for optional dependencies (votes, bluesky).\n\nUpdate RegisterTimelineRoutes last after handlers are refactored.\n\nDepends on: Coves-jdf, Coves-8b1, Coves-iw5\nParent: Coves-8k1","status":"open","priority":3,"issue_type":"task","created_at":"2025-12-22T21:35:27.420117481-08:00","updated_at":"2025-12-22T21:35:58.166765845-08:00","source_repo":"."}

     

       6
       6
       -
       {"id":"Coves-fce","content_hash":"26b3e16b99f827316ee0d741cc959464bd0c813446c95aef8105c7fd1e6b09ff","title":"Implement aggregator feed federation","description":"","status":"open","priority":1,"issue_type":"feature","created_at":"2025-11-17T20:30:21.453326012-08:00","updated_at":"2025-11-17T20:30:21.453326012-08:00","source_repo":"."}

     

       7
       7
       -
       {"id":"Coves-iw5","content_hash":"d3379c617b7583f6b88a0523b3cdd1e4415176877ab00b48710819f2484c4856","title":"Apply functional options pattern to NewGetCommunityHandler","description":"Location: internal/api/handlers/communityFeed/get.go\n\nApply functional options pattern for optional dependencies (votes, bluesky).\n\nDepends on: Coves-jdf (NewPostService refactor should be done first to establish pattern)\nParent: Coves-8k1","status":"open","priority":3,"issue_type":"task","created_at":"2025-12-22T21:35:27.369297201-08:00","updated_at":"2025-12-22T21:35:58.115771178-08:00","source_repo":"."}

     

       8
       8
       -
       {"id":"Coves-jdf","content_hash":"cb27689d71f44fd555e29d2988f2ad053efb6c565cd4f803ff68eaade59c7546","title":"Apply functional options pattern to NewPostService","description":"Location: internal/core/posts/service.go\n\nCurrent constructor (7 params, 4 optional):\n```go\nfunc NewPostService(repo Repository, communityService communities.Service, aggregatorService aggregators.Service, blobService blobs.Service, unfurlService unfurl.Service, blueskyService blueskypost.Service, pdsURL string) Service\n```\n\nRefactor to:\n```go\ntype Option func(*postService)\n\nfunc WithAggregatorService(svc aggregators.Service) Option\nfunc WithBlobService(svc blobs.Service) Option\nfunc WithUnfurlService(svc unfurl.Service) Option\nfunc WithBlueskyService(svc blueskypost.Service) Option\n\nfunc NewPostService(repo Repository, communityService communities.Service, pdsURL string, opts ...Option) Service\n```\n\nFiles to update:\n- internal/core/posts/service.go (define Option type and With* functions)\n- cmd/server/main.go (production caller)\n- ~15 test files with call sites\n\nStart with this one as it has the most params and is most impacted.\nParent: Coves-8k1","status":"open","priority":2,"issue_type":"task","created_at":"2025-12-22T21:35:27.264325344-08:00","updated_at":"2025-12-22T21:35:58.003863381-08:00","source_repo":"."}

     

       9
       9
       -
       {"id":"Coves-p44","content_hash":"6f12091f6e5f1ad9812f8da4ecd720e0f9df1afd1fdb593b3e52c32be0193d94","title":"Bluesky embed conversion Phase 2: resolve post and populate CID","description":"When converting a Bluesky URL to a social.coves.embed.post, we need to:\n\n1. Call blueskyService.ResolvePost() to get the full post data including CID\n2. Populate both URI and CID in the strongRef\n3. Consider caching/re-using resolved post data for rendering\n\nCurrently disabled in Phase 1 (text-only) because:\n- social.coves.embed.post requires a valid CID in com.atproto.repo.strongRef\n- Empty CID causes PDS to reject the record creation\n\nRelated files:\n- internal/core/posts/service.go:tryConvertBlueskyURLToPostEmbed()\n- internal/atproto/lexicon/social/coves/embed/post.json\n\nThis is part of the Bluesky post cross-posting feature (images/embeds phase).","status":"open","priority":2,"issue_type":"feature","created_at":"2025-12-22T21:25:23.540135876-08:00","updated_at":"2025-12-22T21:25:41.704980685-08:00","source_repo":"."}

-1

.beads/beads.base.meta.json

···

       1
       1
       -
       {"version":"0.23.1","timestamp":"2025-12-22T21:37:18.747538079-08:00","commit":"6b49f88"}

.beads/.gitignore

···

       18
       18
        
       !*.jsonl

     

       19
       19
        
       !metadata.json

     

       20
       20
        
       !config.json

     

       21
       21
       +
       

     

       22
       22
       +
       # Merge artifacts (created during conflict resolution)

     

       23
       23
       +
       beads.base.jsonl

     

       24
       24
       +
       beads.base.meta.json

     

       25
       25
       +
       beads.left.jsonl

     

       26
       26
       +
       beads.left.meta.json

+3 -1

internal/api/routes/post.go

···

       10
       10
        
       

     

       11
       11
        
       // RegisterPostRoutes registers post-related XRPC endpoints on the router

     

       12
       12
        
       // Implements social.coves.community.post.* lexicon endpoints

     

       13
       13
       -
       func RegisterPostRoutes(r chi.Router, service posts.Service, authMiddleware *middleware.OAuthAuthMiddleware) {

     

       13
       13
       +
       // authMiddleware can be either OAuthAuthMiddleware or DualAuthMiddleware

     

       14
       14
       +
       func RegisterPostRoutes(r chi.Router, service posts.Service, authMiddleware middleware.AuthMiddleware) {

     

       14
       15
        
       	// Initialize handlers

     

       15
       16
        
       	createHandler := post.NewCreateHandler(service)

     

       16
       17
        
       

     

       17
       18
        
       	// Procedure endpoints (POST) - require authentication

     

       18
       19
        
       	// social.coves.community.post.create - create a new post in a community

     

       20
       20
       +
       	// Supports both OAuth (users) and service JWT (aggregators) authentication

     

       19
       21
        
       	r.With(authMiddleware.RequireAuth).Post("/xrpc/social.coves.community.post.create", createHandler.HandleCreate)

     

       20
       22
        
       

     

       21
       23
        
       	// Future endpoints (Beta):

+79

internal/core/blueskypost/fetcher_test.go

···

       601
       601
        
       		t.Error("Expected no quoted post with nil embeds")

     

       602
       602
        
       	}

     

       603
       603
        
       }

     

       604
       604
       +
       

     

       605
       605
       +
       func TestMapAPIPostToResult_ExternalEmbed(t *testing.T) {

     

       606
       606
       +
       	// Test that external link embeds are correctly extracted

     

       607
       607
       +
       	apiPost := &blueskyAPIPost{

     

       608
       608
       +
       		URI: "at://did:plc:test/app.bsky.feed.post/test",

     

       609
       609
       +
       		CID: "bafyreiabc123",

     

       610
       610
       +
       		Author: blueskyAPIAuthor{

     

       611
       611
       +
       			DID:         "did:plc:test",

     

       612
       612
       +
       			Handle:      "english.lemonde.fr",

     

       613
       613
       +
       			DisplayName: "Le Monde",

     

       614
       614
       +
       		},

     

       615
       615
       +
       		Record: blueskyAPIRecord{

     

       616
       616
       +
       			Text:      "Check out this article",

     

       617
       617
       +
       			CreatedAt: "2025-12-21T10:30:00Z",

     

       618
       618
       +
       		},

     

       619
       619
       +
       		Embed: &blueskyAPIEmbed{

     

       620
       620
       +
       			Type: "app.bsky.embed.external#view",

     

       621
       621
       +
       			External: &blueskyAPIExternal{

     

       622
       622
       +
       				URI:         "https://www.lemonde.fr/en/international/article/2025/12/22/nba-article.html",

     

       623
       623
       +
       				Title:       "NBA and Fiba announce search for teams",

     

       624
       624
       +
       				Description: "The NBA and FIBA have announced a joint search for teams interested in joining a potential European league.",

     

       625
       625
       +
       				Thumb:       "https://cdn.lemonde.fr/thumbnail.jpg",

     

       626
       626
       +
       			},

     

       627
       627
       +
       		},

     

       628
       628
       +
       		ReplyCount:  10,

     

       629
       629
       +
       		RepostCount: 5,

     

       630
       630
       +
       		LikeCount:   100,

     

       631
       631
       +
       	}

     

       632
       632
       +
       

     

       633
       633
       +
       	result := mapAPIPostToResult(apiPost)

     

       634
       634
       +
       

     

       635
       635
       +
       	// Verify basic fields

     

       636
       636
       +
       	if result.URI != "at://did:plc:test/app.bsky.feed.post/test" {

     

       637
       637
       +
       		t.Errorf("Expected URI 'at://did:plc:test/app.bsky.feed.post/test', got %s", result.URI)

     

       638
       638
       +
       	}

     

       639
       639
       +
       	if result.Author.Handle != "english.lemonde.fr" {

     

       640
       640
       +
       		t.Errorf("Expected Handle 'english.lemonde.fr', got %s", result.Author.Handle)

     

       641
       641
       +
       	}

     

       642
       642
       +
       

     

       643
       643
       +
       	// Verify external embed is extracted

     

       644
       644
       +
       	if result.Embed == nil {

     

       645
       645
       +
       		t.Fatal("Expected Embed to be set for external link post")

     

       646
       646
       +
       	}

     

       647
       647
       +
       	if result.Embed.URI != "https://www.lemonde.fr/en/international/article/2025/12/22/nba-article.html" {

     

       648
       648
       +
       		t.Errorf("Expected external URI, got %s", result.Embed.URI)

     

       649
       649
       +
       	}

     

       650
       650
       +
       	if result.Embed.Title != "NBA and Fiba announce search for teams" {

     

       651
       651
       +
       		t.Errorf("Expected external title, got %s", result.Embed.Title)

     

       652
       652
       +
       	}

     

       653
       653
       +
       	if result.Embed.Description != "The NBA and FIBA have announced a joint search for teams interested in joining a potential European league." {

     

       654
       654
       +
       		t.Errorf("Expected external description, got %s", result.Embed.Description)

     

       655
       655
       +
       	}

     

       656
       656
       +
       	if result.Embed.Thumb != "https://cdn.lemonde.fr/thumbnail.jpg" {

     

       657
       657
       +
       		t.Errorf("Expected external thumb, got %s", result.Embed.Thumb)

     

       658
       658
       +
       	}

     

       659
       659
       +
       }

     

       660
       660
       +
       

     

       661
       661
       +
       func TestMapAPIPostToResult_ExternalEmbedNil(t *testing.T) {

     

       662
       662
       +
       	// Test that posts without external embeds don't have Embed set

     

       663
       663
       +
       	apiPost := &blueskyAPIPost{

     

       664
       664
       +
       		URI: "at://did:plc:test/app.bsky.feed.post/test",

     

       665
       665
       +
       		CID: "bafyreiabc123",

     

       666
       666
       +
       		Author: blueskyAPIAuthor{

     

       667
       667
       +
       			DID:    "did:plc:test",

     

       668
       668
       +
       			Handle: "user.bsky.social",

     

       669
       669
       +
       		},

     

       670
       670
       +
       		Record: blueskyAPIRecord{

     

       671
       671
       +
       			Text:      "Just a regular post without links",

     

       672
       672
       +
       			CreatedAt: "2025-12-21T10:30:00Z",

     

       673
       673
       +
       		},

     

       674
       674
       +
       		Embed: nil,

     

       675
       675
       +
       	}

     

       676
       676
       +
       

     

       677
       677
       +
       	result := mapAPIPostToResult(apiPost)

     

       678
       678
       +
       

     

       679
       679
       +
       	if result.Embed != nil {

     

       680
       680
       +
       		t.Errorf("Expected Embed to be nil for post without external embed, got %+v", result.Embed)

     

       681
       681
       +
       	}

     

       682
       682
       +
       }

+24 -7

tests/integration/bluesky_post_test.go

···

       4
       4
        
       	"Coves/internal/atproto/identity"

     

       5
       5
        
       	"Coves/internal/core/blueskypost"

     

       6
       6
        
       	"context"

     

       7
       7
       +
       	"database/sql"

     

       7
       8
        
       	"fmt"

     

       8
       9
        
       	"net/http"

     

       9
       10
        
       	"testing"

     
···

       21
       22
        
       //

     

       22
       23
        
       // Use this for tests that need to resolve real Bluesky handles like "ianboudreau.com".

     

       23
       24
        
       // Do NOT use for tests involving local Coves identities (use local PLC instead).

     

       24
       24
       -
       func productionPLCIdentityResolver() identity.Resolver {

     

       25
       25
       +
       //

     

       26
       26
       +
       // NOTE: Requires a database connection for the identity cache. Pass the test db.

     

       27
       27
       +
       func productionPLCIdentityResolver(db *sql.DB) identity.Resolver {

     

       25
       28
        
       	config := identity.DefaultConfig()

     

       26
       29
        
       	config.PLCURL = "https://plc.directory" // Production PLC - READ ONLY

     

       27
       27
       -
       	return identity.NewResolver(nil, config)

     

       30
       30
       +
       	return identity.NewResolver(db, config)

     

       28
       31
        
       }

     

       29
       32
        
       

     

       30
       33
        
       // TestBlueskyPostCrossPosting_URLParsing tests URL detection and parsing

     
···

       37
       40
        
       	defer func() { _ = db.Close() }()

     

       38
       41
        
       

     

       39
       42
        
       	// Use production PLC resolver for real Bluesky handles (READ-ONLY)

     

       40
       40
       -
       	identityResolver := productionPLCIdentityResolver()

     

       43
       43
       +
       	identityResolver := productionPLCIdentityResolver(db)

     

       41
       44
        
       

     

       42
       45
        
       	// Setup Bluesky post service

     

       43
       46
        
       	repo := blueskypost.NewRepository(db)

     
···

       119
       122
        
       	_, _ = db.Exec("DELETE FROM bluesky_post_cache")

     

       120
       123
        
       

     

       121
       124
        
       	// Use production PLC resolver for real Bluesky handles (READ-ONLY)

     

       122
       122
       -
       	identityResolver := productionPLCIdentityResolver()

     

       125
       125
       +
       	identityResolver := productionPLCIdentityResolver(db)

     

       123
       126
        
       

     

       124
       127
        
       	repo := blueskypost.NewRepository(db)

     

       125
       128
        
       	service := blueskypost.NewService(repo, identityResolver,

     
···

       239
       242
        
       		assert.Equal(t, "davidpfau.com", result.Author.Handle)

     

       240
       243
        
       		assert.NotEmpty(t, result.Text)

     

       241
       244
        
       

     

       245
       245
       +
       		// Verify external embed is extracted

     

       246
       246
       +
       		if result.Embed != nil {

     

       247
       247
       +
       			assert.NotEmpty(t, result.Embed.URI, "External embed should have URI")

     

       248
       248
       +
       			t.Logf("  External embed URI: %s", result.Embed.URI)

     

       249
       249
       +
       			if result.Embed.Title != "" {

     

       250
       250
       +
       				t.Logf("  External embed title: %s", result.Embed.Title)

     

       251
       251
       +
       			}

     

       252
       252
       +
       			if result.Embed.Thumb != "" {

     

       253
       253
       +
       				t.Logf("  External embed thumb: %s", result.Embed.Thumb)

     

       254
       254
       +
       			}

     

       255
       255
       +
       		} else {

     

       256
       256
       +
       			t.Log("  Note: No external embed found (post may have been modified)")

     

       257
       257
       +
       		}

     

       258
       258
       +
       

     

       242
       259
        
       		t.Logf("✓ Successfully fetched post with link embed:")

     

       243
       260
        
       		t.Logf("  Author: @%s", result.Author.Handle)

     

       244
       261
        
       		t.Logf("  Text: %.80s...", result.Text)

     
···

       385
       402
        
       	defer func() { _ = db.Close() }()

     

       386
       403
        
       

     

       387
       404
        
       	// Use production PLC resolver for real Bluesky handles (READ-ONLY)

     

       388
       388
       -
       	identityResolver := productionPLCIdentityResolver()

     

       405
       405
       +
       	identityResolver := productionPLCIdentityResolver(db)

     

       389
       406
        
       

     

       390
       407
        
       	repo := blueskypost.NewRepository(db)

     

       391
       408
        
       	service := blueskypost.NewService(repo, identityResolver,

     
···

       542
       559
        
       	_, _ = db.Exec("DELETE FROM bluesky_post_cache WHERE at_uri LIKE 'at://did:plc:%'")

     

       543
       560
        
       

     

       544
       561
        
       	// Use production PLC resolver for real Bluesky handles (READ-ONLY)

     

       545
       545
       -
       	identityResolver := productionPLCIdentityResolver()

     

       562
       562
       +
       	identityResolver := productionPLCIdentityResolver(db)

     

       546
       563
        
       

     

       547
       564
        
       	repo := blueskypost.NewRepository(db)

     

       548
       565
        
       	service := blueskypost.NewService(repo, identityResolver,

     
···

       611
       628
        
       	_, _ = db.Exec("DELETE FROM bluesky_post_cache")

     

       612
       629
        
       

     

       613
       630
        
       	// Use production PLC resolver for real Bluesky handles (READ-ONLY)

     

       614
       614
       -
       	identityResolver := productionPLCIdentityResolver()

     

       631
       631
       +
       	identityResolver := productionPLCIdentityResolver(db)

     

       615
       632
        
       

     

       616
       633
        
       	// Setup Bluesky post service

     

       617
       634
        
       	repo := blueskypost.NewRepository(db)

+7 -5

internal/core/communities/token_refresh.go

···

       13
       13
        
       // refreshPDSToken exchanges a refresh token for new access and refresh tokens

     

       14
       14
        
       // Uses com.atproto.server.refreshSession endpoint via Indigo SDK

     

       15
       15
        
       // CRITICAL: Refresh tokens are single-use - old refresh token is revoked on success

     

       16
       16
       -
       func refreshPDSToken(ctx context.Context, pdsURL, currentAccessToken, refreshToken string) (newAccessToken, newRefreshToken string, err error) {

     

       16
       16
       +
       func refreshPDSToken(ctx context.Context, pdsURL, refreshToken string) (newAccessToken, newRefreshToken string, err error) {

     

       17
       17
        
       	if pdsURL == "" {

     

       18
       18
        
       		return "", "", fmt.Errorf("PDS URL is required")

     

       19
       19
        
       	}

     
···

       21
       21
        
       		return "", "", fmt.Errorf("refresh token is required")

     

       22
       22
        
       	}

     

       23
       23
        
       

     

       24
       24
       -
       	// Create XRPC client with auth credentials

     

       25
       25
       -
       	// The refresh endpoint requires authentication with the refresh token

     

       24
       24
       +
       	// Create XRPC client with refresh token as the auth credential

     

       25
       25
       +
       	// IMPORTANT: The xrpc client always sends AccessJwt as the Authorization header,

     

       26
       26
       +
       	// but refreshSession requires the refresh token in that header.

     

       27
       27
       +
       	// So we put the refresh token in AccessJwt to make it work correctly.

     

       26
       28
        
       	client := &xrpc.Client{

     

       27
       29
        
       		Host: pdsURL,

     

       28
       30
        
       		Auth: &xrpc.AuthInfo{

     

       29
       29
       -
       			AccessJwt:  currentAccessToken, // Can be expired (not used for refresh auth)

     

       30
       30
       -
       			RefreshJwt: refreshToken,       // This is what authenticates the refresh request

     

       31
       31
       +
       			AccessJwt:  refreshToken, // Refresh token goes here (sent as Authorization header)

     

       32
       32
       +
       			RefreshJwt: refreshToken, // Also set here for completeness

     

       31
       33
        
       		},

     

       32
       34
        
       	}

     

       33
       35

+77

internal/db/migrations/024_add_aggregator_api_keys.sql

···

       1
       1
       +
       -- +goose Up

     

       2
       2
       +
       -- Add API key authentication and OAuth credential storage for aggregators

     

       3
       3
       +
       -- This enables aggregators to authenticate using API keys backed by OAuth sessions

     

       4
       4
       +
       

     

       5
       5
       +
       -- ============================================================================

     

       6
       6
       +
       -- Add API key columns to aggregators table

     

       7
       7
       +
       -- ============================================================================

     

       8
       8
       +
       ALTER TABLE aggregators

     

       9
       9
       +
           -- API key identification (prefix for log correlation, hash for auth)

     

       10
       10
       +
           ADD COLUMN api_key_prefix VARCHAR(12),

     

       11
       11
       +
           ADD COLUMN api_key_hash VARCHAR(64) UNIQUE,

     

       12
       12
       +
       

     

       13
       13
       +
           -- OAuth credentials (encrypted at application layer before storage)

     

       14
       14
       +
           -- SECURITY: These columns contain sensitive OAuth tokens

     

       15
       15
       +
           ADD COLUMN oauth_access_token TEXT,

     

       16
       16
       +
           ADD COLUMN oauth_refresh_token TEXT,

     

       17
       17
       +
           ADD COLUMN oauth_token_expires_at TIMESTAMPTZ,

     

       18
       18
       +
       

     

       19
       19
       +
           -- OAuth session metadata for token refresh

     

       20
       20
       +
           ADD COLUMN oauth_pds_url TEXT,

     

       21
       21
       +
           ADD COLUMN oauth_auth_server_iss TEXT,

     

       22
       22
       +
           ADD COLUMN oauth_auth_server_token_endpoint TEXT,

     

       23
       23
       +
       

     

       24
       24
       +
           -- DPoP keys and nonces for token refresh (multibase encoded)

     

       25
       25
       +
           -- SECURITY: Contains private key material

     

       26
       26
       +
           ADD COLUMN oauth_dpop_private_key_multibase TEXT,

     

       27
       27
       +
           ADD COLUMN oauth_dpop_authserver_nonce TEXT,

     

       28
       28
       +
           ADD COLUMN oauth_dpop_pds_nonce TEXT,

     

       29
       29
       +
       

     

       30
       30
       +
           -- API key lifecycle timestamps

     

       31
       31
       +
           ADD COLUMN api_key_created_at TIMESTAMPTZ,

     

       32
       32
       +
           ADD COLUMN api_key_revoked_at TIMESTAMPTZ,

     

       33
       33
       +
           ADD COLUMN api_key_last_used_at TIMESTAMPTZ;

     

       34
       34
       +
       

     

       35
       35
       +
       -- Index for API key lookup during authentication

     

       36
       36
       +
       -- Partial index excludes NULL values since not all aggregators have API keys

     

       37
       37
       +
       CREATE INDEX idx_aggregators_api_key_hash

     

       38
       38
       +
           ON aggregators(api_key_hash)

     

       39
       39
       +
           WHERE api_key_hash IS NOT NULL;

     

       40
       40
       +
       

     

       41
       41
       +
       -- ============================================================================

     

       42
       42
       +
       -- Security comments on sensitive columns

     

       43
       43
       +
       -- ============================================================================

     

       44
       44
       +
       COMMENT ON COLUMN aggregators.api_key_prefix IS 'First 12 characters of API key for identification in logs (not secret)';

     

       45
       45
       +
       COMMENT ON COLUMN aggregators.api_key_hash IS 'SHA-256 hash of full API key for authentication lookup';

     

       46
       46
       +
       COMMENT ON COLUMN aggregators.oauth_access_token IS 'SENSITIVE: Encrypted OAuth access token for PDS operations';

     

       47
       47
       +
       COMMENT ON COLUMN aggregators.oauth_refresh_token IS 'SENSITIVE: Encrypted OAuth refresh token for session renewal';

     

       48
       48
       +
       COMMENT ON COLUMN aggregators.oauth_token_expires_at IS 'When the OAuth access token expires (triggers refresh)';

     

       49
       49
       +
       COMMENT ON COLUMN aggregators.oauth_pds_url IS 'PDS URL for this aggregators OAuth session';

     

       50
       50
       +
       COMMENT ON COLUMN aggregators.oauth_auth_server_iss IS 'OAuth authorization server issuer URL';

     

       51
       51
       +
       COMMENT ON COLUMN aggregators.oauth_auth_server_token_endpoint IS 'OAuth token refresh endpoint URL';

     

       52
       52
       +
       COMMENT ON COLUMN aggregators.oauth_dpop_private_key_multibase IS 'SENSITIVE: DPoP private key in multibase format for token refresh';

     

       53
       53
       +
       COMMENT ON COLUMN aggregators.oauth_dpop_authserver_nonce IS 'Latest DPoP nonce from authorization server';

     

       54
       54
       +
       COMMENT ON COLUMN aggregators.oauth_dpop_pds_nonce IS 'Latest DPoP nonce from PDS';

     

       55
       55
       +
       COMMENT ON COLUMN aggregators.api_key_created_at IS 'When the API key was generated';

     

       56
       56
       +
       COMMENT ON COLUMN aggregators.api_key_revoked_at IS 'When the API key was revoked (NULL = active)';

     

       57
       57
       +
       COMMENT ON COLUMN aggregators.api_key_last_used_at IS 'Last successful authentication using this API key';

     

       58
       58
       +
       

     

       59
       59
       +
       -- +goose Down

     

       60
       60
       +
       -- Remove API key columns from aggregators table

     

       61
       61
       +
       DROP INDEX IF EXISTS idx_aggregators_api_key_hash;

     

       62
       62
       +
       

     

       63
       63
       +
       ALTER TABLE aggregators

     

       64
       64
       +
           DROP COLUMN IF EXISTS api_key_prefix,

     

       65
       65
       +
           DROP COLUMN IF EXISTS api_key_hash,

     

       66
       66
       +
           DROP COLUMN IF EXISTS oauth_access_token,

     

       67
       67
       +
           DROP COLUMN IF EXISTS oauth_refresh_token,

     

       68
       68
       +
           DROP COLUMN IF EXISTS oauth_token_expires_at,

     

       69
       69
       +
           DROP COLUMN IF EXISTS oauth_pds_url,

     

       70
       70
       +
           DROP COLUMN IF EXISTS oauth_auth_server_iss,

     

       71
       71
       +
           DROP COLUMN IF EXISTS oauth_auth_server_token_endpoint,

     

       72
       72
       +
           DROP COLUMN IF EXISTS oauth_dpop_private_key_multibase,

     

       73
       73
       +
           DROP COLUMN IF EXISTS oauth_dpop_authserver_nonce,

     

       74
       74
       +
           DROP COLUMN IF EXISTS oauth_dpop_pds_nonce,

     

       75
       75
       +
           DROP COLUMN IF EXISTS api_key_created_at,

     

       76
       76
       +
           DROP COLUMN IF EXISTS api_key_revoked_at,

     

       77
       77
       +
           DROP COLUMN IF EXISTS api_key_last_used_at;

+92

internal/db/migrations/025_encrypt_aggregator_oauth_tokens.sql

···

       1
       1
       +
       -- +goose Up

     

       2
       2
       +
       -- Encrypt aggregator OAuth tokens at rest using pgp_sym_encrypt

     

       3
       3
       +
       -- This addresses the security issue where OAuth tokens were stored in plaintext

     

       4
       4
       +
       -- despite migration 024 claiming "encrypted at application layer before storage"

     

       5
       5
       +
       

     

       6
       6
       +
       -- +goose StatementBegin

     

       7
       7
       +
       

     

       8
       8
       +
       -- Step 1: Add new encrypted columns for OAuth tokens and DPoP private key

     

       9
       9
       +
       ALTER TABLE aggregators

     

       10
       10
       +
           ADD COLUMN oauth_access_token_encrypted BYTEA,

     

       11
       11
       +
           ADD COLUMN oauth_refresh_token_encrypted BYTEA,

     

       12
       12
       +
           ADD COLUMN oauth_dpop_private_key_encrypted BYTEA;

     

       13
       13
       +
       

     

       14
       14
       +
       -- Step 2: Migrate existing plaintext data to encrypted columns

     

       15
       15
       +
       -- Uses the same encryption key table as community credentials (migration 006)

     

       16
       16
       +
       UPDATE aggregators

     

       17
       17
       +
       SET

     

       18
       18
       +
           oauth_access_token_encrypted = CASE

     

       19
       19
       +
               WHEN oauth_access_token IS NOT NULL AND oauth_access_token != ''

     

       20
       20
       +
               THEN pgp_sym_encrypt(oauth_access_token, (SELECT encode(key_data, 'hex') FROM encryption_keys WHERE id = 1))

     

       21
       21
       +
               ELSE NULL

     

       22
       22
       +
           END,

     

       23
       23
       +
           oauth_refresh_token_encrypted = CASE

     

       24
       24
       +
               WHEN oauth_refresh_token IS NOT NULL AND oauth_refresh_token != ''

     

       25
       25
       +
               THEN pgp_sym_encrypt(oauth_refresh_token, (SELECT encode(key_data, 'hex') FROM encryption_keys WHERE id = 1))

     

       26
       26
       +
               ELSE NULL

     

       27
       27
       +
           END,

     

       28
       28
       +
           oauth_dpop_private_key_encrypted = CASE

     

       29
       29
       +
               WHEN oauth_dpop_private_key_multibase IS NOT NULL AND oauth_dpop_private_key_multibase != ''

     

       30
       30
       +
               THEN pgp_sym_encrypt(oauth_dpop_private_key_multibase, (SELECT encode(key_data, 'hex') FROM encryption_keys WHERE id = 1))

     

       31
       31
       +
               ELSE NULL

     

       32
       32
       +
           END

     

       33
       33
       +
       WHERE oauth_access_token IS NOT NULL

     

       34
       34
       +
          OR oauth_refresh_token IS NOT NULL

     

       35
       35
       +
          OR oauth_dpop_private_key_multibase IS NOT NULL;

     

       36
       36
       +
       

     

       37
       37
       +
       -- Step 3: Drop the old plaintext columns

     

       38
       38
       +
       ALTER TABLE aggregators

     

       39
       39
       +
           DROP COLUMN oauth_access_token,

     

       40
       40
       +
           DROP COLUMN oauth_refresh_token,

     

       41
       41
       +
           DROP COLUMN oauth_dpop_private_key_multibase;

     

       42
       42
       +
       

     

       43
       43
       +
       -- Step 4: Add security comments

     

       44
       44
       +
       COMMENT ON COLUMN aggregators.oauth_access_token_encrypted IS 'SENSITIVE: Encrypted OAuth access token (pgp_sym_encrypt) for PDS operations';

     

       45
       45
       +
       COMMENT ON COLUMN aggregators.oauth_refresh_token_encrypted IS 'SENSITIVE: Encrypted OAuth refresh token (pgp_sym_encrypt) for session renewal';

     

       46
       46
       +
       COMMENT ON COLUMN aggregators.oauth_dpop_private_key_encrypted IS 'SENSITIVE: Encrypted DPoP private key (pgp_sym_encrypt) for token refresh';

     

       47
       47
       +
       

     

       48
       48
       +
       -- +goose StatementEnd

     

       49
       49
       +
       

     

       50
       50
       +
       -- +goose Down

     

       51
       51
       +
       -- +goose StatementBegin

     

       52
       52
       +
       

     

       53
       53
       +
       -- Restore plaintext columns

     

       54
       54
       +
       ALTER TABLE aggregators

     

       55
       55
       +
           ADD COLUMN oauth_access_token TEXT,

     

       56
       56
       +
           ADD COLUMN oauth_refresh_token TEXT,

     

       57
       57
       +
           ADD COLUMN oauth_dpop_private_key_multibase TEXT;

     

       58
       58
       +
       

     

       59
       59
       +
       -- Decrypt data back to plaintext (for rollback)

     

       60
       60
       +
       UPDATE aggregators

     

       61
       61
       +
       SET

     

       62
       62
       +
           oauth_access_token = CASE

     

       63
       63
       +
               WHEN oauth_access_token_encrypted IS NOT NULL

     

       64
       64
       +
               THEN pgp_sym_decrypt(oauth_access_token_encrypted, (SELECT encode(key_data, 'hex') FROM encryption_keys WHERE id = 1))

     

       65
       65
       +
               ELSE NULL

     

       66
       66
       +
           END,

     

       67
       67
       +
           oauth_refresh_token = CASE

     

       68
       68
       +
               WHEN oauth_refresh_token_encrypted IS NOT NULL

     

       69
       69
       +
               THEN pgp_sym_decrypt(oauth_refresh_token_encrypted, (SELECT encode(key_data, 'hex') FROM encryption_keys WHERE id = 1))

     

       70
       70
       +
               ELSE NULL

     

       71
       71
       +
           END,

     

       72
       72
       +
           oauth_dpop_private_key_multibase = CASE

     

       73
       73
       +
               WHEN oauth_dpop_private_key_encrypted IS NOT NULL

     

       74
       74
       +
               THEN pgp_sym_decrypt(oauth_dpop_private_key_encrypted, (SELECT encode(key_data, 'hex') FROM encryption_keys WHERE id = 1))

     

       75
       75
       +
               ELSE NULL

     

       76
       76
       +
           END

     

       77
       77
       +
       WHERE oauth_access_token_encrypted IS NOT NULL

     

       78
       78
       +
          OR oauth_refresh_token_encrypted IS NOT NULL

     

       79
       79
       +
          OR oauth_dpop_private_key_encrypted IS NOT NULL;

     

       80
       80
       +
       

     

       81
       81
       +
       -- Drop encrypted columns

     

       82
       82
       +
       ALTER TABLE aggregators

     

       83
       83
       +
           DROP COLUMN oauth_access_token_encrypted,

     

       84
       84
       +
           DROP COLUMN oauth_refresh_token_encrypted,

     

       85
       85
       +
           DROP COLUMN oauth_dpop_private_key_encrypted;

     

       86
       86
       +
       

     

       87
       87
       +
       -- Restore comments

     

       88
       88
       +
       COMMENT ON COLUMN aggregators.oauth_access_token IS 'SENSITIVE: OAuth access token for PDS operations';

     

       89
       89
       +
       COMMENT ON COLUMN aggregators.oauth_refresh_token IS 'SENSITIVE: OAuth refresh token for session renewal';

     

       90
       90
       +
       COMMENT ON COLUMN aggregators.oauth_dpop_private_key_multibase IS 'SENSITIVE: DPoP private key in multibase format for token refresh';

     

       91
       91
       +
       

     

       92
       92
       +
       -- +goose StatementEnd

+42

internal/api/handlers/aggregator/metrics.go

···

       1
       1
       +
       package aggregator

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"net/http"

     

       5
       5
       +
       

     

       6
       6
       +
       	"Coves/internal/core/aggregators"

     

       7
       7
       +
       )

     

       8
       8
       +
       

     

       9
       9
       +
       // MetricsHandler provides API key service metrics for monitoring

     

       10
       10
       +
       type MetricsHandler struct {

     

       11
       11
       +
       	apiKeyService aggregators.APIKeyServiceInterface

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       // NewMetricsHandler creates a new metrics handler

     

       15
       15
       +
       func NewMetricsHandler(apiKeyService aggregators.APIKeyServiceInterface) *MetricsHandler {

     

       16
       16
       +
       	return &MetricsHandler{

     

       17
       17
       +
       		apiKeyService: apiKeyService,

     

       18
       18
       +
       	}

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       // MetricsResponse contains API key service operational metrics

     

       22
       22
       +
       type MetricsResponse struct {

     

       23
       23
       +
       	FailedLastUsedUpdates int64 `json:"failedLastUsedUpdates"`

     

       24
       24
       +
       	FailedNonceUpdates    int64 `json:"failedNonceUpdates"`

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       // HandleMetrics handles GET /xrpc/social.coves.aggregator.getMetrics

     

       28
       28
       +
       // Returns operational metrics for the API key service.

     

       29
       29
       +
       // This endpoint is intended for internal monitoring and health checks.

     

       30
       30
       +
       func (h *MetricsHandler) HandleMetrics(w http.ResponseWriter, r *http.Request) {

     

       31
       31
       +
       	if r.Method != http.MethodGet {

     

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

     

       33
       33
       +
       		return

     

       34
       34
       +
       	}

     

       35
       35
       +
       

     

       36
       36
       +
       	response := MetricsResponse{

     

       37
       37
       +
       		FailedLastUsedUpdates: h.apiKeyService.GetFailedLastUsedUpdates(),

     

       38
       38
       +
       		FailedNonceUpdates:    h.apiKeyService.GetFailedNonceUpdates(),

     

       39
       39
       +
       	}

     

       40
       40
       +
       

     

       41
       41
       +
       	writeJSONResponse(w, http.StatusOK, response)

     

       42
       42
       +
       }

+7 -1

internal/api/routes/aggregator.go

···

       64
       64
        
       func RegisterAggregatorAPIKeyRoutes(

     

       65
       65
        
       	r chi.Router,

     

       66
       66
        
       	authMiddleware middleware.AuthMiddleware,

     

       67
       67
       -
       	apiKeyService *aggregators.APIKeyService,

     

       67
       67
       +
       	apiKeyService aggregators.APIKeyServiceInterface,

     

       68
       68
        
       	aggregatorService aggregators.Service,

     

       69
       69
        
       ) {

     

       70
       70
        
       	// Create API key handlers

     

       71
       71
        
       	createAPIKeyHandler := aggregator.NewCreateAPIKeyHandler(apiKeyService, aggregatorService)

     

       72
       72
        
       	getAPIKeyHandler := aggregator.NewGetAPIKeyHandler(apiKeyService, aggregatorService)

     

       73
       73
        
       	revokeAPIKeyHandler := aggregator.NewRevokeAPIKeyHandler(apiKeyService, aggregatorService)

     

       74
       74
       +
       	metricsHandler := aggregator.NewMetricsHandler(apiKeyService)

     

       74
       75
        
       

     

       75
       76
        
       	// API key management endpoints (require OAuth authentication)

     

       76
       77
        
       	// POST /xrpc/social.coves.aggregator.createApiKey

     
···

       87
       88
        
       	// Revokes the authenticated aggregator's API key

     

       88
       89
        
       	r.With(authMiddleware.RequireAuth).Post("/xrpc/social.coves.aggregator.revokeApiKey",

     

       89
       90
        
       		revokeAPIKeyHandler.HandleRevokeAPIKey)

     

       91
       91
       +
       

     

       92
       92
       +
       	// GET /xrpc/social.coves.aggregator.getMetrics

     

       93
       93
       +
       	// Returns operational metrics for the API key service (internal monitoring endpoint)

     

       94
       94
       +
       	// No authentication required - metrics are non-sensitive operational data

     

       95
       95
       +
       	r.Get("/xrpc/social.coves.aggregator.getMetrics", metricsHandler.HandleMetrics)

     

       90
       96
        
       }

+2 -3

aggregators/kagi-news/.env.example

···

       1
       1
       -
       # Aggregator Identity (pre-created account credentials)

     

       2
       2
       -
       AGGREGATOR_HANDLE=kagi-news.local.coves.dev

     

       3
       3
       -
       AGGREGATOR_PASSWORD=your-secure-password-here

     

       1
       1
       +
       # Coves API Key (get from https://coves.social after OAuth login)

     

       2
       2
       +
       COVES_API_KEY=ckapi_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

     

       4
       3
        
       

     

       5
       4
        
       # Optional: Override Coves API URL (defaults to config.yaml)

     

       6
       5
        
       # COVES_API_URL=http://localhost:3001

-1

aggregators/kagi-news/requirements.txt

···

       2
       2
        
       feedparser==6.0.11

     

       3
       3
        
       beautifulsoup4==4.12.3

     

       4
       4
        
       requests==2.31.0

     

       5
       5
       -
       atproto==0.0.55

     

       6
       5
        
       pyyaml==6.0.1

     

       7
       6
        
       

     

       8
       7
        
       # Testing

+24 -15

aggregators/kagi-news/README.md

···

       47
       47
        
       

     

       48
       48
        
       Before running the aggregator, you must register it with a Coves instance. This creates a DID for your aggregator and registers it with Coves.

     

       49
       49
        
       

     

       50
       50
       +
       ### Handle Options

     

       51
       51
       +
       

     

       52
       52
       +
       You have two choices:

     

       53
       53
       +
       

     

       54
       54
       +
       1. **PDS-assigned handle** (simpler): Use `my-aggregator.bsky.social`. No domain verification needed.

     

       55
       55
       +
       2. **Custom domain** (branded): Use `news.example.com`. Requires hosting a `.well-known/atproto-did` file.

     

       56
       56
       +
       

     

       50
       57
        
       ### Quick Setup (Automated)

     

       51
       58
        
       

     

       52
       59
        
       The automated setup script handles the entire registration process:

     
···

       59
       66
        
       

     

       60
       67
        
       This will:

     

       61
       68
        
       1. **Create a PDS account** for your aggregator (generates a DID)

     

       62
       62
       -
       2. **Generate `.well-known/atproto-did`** file for domain verification

     

       63
       63
       -
       3. **Pause for manual upload** - you'll upload the file to your web server

     

       64
       64
       -
       4. **Register with Coves** instance via XRPC

     

       65
       65
       -
       5. **Create service declaration** record (indexed by Jetstream)

     

       69
       69
       +
       2. **(Optional)** Generate `.well-known/atproto-did` file for custom domain handle

     

       70
       70
       +
       3. **(Optional)** Pause for manual upload if using custom domain

     

       71
       71
       +
       4. **Create service declaration** record (indexed by Jetstream)

     

       72
       72
       +
       5. **Generate an API key** for authentication (requires browser OAuth)

     

       66
       73
        
       

     

       67
       67
       -
       **Manual step required:** During the process, you'll need to upload the `.well-known/atproto-did` file to your domain so it's accessible at `https://yourdomain.com/.well-known/atproto-did`.

     

       74
       74
       +
       **Manual steps required:**

     

       75
       75
       +
       - **(If using custom domain)** Upload `.well-known/atproto-did` to your domain

     

       76
       76
       +
       - Complete OAuth login in browser to generate API key

     

       68
       77
        
       

     

       69
       69
       -
       After completion, you'll have a `kagi-aggregator-config.env` file with:

     

       70
       70
       -
       - Aggregator DID and credentials

     

       71
       71
       -
       - Access/refresh JWTs

     

       72
       72
       -
       - Service declaration URI

     

       78
       78
       +
       After completion, you'll have:

     

       79
       79
       +
       - `kagi-aggregator-config.env` - Full configuration with API key

     

       80
       80
       +
       - `COVES_API_KEY` - Your authentication token for posting

     

       73
       81
        
       

     

       74
       74
       -
       **Keep this file secure!** It contains your aggregator's credentials.

     

       82
       82
       +
       **Keep the API key secure!** It cannot be retrieved after generation.

     

       75
       83
        
       

     

       76
       84
        
       ### Manual Setup (Step-by-step)

     

       77
       85
        
       

     
···

       81
       89
        
       # From the Coves project root

     

       82
       90
        
       cd scripts/aggregator-setup

     

       83
       91
        
       

     

       84
       84
       -
       # Follow the 4-step process

     

       92
       92
       +
       # Follow the 5-step process

     

       85
       93
        
       ./1-create-pds-account.sh

     

       86
       94
        
       ./2-setup-wellknown.sh

     

       87
       95
        
       ./3-register-with-coves.sh

     

       88
       96
        
       ./4-create-service-declaration.sh

     

       97
       97
       +
       ./5-create-api-key.sh

     

       89
       98
        
       ```

     

       90
       99
        
       

     

       91
       100
        
       See [scripts/aggregator-setup/README.md](../../scripts/aggregator-setup/README.md) for detailed documentation on each step.

     
···

       96
       105
        
       2. **Domain Verification**: Proves you control your aggregator's domain

     

       97
       106
        
       3. **Coves Registration**: Inserts your DID into the Coves instance's `users` table

     

       98
       107
        
       4. **Service Declaration**: Creates a record that gets indexed into the `aggregators` table

     

       99
       99
       -
       5. **Ready for Authorization**: Community moderators can now authorize your aggregator

     

       108
       108
       +
       5. **API Key Generation**: Creates a secure API key for authentication

     

       109
       109
       +
       6. **Ready for Authorization**: Community moderators can now authorize your aggregator

     

       100
       110
        
       

     

       101
       111
        
       Once registered and authorized by a community, your aggregator can post content.

     

       102
       112
        
       

     
···

       128
       138
        
          ```

     

       129
       139
        
       

     

       130
       140
        
       4. Edit `config.yaml` to map RSS feeds to communities

     

       131
       131
       -
       5. Set environment variables in `.env` (aggregator DID and private key)

     

       141
       141
       +
       5. Set `COVES_API_KEY` in `.env` (from registration step 5)

     

       132
       142
        
       

     

       133
       143
        
       ## Running Tests

     

       134
       144
        
       

     
···

       189
       199
        
       

     

       190
       200
        
       The `docker-compose.yml` file supports these environment variables:

     

       191
       201
        
       

     

       192
       192
       -
       - **`AGGREGATOR_HANDLE`** (required): Your aggregator's handle

     

       193
       193
       -
       - **`AGGREGATOR_PASSWORD`** (required): Your aggregator's password

     

       202
       202
       +
       - **`COVES_API_KEY`** (required): Your aggregator's API key (format: `ckapi_...`)

     

       194
       203
        
       - **`COVES_API_URL`** (optional): Override Coves API endpoint (defaults to `https://api.coves.social`)

     

       195
       204
        
       - **`RUN_ON_STARTUP`** (optional): Set to `true` to run immediately on container start (useful for testing)

     

       196
       205

+148

scripts/aggregator-setup/5-create-api-key.sh

···

       1
       1
       +
       #!/bin/bash

     

       2
       2
       +
       #

     

       3
       3
       +
       # Step 5: Create API Key for Aggregator

     

       4
       4
       +
       #

     

       5
       5
       +
       # This script guides you through generating an API key for your aggregator.

     

       6
       6
       +
       # API keys are used for authentication instead of PDS JWTs.

     

       7
       7
       +
       #

     

       8
       8
       +
       # Prerequisites:

     

       9
       9
       +
       # - Completed steps 1-4 (PDS account, .well-known, Coves registration, service declaration)

     

       10
       10
       +
       # - Aggregator indexed by Coves (check: curl https://coves.social/xrpc/social.coves.aggregator.get?did=YOUR_DID)

     

       11
       11
       +
       #

     

       12
       12
       +
       # Usage: ./5-create-api-key.sh

     

       13
       13
       +
       #

     

       14
       14
       +
       

     

       15
       15
       +
       set -e

     

       16
       16
       +
       

     

       17
       17
       +
       # Colors for output

     

       18
       18
       +
       RED='\033[0;31m'

     

       19
       19
       +
       GREEN='\033[0;32m'

     

       20
       20
       +
       YELLOW='\033[1;33m'

     

       21
       21
       +
       BLUE='\033[0;34m'

     

       22
       22
       +
       NC='\033[0m' # No Color

     

       23
       23
       +
       

     

       24
       24
       +
       echo -e "${BLUE}╔════════════════════════════════════════════════════════════╗${NC}"

     

       25
       25
       +
       echo -e "${BLUE}║         Coves Aggregator - Step 5: Create API Key         ║${NC}"

     

       26
       26
       +
       echo -e "${BLUE}╚════════════════════════════════════════════════════════════╝${NC}"

     

       27
       27
       +
       echo

     

       28
       28
       +
       

     

       29
       29
       +
       # Load existing configuration

     

       30
       30
       +
       CONFIG_FILE="aggregator-config.env"

     

       31
       31
       +
       if [ -f "$CONFIG_FILE" ]; then

     

       32
       32
       +
           echo -e "${GREEN}✓${NC} Loading existing configuration from $CONFIG_FILE"

     

       33
       33
       +
           source "$CONFIG_FILE"

     

       34
       34
       +
       else

     

       35
       35
       +
           echo -e "${YELLOW}⚠${NC} No $CONFIG_FILE found. Please run steps 1-4 first."

     

       36
       36
       +
           echo

     

       37
       37
       +
           read -p "Enter your Coves instance URL [https://coves.social]: " COVES_INSTANCE_URL

     

       38
       38
       +
           COVES_INSTANCE_URL=${COVES_INSTANCE_URL:-https://coves.social}

     

       39
       39
       +
       fi

     

       40
       40
       +
       

     

       41
       41
       +
       echo

     

       42
       42
       +
       echo -e "${YELLOW}═══════════════════════════════════════════════════════════${NC}"

     

       43
       43
       +
       echo -e "${YELLOW} API Key Generation Process${NC}"

     

       44
       44
       +
       echo -e "${YELLOW}═══════════════════════════════════════════════════════════${NC}"

     

       45
       45
       +
       echo

     

       46
       46
       +
       echo "API keys allow your aggregator to authenticate without managing"

     

       47
       47
       +
       echo "OAuth token refresh. The key is shown ONCE and cannot be retrieved later."

     

       48
       48
       +
       echo

     

       49
       49
       +
       echo -e "${BLUE}Steps:${NC}"

     

       50
       50
       +
       echo "1. Complete OAuth login in your browser"

     

       51
       51
       +
       echo "2. Call the createApiKey endpoint"

     

       52
       52
       +
       echo "3. Save the key securely"

     

       53
       53
       +
       echo

     

       54
       54
       +
       

     

       55
       55
       +
       # Check if aggregator is indexed

     

       56
       56
       +
       echo -e "${BLUE}Checking if aggregator is indexed...${NC}"

     

       57
       57
       +
       if [ -n "$AGGREGATOR_DID" ]; then

     

       58
       58
       +
           AGGREGATOR_CHECK=$(curl -s "${COVES_INSTANCE_URL}/xrpc/social.coves.aggregator.get?did=${AGGREGATOR_DID}" 2>/dev/null || echo "error")

     

       59
       59
       +
           if echo "$AGGREGATOR_CHECK" | grep -q "error"; then

     

       60
       60
       +
               echo -e "${YELLOW}⚠${NC} Could not verify aggregator status. Proceeding anyway..."

     

       61
       61
       +
           else

     

       62
       62
       +
               echo -e "${GREEN}✓${NC} Aggregator found in Coves instance"

     

       63
       63
       +
           fi

     

       64
       64
       +
       fi

     

       65
       65
       +
       

     

       66
       66
       +
       echo

     

       67
       67
       +
       echo -e "${YELLOW}═══════════════════════════════════════════════════════════${NC}"

     

       68
       68
       +
       echo -e "${YELLOW} Step 5.1: OAuth Login${NC}"

     

       69
       69
       +
       echo -e "${YELLOW}═══════════════════════════════════════════════════════════${NC}"

     

       70
       70
       +
       echo

     

       71
       71
       +
       echo "Open this URL in your browser to authenticate:"

     

       72
       72
       +
       echo

     

       73
       73
       +
       AGGREGATOR_HANDLE=${AGGREGATOR_HANDLE:-"your-aggregator.example.com"}

     

       74
       74
       +
       echo -e "  ${BLUE}${COVES_INSTANCE_URL}/oauth/login?handle=${AGGREGATOR_HANDLE}${NC}"

     

       75
       75
       +
       echo

     

       76
       76
       +
       echo "This will:"

     

       77
       77
       +
       echo "  1. Redirect you to your PDS for authentication"

     

       78
       78
       +
       echo "  2. Return you to Coves with an OAuth session"

     

       79
       79
       +
       echo

     

       80
       80
       +
       echo -e "${YELLOW}After authenticating, press Enter to continue...${NC}"

     

       81
       81
       +
       read

     

       82
       82
       +
       

     

       83
       83
       +
       echo

     

       84
       84
       +
       echo -e "${YELLOW}═══════════════════════════════════════════════════════════${NC}"

     

       85
       85
       +
       echo -e "${YELLOW} Step 5.2: Create API Key${NC}"

     

       86
       86
       +
       echo -e "${YELLOW}═══════════════════════════════════════════════════════════${NC}"

     

       87
       87
       +
       echo

     

       88
       88
       +
       echo "In your browser's Developer Console (F12 → Console), run:"

     

       89
       89
       +
       echo

     

       90
       90
       +
       echo -e "${GREEN}fetch('/xrpc/social.coves.aggregator.createApiKey', {"

     

       91
       91
       +
       echo "  method: 'POST',"

     

       92
       92
       +
       echo "  credentials: 'include'"

     

       93
       93
       +
       echo "})"

     

       94
       94
       +
       echo ".then(r => r.json())"

     

       95
       95
       +
       echo -e ".then(data => console.log('API Key:', data.key))${NC}"

     

       96
       96
       +
       echo

     

       97
       97
       +
       echo "This will return your API key. It looks like:"

     

       98
       98
       +
       echo "  ckapi_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

     

       99
       99
       +
       echo

     

       100
       100
       +
       echo -e "${RED}⚠ IMPORTANT: Save this key immediately! It cannot be retrieved again.${NC}"

     

       101
       101
       +
       echo

     

       102
       102
       +
       read -p "Enter the API key you received: " API_KEY

     

       103
       103
       +
       

     

       104
       104
       +
       # Validate API key format

     

       105
       105
       +
       if [[ ! $API_KEY =~ ^ckapi_[a-f0-9]{64}$ ]]; then

     

       106
       106
       +
           echo -e "${RED}✗ Invalid API key format. Expected: ckapi_ followed by 64 hex characters${NC}"

     

       107
       107
       +
           echo "  Example: ckapi_dcbdec0a0d1b3c440125547d21fe582bbf1587d2dcd364c56ad285af841cc934"

     

       108
       108
       +
           exit 1

     

       109
       109
       +
       fi

     

       110
       110
       +
       

     

       111
       111
       +
       echo -e "${GREEN}✓${NC} API key format valid"

     

       112
       112
       +
       

     

       113
       113
       +
       # Save to config

     

       114
       114
       +
       echo

     

       115
       115
       +
       echo "COVES_API_KEY=\"$API_KEY\"" >> "$CONFIG_FILE"

     

       116
       116
       +
       echo -e "${GREEN}✓${NC} API key saved to $CONFIG_FILE"

     

       117
       117
       +
       

     

       118
       118
       +
       echo

     

       119
       119
       +
       echo -e "${YELLOW}═══════════════════════════════════════════════════════════${NC}"

     

       120
       120
       +
       echo -e "${YELLOW} Step 5.3: Update Your .env File${NC}"

     

       121
       121
       +
       echo -e "${YELLOW}═══════════════════════════════════════════════════════════${NC}"

     

       122
       122
       +
       echo

     

       123
       123
       +
       echo "Update your aggregator's .env file with:"

     

       124
       124
       +
       echo

     

       125
       125
       +
       echo -e "${GREEN}COVES_API_KEY=${API_KEY}${NC}"

     

       126
       126
       +
       echo -e "${GREEN}COVES_API_URL=${COVES_INSTANCE_URL}${NC}"

     

       127
       127
       +
       echo

     

       128
       128
       +
       echo "You can remove the old AGGREGATOR_HANDLE and AGGREGATOR_PASSWORD variables."

     

       129
       129
       +
       echo

     

       130
       130
       +
       

     

       131
       131
       +
       echo

     

       132
       132
       +
       echo -e "${GREEN}╔════════════════════════════════════════════════════════════╗${NC}"

     

       133
       133
       +
       echo -e "${GREEN}║                    Setup Complete!                         ║${NC}"

     

       134
       134
       +
       echo -e "${GREEN}╚════════════════════════════════════════════════════════════╝${NC}"

     

       135
       135
       +
       echo

     

       136
       136
       +
       echo "Your aggregator is now configured with API key authentication."

     

       137
       137
       +
       echo

     

       138
       138
       +
       echo "Next steps:"

     

       139
       139
       +
       echo "  1. Update your aggregator's .env file with COVES_API_KEY"

     

       140
       140
       +
       echo "  2. Rebuild your Docker container: docker compose build --no-cache"

     

       141
       141
       +
       echo "  3. Start the aggregator: docker compose up -d"

     

       142
       142
       +
       echo "  4. Check logs: docker compose logs -f"

     

       143
       143
       +
       echo

     

       144
       144
       +
       echo -e "${YELLOW}Security Reminders:${NC}"

     

       145
       145
       +
       echo "  - Never commit your API key to version control"

     

       146
       146
       +
       echo "  - Store it securely (environment variables or secrets manager)"

     

       147
       147
       +
       echo "  - Rotate periodically by generating a new key (revokes the old one)"

     

       148
       148
       +
       echo

+73 -28

scripts/aggregator-setup/README.md

···

       7
       7
        
       Aggregators are automated services that post content to Coves communities. They are similar to Bluesky's feed generators and labelers. To use aggregators with Coves, you need to:

     

       8
       8
        
       

     

       9
       9
        
       1. Create a PDS account for your aggregator (gets you a DID)

     

       10
       10
       -
       2. Prove you own a domain via `.well-known/atproto-did`

     

       10
       10
       +
       2. **(Optional)** Verify a custom domain via `.well-known/atproto-did`

     

       11
       11
        
       3. Register with a Coves instance

     

       12
       12
        
       4. Create a service declaration record

     

       13
       13
       +
       5. **Generate an API key** for authentication

     

       13
       14
        
       

     

       14
       15
        
       These scripts automate this process for you.

     

       15
       16
        
       

     

       17
       17
       +
       ### Handle Options

     

       18
       18
       +
       

     

       19
       19
       +
       You have two choices for your aggregator's handle:

     

       20
       20
       +
       

     

       21
       21
       +
       1. **PDS-assigned handle** (simpler): Use the handle from your PDS, e.g., `my-aggregator.bsky.social`. No domain verification needed—skip steps 2-3.

     

       22
       22
       +
       

     

       23
       23
       +
       2. **Custom domain handle** (branded): Use your own domain, e.g., `news.example.com`. Requires hosting a `.well-known/atproto-did` file on your domain.

     

       24
       24
       +
       

     

       16
       25
        
       ## Prerequisites

     

       17
       26
        
       

     

       18
       18
       -
       - **Domain ownership**: You must own a domain where you can host the `.well-known/atproto-did` file

     

       19
       19
       -
       - **Web server**: Ability to serve static files over HTTPS

     

       20
       27
        
       - **Tools**: `curl`, `jq` (for JSON processing)

     

       21
       28
        
       - **Account**: Email address for creating the PDS account

     

       29
       29
       +
       - **(For custom domain only)**: Domain ownership and ability to serve HTTPS files

     

       22
       30
        
       

     

       23
       31
        
       ## Quick Start

     

       24
       32
        
       

     
···

       33
       41
        
       # Step 1: Create PDS account

     

       34
       42
        
       ./1-create-pds-account.sh

     

       35
       43
        
       

     

       36
       36
       -
       # Step 2: Generate .well-known file

     

       37
       37
       -
       ./2-setup-wellknown.sh

     

       38
       38
       -
       

     

       39
       39
       -
       # Step 3: Register with Coves (after uploading .well-known)

     

       40
       40
       -
       ./3-register-with-coves.sh

     

       44
       44
       +
       # Steps 2-3: OPTIONAL - Only if you want a custom domain handle

     

       45
       45
       +
       # ./2-setup-wellknown.sh

     

       46
       46
       +
       # ./3-register-with-coves.sh  (after uploading .well-known)

     

       41
       47
        
       

     

       42
       48
        
       # Step 4: Create service declaration

     

       43
       49
        
       ./4-create-service-declaration.sh

     

       50
       50
       +
       

     

       51
       51
       +
       # Step 5: Generate API key (requires browser for OAuth)

     

       52
       52
       +
       ./5-create-api-key.sh

     

       44
       53
        
       ```

     

       45
       54
        
       

     

       55
       55
       +
       **Minimal setup** (PDS handle only): Steps 1, 4, 5

     

       56
       56
       +
       **Custom domain**: Steps 1, 2, 3, 4, 5

     

       57
       57
       +
       

     

       46
       58
        
       ### Automated Setup Example

     

       47
       59
        
       

     

       48
       60
        
       For a reference implementation of automated setup, see the Kagi News aggregator at [aggregators/kagi-news/scripts/setup.sh](../../aggregators/kagi-news/scripts/setup.sh).

     
···

       134
       146
        
       - Updates `aggregator-config.env` with record URI and CID

     

       135
       147
        
       - Prints record details

     

       136
       148
        
       

     

       149
       149
       +
       ### 5-create-api-key.sh

     

       150
       150
       +
       

     

       151
       151
       +
       **Purpose**: Generates an API key for aggregator authentication

     

       152
       152
       +
       

     

       153
       153
       +
       **Prerequisites**:

     

       154
       154
       +
       - Steps 1-4 completed

     

       155
       155
       +
       - Aggregator indexed by Coves (usually takes a few seconds after step 4)

     

       156
       156
       +
       - Web browser for OAuth login

     

       157
       157
       +
       

     

       158
       158
       +
       **What it does**:

     

       159
       159
       +
       1. Guides you through OAuth login in your browser

     

       160
       160
       +
       2. Provides the JavaScript to call the `createApiKey` endpoint

     

       161
       161
       +
       3. Validates the API key format

     

       162
       162
       +
       4. Saves the key to your config file

     

       163
       163
       +
       

     

       164
       164
       +
       **Outputs**:

     

       165
       165
       +
       - Updates `aggregator-config.env` with `COVES_API_KEY`

     

       166
       166
       +
       - Provides instructions for updating your `.env` file

     

       167
       167
       +
       

     

       168
       168
       +
       **Important Notes**:

     

       169
       169
       +
       - The API key is shown **ONCE** and cannot be retrieved later

     

       170
       170
       +
       - API keys replace password-based authentication

     

       171
       171
       +
       - Keys can be revoked and regenerated at any time

     

       172
       172
       +
       - Store securely - never commit to version control

     

       173
       173
       +
       

     

       137
       174
        
       ## Configuration File

     

       138
       175
        
       

     

       139
       139
       -
       After running the scripts, you'll have an `aggregator-config.env` file with:

     

       176
       176
       +
       After running all scripts, you'll have an `aggregator-config.env` file with:

     

       140
       177
        
       

     

       141
       178
        
       ```bash

     

       179
       179
       +
       # Identity

     

       142
       180
        
       AGGREGATOR_DID="did:plc:..."

     

       143
       143
       -
       AGGREGATOR_HANDLE="mynewsbot.bsky.social"

     

       181
       181
       +
       AGGREGATOR_HANDLE="mynewsbot.example.com"

     

       144
       182
        
       AGGREGATOR_PDS_URL="https://bsky.social"

     

       145
       145
       -
       AGGREGATOR_EMAIL="bot@example.com"

     

       146
       146
       -
       AGGREGATOR_PASSWORD="..."

     

       147
       147
       -
       AGGREGATOR_ACCESS_JWT="..."

     

       148
       148
       -
       AGGREGATOR_REFRESH_JWT="..."

     

       149
       149
       -
       AGGREGATOR_DOMAIN="rss-bot.example.com"

     

       150
       150
       -
       COVES_INSTANCE_URL="https://api.coves.social"

     

       183
       183
       +
       AGGREGATOR_DOMAIN="mynewsbot.example.com"

     

       184
       184
       +
       

     

       185
       185
       +
       # Coves Instance

     

       186
       186
       +
       COVES_INSTANCE_URL="https://coves.social"

     

       151
       187
        
       SERVICE_DECLARATION_URI="at://did:plc:.../social.coves.aggregator.service/self"

     

       152
       188
        
       SERVICE_DECLARATION_CID="..."

     

       189
       189
       +
       

     

       190
       190
       +
       # API Key (from Step 5)

     

       191
       191
       +
       COVES_API_KEY="ckapi_..."

     

       153
       192
        
       ```

     

       154
       193
        
       

     

       155
       155
       -
       **Use this in your aggregator code** to authenticate and post.

     

       194
       194
       +
       **For your aggregator's `.env` file, you only need:**

     

       195
       195
       +
       

     

       196
       196
       +
       ```bash

     

       197
       197
       +
       COVES_API_KEY=ckapi_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

     

       198
       198
       +
       COVES_API_URL=https://coves.social

     

       199
       199
       +
       ```

     

       156
       200
        
       

     

       157
       201
        
       ## What Happens Next?

     

       158
       202
        
       

     

       159
       159
       -
       After completing all 4 steps:

     

       203
       203
       +
       After completing all 5 steps:

     

       160
       204
        
       

     

       161
       205
        
       1. **Your aggregator is registered** in the Coves instance's `users` table

     

       162
       206
        
       2. **Your service declaration is indexed** in the `aggregators` table (takes a few seconds)

     

       163
       163
       -
       3. **Community moderators can now authorize** your aggregator for their communities

     

       164
       164
       -
       4. **Once authorized**, your aggregator can post to those communities

     

       207
       207
       +
       3. **Your API key is stored** and can be used for authentication

     

       208
       208
       +
       4. **Community moderators can authorize** your aggregator for their communities

     

       209
       209
       +
       5. **Your aggregator can post** to authorized communities (or all if you're a trusted aggregator)

     

       165
       210
        
       

     

       166
       211
        
       ## Creating an Authorization

     

       167
       212
        
       

     
···

       171
       216
        
       

     

       172
       217
        
       ## Posting to Communities

     

       173
       218
        
       

     

       174
       174
       -
       Once authorized, your aggregator can post using:

     

       219
       219
       +
       Once authorized, your aggregator can post using your API key:

     

       175
       220
        
       

     

       176
       221
        
       ```bash

     

       177
       177
       -
       curl -X POST https://api.coves.social/xrpc/social.coves.community.post.create \

     

       178
       178
       -
         -H "Authorization: DPoP $AGGREGATOR_ACCESS_JWT" \

     

       222
       222
       +
       curl -X POST https://coves.social/xrpc/social.coves.community.post.create \

     

       223
       223
       +
         -H "Authorization: Bearer $COVES_API_KEY" \

     

       179
       224
        
         -H "Content-Type: application/json" \

     

       180
       225
        
         -d '{

     

       181
       181
       -
           "communityDid": "did:plc:...",

     

       182
       182
       -
           "post": {

     

       183
       183
       -
             "text": "Your post content",

     

       184
       184
       -
             "createdAt": "2024-01-15T12:00:00Z"

     

       185
       185
       -
           }

     

       226
       226
       +
           "community": "c-worldnews.coves.social",

     

       227
       227
       +
           "content": "Your post content",

     

       228
       228
       +
           "facets": []

     

       186
       229
        
         }'

     

       187
       230
        
       ```

     

       188
       231
        
       

     

       232
       232
       +
       The API key handles all authentication - no OAuth token refresh needed.

     

       233
       233
       +
       

     

       189
       234
        
       ## Troubleshooting

     

       190
       235
        
       

     

       191
       236
        
       ### Error: "DomainVerificationFailed"

+200

scripts/setup_dev_aggregator.go

···

       1
       1
       +
       // setup_dev_aggregator.go - Creates a local test aggregator on the local PDS

     

       2
       2
       +
       //

     

       3
       3
       +
       // This script creates an aggregator account on the local PDS for development testing.

     

       4
       4
       +
       // After running, you'll need to:

     

       5
       5
       +
       // 1. Register the aggregator via OAuth UI

     

       6
       6
       +
       // 2. Generate an API key via the createApiKey endpoint

     

       7
       7
       +
       //

     

       8
       8
       +
       // Usage: go run scripts/setup_dev_aggregator.go

     

       9
       9
       +
       package main

     

       10
       10
       +
       

     

       11
       11
       +
       import (

     

       12
       12
       +
       	"bytes"

     

       13
       13
       +
       	"context"

     

       14
       14
       +
       	"database/sql"

     

       15
       15
       +
       	"encoding/json"

     

       16
       16
       +
       	"fmt"

     

       17
       17
       +
       	"io"

     

       18
       18
       +
       	"log"

     

       19
       19
       +
       	"net/http"

     

       20
       20
       +
       

     

       21
       21
       +
       	_ "github.com/lib/pq"

     

       22
       22
       +
       )

     

       23
       23
       +
       

     

       24
       24
       +
       const (

     

       25
       25
       +
       	PDSURL      = "http://localhost:3001"

     

       26
       26
       +
       	DatabaseURL = "postgres://dev_user:dev_password@localhost:5435/coves_dev?sslmode=disable"

     

       27
       27
       +
       )

     

       28
       28
       +
       

     

       29
       29
       +
       type CreateAccountRequest struct {

     

       30
       30
       +
       	Email    string `json:"email"`

     

       31
       31
       +
       	Handle   string `json:"handle"`

     

       32
       32
       +
       	Password string `json:"password"`

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       type CreateAccountResponse struct {

     

       36
       36
       +
       	DID       string `json:"did"`

     

       37
       37
       +
       	Handle    string `json:"handle"`

     

       38
       38
       +
       	AccessJWT string `json:"accessJwt"`

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       type CreateSessionRequest struct {

     

       42
       42
       +
       	Identifier string `json:"identifier"`

     

       43
       43
       +
       	Password   string `json:"password"`

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       type CreateSessionResponse struct {

     

       47
       47
       +
       	DID       string `json:"did"`

     

       48
       48
       +
       	Handle    string `json:"handle"`

     

       49
       49
       +
       	AccessJWT string `json:"accessJwt"`

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       func main() {

     

       53
       53
       +
       	ctx := context.Background()

     

       54
       54
       +
       

     

       55
       55
       +
       	// Configuration

     

       56
       56
       +
       	handle := "test-aggregator.local.coves.dev"

     

       57
       57
       +
       	email := "test-aggregator@example.com"

     

       58
       58
       +
       	password := "test-password-12345"

     

       59
       59
       +
       	displayName := "Test Aggregator (Dev)"

     

       60
       60
       +
       

     

       61
       61
       +
       	log.Printf("Setting up dev aggregator: %s", handle)

     

       62
       62
       +
       

     

       63
       63
       +
       	// Connect to database

     

       64
       64
       +
       	db, err := sql.Open("postgres", DatabaseURL)

     

       65
       65
       +
       	if err != nil {

     

       66
       66
       +
       		log.Fatalf("Failed to connect to database: %v", err)

     

       67
       67
       +
       	}

     

       68
       68
       +
       	defer db.Close()

     

       69
       69
       +
       

     

       70
       70
       +
       	// Step 1: Try to create account on PDS (or get existing session)

     

       71
       71
       +
       	log.Printf("Creating account on PDS: %s", PDSURL)

     

       72
       72
       +
       

     

       73
       73
       +
       	var did string

     

       74
       74
       +
       

     

       75
       75
       +
       	// First try to create account

     

       76
       76
       +
       	createResp, err := createAccount(handle, email, password)

     

       77
       77
       +
       	if err != nil {

     

       78
       78
       +
       		log.Printf("Account creation failed (may already exist): %v", err)

     

       79
       79
       +
       		log.Printf("Trying to create session with existing account...")

     

       80
       80
       +
       

     

       81
       81
       +
       		// Try to login instead

     

       82
       82
       +
       		sessionResp, err := createSession(handle, password)

     

       83
       83
       +
       		if err != nil {

     

       84
       84
       +
       			log.Fatalf("Failed to create session: %v", err)

     

       85
       85
       +
       		}

     

       86
       86
       +
       		did = sessionResp.DID

     

       87
       87
       +
       		log.Printf("Logged in as existing account: %s", did)

     

       88
       88
       +
       	} else {

     

       89
       89
       +
       		did = createResp.DID

     

       90
       90
       +
       		log.Printf("Created new account: %s", did)

     

       91
       91
       +
       	}

     

       92
       92
       +
       

     

       93
       93
       +
       	// Step 2: Check if already in users table

     

       94
       94
       +
       	var existingHandle string

     

       95
       95
       +
       	err = db.QueryRowContext(ctx, "SELECT handle FROM users WHERE did = $1", did).Scan(&existingHandle)

     

       96
       96
       +
       	if err == nil {

     

       97
       97
       +
       		log.Printf("User already exists in users table: %s", existingHandle)

     

       98
       98
       +
       	} else {

     

       99
       99
       +
       		// Insert into users table

     

       100
       100
       +
       		log.Printf("Inserting user into users table...")

     

       101
       101
       +
       		_, err = db.ExecContext(ctx, `

     

       102
       102
       +
       			INSERT INTO users (did, handle, pds_url)

     

       103
       103
       +
       			VALUES ($1, $2, $3)

     

       104
       104
       +
       			ON CONFLICT (did) DO UPDATE SET handle = $2

     

       105
       105
       +
       		`, did, handle, PDSURL)

     

       106
       106
       +
       		if err != nil {

     

       107
       107
       +
       			log.Fatalf("Failed to insert user: %v", err)

     

       108
       108
       +
       		}

     

       109
       109
       +
       	}

     

       110
       110
       +
       

     

       111
       111
       +
       	// Step 3: Check if already in aggregators table

     

       112
       112
       +
       	var existingAggDID string

     

       113
       113
       +
       	err = db.QueryRowContext(ctx, "SELECT did FROM aggregators WHERE did = $1", did).Scan(&existingAggDID)

     

       114
       114
       +
       	if err == nil {

     

       115
       115
       +
       		log.Printf("Aggregator already exists in aggregators table")

     

       116
       116
       +
       	} else {

     

       117
       117
       +
       		// Insert into aggregators table

     

       118
       118
       +
       		log.Printf("Inserting aggregator into aggregators table...")

     

       119
       119
       +
       		recordURI := fmt.Sprintf("at://%s/social.coves.aggregator.declaration/self", did)

     

       120
       120
       +
       		recordCID := "dev-placeholder-cid"

     

       121
       121
       +
       

     

       122
       122
       +
       		_, err = db.ExecContext(ctx, `

     

       123
       123
       +
       			INSERT INTO aggregators (did, display_name, description, record_uri, record_cid, created_at, indexed_at)

     

       124
       124
       +
       			VALUES ($1, $2, $3, $4, $5, NOW(), NOW())

     

       125
       125
       +
       		`, did, displayName, "Development test aggregator", recordURI, recordCID)

     

       126
       126
       +
       		if err != nil {

     

       127
       127
       +
       			log.Fatalf("Failed to insert aggregator: %v", err)

     

       128
       128
       +
       		}

     

       129
       129
       +
       	}

     

       130
       130
       +
       

     

       131
       131
       +
       	fmt.Println()

     

       132
       132
       +
       	fmt.Println("========================================")

     

       133
       133
       +
       	fmt.Println("  DEV AGGREGATOR ACCOUNT CREATED")

     

       134
       134
       +
       	fmt.Println("========================================")

     

       135
       135
       +
       	fmt.Println()

     

       136
       136
       +
       	fmt.Printf("  DID:      %s\n", did)

     

       137
       137
       +
       	fmt.Printf("  Handle:   %s\n", handle)

     

       138
       138
       +
       	fmt.Printf("  Password: %s\n", password)

     

       139
       139
       +
       	fmt.Println()

     

       140
       140
       +
       	fmt.Println("  Next steps:")

     

       141
       141
       +
       	fmt.Println("  1. Start Coves server: make run")

     

       142
       142
       +
       	fmt.Println("  2. Authenticate as this account via OAuth UI")

     

       143
       143
       +
       	fmt.Println("  3. Call POST /xrpc/social.coves.aggregator.createApiKey")

     

       144
       144
       +
       	fmt.Println("  4. Save the API key and add to aggregators/kagi-news/.env")

     

       145
       145
       +
       	fmt.Println()

     

       146
       146
       +
       	fmt.Println("========================================")

     

       147
       147
       +
       }

     

       148
       148
       +
       

     

       149
       149
       +
       func createAccount(handle, email, password string) (*CreateAccountResponse, error) {

     

       150
       150
       +
       	reqBody := CreateAccountRequest{

     

       151
       151
       +
       		Email:    email,

     

       152
       152
       +
       		Handle:   handle,

     

       153
       153
       +
       		Password: password,

     

       154
       154
       +
       	}

     

       155
       155
       +
       

     

       156
       156
       +
       	body, _ := json.Marshal(reqBody)

     

       157
       157
       +
       	resp, err := http.Post(PDSURL+"/xrpc/com.atproto.server.createAccount", "application/json", bytes.NewReader(body))

     

       158
       158
       +
       	if err != nil {

     

       159
       159
       +
       		return nil, fmt.Errorf("request failed: %w", err)

     

       160
       160
       +
       	}

     

       161
       161
       +
       	defer resp.Body.Close()

     

       162
       162
       +
       

     

       163
       163
       +
       	respBody, _ := io.ReadAll(resp.Body)

     

       164
       164
       +
       	if resp.StatusCode != http.StatusOK {

     

       165
       165
       +
       		return nil, fmt.Errorf("status %d: %s", resp.StatusCode, string(respBody))

     

       166
       166
       +
       	}

     

       167
       167
       +
       

     

       168
       168
       +
       	var result CreateAccountResponse

     

       169
       169
       +
       	if err := json.Unmarshal(respBody, &result); err != nil {

     

       170
       170
       +
       		return nil, fmt.Errorf("failed to parse response: %w", err)

     

       171
       171
       +
       	}

     

       172
       172
       +
       

     

       173
       173
       +
       	return &result, nil

     

       174
       174
       +
       }

     

       175
       175
       +
       

     

       176
       176
       +
       func createSession(identifier, password string) (*CreateSessionResponse, error) {

     

       177
       177
       +
       	reqBody := CreateSessionRequest{

     

       178
       178
       +
       		Identifier: identifier,

     

       179
       179
       +
       		Password:   password,

     

       180
       180
       +
       	}

     

       181
       181
       +
       

     

       182
       182
       +
       	body, _ := json.Marshal(reqBody)

     

       183
       183
       +
       	resp, err := http.Post(PDSURL+"/xrpc/com.atproto.server.createSession", "application/json", bytes.NewReader(body))

     

       184
       184
       +
       	if err != nil {

     

       185
       185
       +
       		return nil, fmt.Errorf("request failed: %w", err)

     

       186
       186
       +
       	}

     

       187
       187
       +
       	defer resp.Body.Close()

     

       188
       188
       +
       

     

       189
       189
       +
       	respBody, _ := io.ReadAll(resp.Body)

     

       190
       190
       +
       	if resp.StatusCode != http.StatusOK {

     

       191
       191
       +
       		return nil, fmt.Errorf("status %d: %s", resp.StatusCode, string(respBody))

     

       192
       192
       +
       	}

     

       193
       193
       +
       

     

       194
       194
       +
       	var result CreateSessionResponse

     

       195
       195
       +
       	if err := json.Unmarshal(respBody, &result); err != nil {

     

       196
       196
       +
       		return nil, fmt.Errorf("failed to parse response: %w", err)

     

       197
       197
       +
       	}

     

       198
       198
       +
       

     

       199
       199
       +
       	return &result, nil

     

       200
       200
       +
       }

+2 -1

aggregators/kagi-news/crontab

···

       1
       1
        
       # Run Kagi News aggregator daily at 1 PM UTC (after Kagi updates around noon)

     

       2
       2
       -
       0 13 * * * cd /app && /usr/local/bin/python -m src.main >> /var/log/cron.log 2>&1

     

       2
       2
       +
       # Source environment variables exported by docker-entrypoint.sh

     

       3
       3
       +
       0 13 * * * . /etc/environment; cd /app && /usr/local/bin/python -m src.main >> /var/log/cron.log 2>&1

     

       3
       4
        
       

     

       4
       5
        
       # Blank line required at end of crontab

     

       5
       6

+6 -6

internal/core/blobs/service.go

···

       90
       90
        
       		return nil, fmt.Errorf("failed to read image data: %w", err)

     

       91
       91
        
       	}

     

       92
       92
        
       

     

       93
       93
       -
       	// Validate size (1MB = 1048576 bytes)

     

       94
       94
       -
       	const maxSize = 1048576

     

       93
       93
       +
       	// Validate size (6MB = 6291456 bytes)

     

       94
       94
       +
       	const maxSize = 6291456

     

       95
       95
        
       	if len(data) > maxSize {

     

       96
       96
       -
       		return nil, fmt.Errorf("image size %d bytes exceeds maximum of %d bytes (1MB)", len(data), maxSize)

     

       96
       96
       +
       		return nil, fmt.Errorf("image size %d bytes exceeds maximum of %d bytes (6MB)", len(data), maxSize)

     

       97
       97
        
       	}

     

       98
       98
        
       

     

       99
       99
        
       	// Upload to PDS

     
···

       124
       124
        
       		return nil, fmt.Errorf("unsupported MIME type: %s (allowed: image/jpeg, image/png, image/webp)", mimeType)

     

       125
       125
        
       	}

     

       126
       126
        
       

     

       127
       127
       -
       	// Validate size (1MB = 1048576 bytes)

     

       128
       128
       -
       	const maxSize = 1048576

     

       127
       127
       +
       	// Validate size (6MB = 6291456 bytes)

     

       128
       128
       +
       	const maxSize = 6291456

     

       129
       129
        
       	if len(data) > maxSize {

     

       130
       130
       -
       		return nil, fmt.Errorf("data size %d bytes exceeds maximum of %d bytes (1MB)", len(data), maxSize)

     

       130
       130
       +
       		return nil, fmt.Errorf("data size %d bytes exceeds maximum of %d bytes (6MB)", len(data), maxSize)

     

       131
       131
        
       	}

     

       132
       132
        
       

     

       133
       133
        
       	// Use community's PDS URL (for federated communities)

+28 -17

internal/db/postgres/feed_repo_base.go

···

       192
       192
        
       		return filter, []interface{}{score, createdAt, uri}, nil

     

       193
       193
        
       

     

       194
       194
        
       	case "hot":

     

       195
       195
       -
       		// Cursor format: hot_rank::timestamp::uri

     

       196
       196
       -
       		// CRITICAL: Must use computed hot_rank, not raw score, to prevent pagination bugs

     

       197
       197
       -
       		if len(payloadParts) != 3 {

     

       195
       195
       +
       		// Cursor format: hot_rank::post_created_at::uri::cursor_timestamp

     

       196
       196
       +
       		// CRITICAL: cursor_timestamp is when the cursor was created, used for stable hot_rank comparison

     

       197
       197
       +
       		// This prevents pagination bugs caused by hot_rank drift when NOW() changes between requests

     

       198
       198
       +
       		if len(payloadParts) != 4 {

     

       198
       199
        
       			return "", nil, fmt.Errorf("invalid cursor format for hot sort")

     

       199
       200
        
       		}

     

       200
       201
        
       

     

       201
       202
        
       		hotRankStr := payloadParts[0]

     

       202
       202
       -
       		createdAt := payloadParts[1]

     

       203
       203
       +
       		postCreatedAt := payloadParts[1]

     

       203
       204
        
       		uri := payloadParts[2]

     

       205
       205
       +
       		cursorTimestamp := payloadParts[3]

     

       204
       206
        
       

     

       205
       207
        
       		// Validate hot_rank is numeric (float)

     

       206
       208
        
       		hotRank := 0.0

     
···

       208
       210
        
       			return "", nil, fmt.Errorf("invalid cursor hot rank")

     

       209
       211
        
       		}

     

       210
       212
        
       

     

       211
       211
       -
       		// Validate timestamp format

     

       212
       212
       -
       		if _, err := time.Parse(time.RFC3339Nano, createdAt); err != nil {

     

       213
       213
       -
       			return "", nil, fmt.Errorf("invalid cursor timestamp")

     

       213
       213
       +
       		// Validate post timestamp format

     

       214
       214
       +
       		if _, err := time.Parse(time.RFC3339Nano, postCreatedAt); err != nil {

     

       215
       215
       +
       			return "", nil, fmt.Errorf("invalid cursor post timestamp")

     

       214
       216
        
       		}

     

       215
       217
        
       

     

       216
       218
        
       		// Validate URI format (must be AT-URI)

     
···

       218
       220
        
       			return "", nil, fmt.Errorf("invalid cursor URI")

     

       219
       221
        
       		}

     

       220
       222
        
       

     

       221
       221
       -
       		// CRITICAL: Compare against the computed hot_rank expression, not p.score

     

       222
       222
       -
       		filter := fmt.Sprintf(`AND ((%s < $%d OR (%s = $%d AND p.created_at < $%d) OR (%s = $%d AND p.created_at = $%d AND p.uri < $%d)) AND p.uri != $%d)`,

     

       223
       223
       -
       			r.hotRankExpression, paramOffset,

     

       224
       224
       -
       			r.hotRankExpression, paramOffset, paramOffset+1,

     

       225
       225
       -
       			r.hotRankExpression, paramOffset, paramOffset+1, paramOffset+2,

     

       223
       223
       +
       		// Validate cursor timestamp format

     

       224
       224
       +
       		if _, err := time.Parse(time.RFC3339Nano, cursorTimestamp); err != nil {

     

       225
       225
       +
       			return "", nil, fmt.Errorf("invalid cursor timestamp")

     

       226
       226
       +
       		}

     

       227
       227
       +
       

     

       228
       228
       +
       		// CRITICAL: Use cursor_timestamp instead of NOW() for stable hot_rank comparison

     

       229
       229
       +
       		// This ensures posts don't drift across page boundaries due to time passing

     

       230
       230
       +
       		stableHotRankExpr := fmt.Sprintf(

     

       231
       231
       +
       			`((p.score + 1) / POWER(EXTRACT(EPOCH FROM ($%d::timestamptz - p.created_at))/3600 + 2, 1.5))`,

     

       226
       232
        
       			paramOffset+3)

     

       227
       227
       -
       		return filter, []interface{}{hotRank, createdAt, uri, uri}, nil

     

       233
       233
       +
       

     

       234
       234
       +
       		// Use tuple comparison for clean keyset pagination: (hot_rank, created_at, uri) < (cursor_values)

     

       235
       235
       +
       		filter := fmt.Sprintf(`AND ((%s, p.created_at, p.uri) < ($%d, $%d, $%d))`,

     

       236
       236
       +
       			stableHotRankExpr, paramOffset, paramOffset+1, paramOffset+2)

     

       237
       237
       +
       		return filter, []interface{}{hotRank, postCreatedAt, uri, cursorTimestamp}, nil

     

       228
       238
        
       

     

       229
       239
        
       	default:

     

       230
       240
        
       		return "", nil, nil

     
···

       233
       243
        
       

     

       234
       244
        
       // buildCursor creates HMAC-signed pagination cursor from last post

     

       235
       245
        
       // SECURITY: Cursor is signed with HMAC-SHA256 to prevent manipulation

     

       236
       236
       -
       func (r *feedRepoBase) buildCursor(post *posts.PostView, sort string, hotRank float64) string {

     

       246
       246
       +
       // queryTime is the timestamp when the query was executed, used for stable hot_rank comparison

     

       247
       247
       +
       func (r *feedRepoBase) buildCursor(post *posts.PostView, sort string, hotRank float64, queryTime time.Time) string {

     

       237
       248
        
       	var payload string

     

       238
       249
        
       	// Use :: as delimiter following Bluesky convention

     

       239
       250
        
       	const delimiter = "::"

     
···

       252
       263
        
       		payload = fmt.Sprintf("%d%s%s%s%s", score, delimiter, post.CreatedAt.Format(time.RFC3339Nano), delimiter, post.URI)

     

       253
       264
        
       

     

       254
       265
        
       	case "hot":

     

       255
       255
       -
       		// Format: hot_rank::timestamp::uri

     

       256
       256
       -
       		// CRITICAL: Use computed hot_rank with full precision

     

       266
       266
       +
       		// Format: hot_rank::post_created_at::uri::cursor_timestamp

     

       267
       267
       +
       		// CRITICAL: Include cursor_timestamp for stable hot_rank comparison across requests

     

       257
       268
        
       		hotRankStr := strconv.FormatFloat(hotRank, 'g', -1, 64)

     

       258
       258
       -
       		payload = fmt.Sprintf("%s%s%s%s%s", hotRankStr, delimiter, post.CreatedAt.Format(time.RFC3339Nano), delimiter, post.URI)

     

       269
       269
       +
       		payload = fmt.Sprintf("%s%s%s%s%s%s%s", hotRankStr, delimiter, post.CreatedAt.Format(time.RFC3339Nano), delimiter, post.URI, delimiter, queryTime.Format(time.RFC3339Nano))

     

       259
       270
        
       

     

       260
       271
        
       	default:

     

       261
       272
        
       		payload = post.URI

+13 -1

internal/core/users/errors.go

···

       1
       1
        
       package users

     

       2
       2
        
       

     

       3
       3
       -
       import "fmt"

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"errors"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       // Sentinel errors for common user operations

     

       9
       9
       +
       var (

     

       10
       10
       +
       	// ErrUserNotFound is returned when a user lookup finds no matching record

     

       11
       11
       +
       	ErrUserNotFound = errors.New("user not found")

     

       12
       12
       +
       

     

       13
       13
       +
       	// ErrHandleAlreadyTaken is returned when attempting to use a handle that belongs to another user

     

       14
       14
       +
       	ErrHandleAlreadyTaken = errors.New("handle already taken")

     

       15
       15
       +
       )

     

       4
       16
        
       

     

       5
       17
        
       // Domain errors for user service operations

     

       6
       18
        
       // These map to lexicon error types defined in social.coves.actor.signup

+94

internal/api/handlers/actor/errors.go

···

       1
       1
       +
       package actor

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"errors"

     

       6
       6
       +
       	"fmt"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"net/http"

     

       9
       9
       +
       

     

       10
       10
       +
       	"Coves/internal/core/posts"

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       // ErrorResponse represents an XRPC error response

     

       14
       14
       +
       type ErrorResponse struct {

     

       15
       15
       +
       	Error   string `json:"error"`

     

       16
       16
       +
       	Message string `json:"message"`

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       // writeError writes a JSON error response

     

       20
       20
       +
       func writeError(w http.ResponseWriter, statusCode int, errorType, message string) {

     

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

     

       22
       22
       +
       	w.WriteHeader(statusCode)

     

       23
       23
       +
       	if err := json.NewEncoder(w).Encode(ErrorResponse{

     

       24
       24
       +
       		Error:   errorType,

     

       25
       25
       +
       		Message: message,

     

       26
       26
       +
       	}); err != nil {

     

       27
       27
       +
       		// Log encoding errors but can't send error response (headers already sent)

     

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

     

       29
       29
       +
       	}

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       // handleServiceError maps service errors to HTTP responses

     

       33
       33
       +
       func handleServiceError(w http.ResponseWriter, err error) {

     

       34
       34
       +
       	// Check for handler-level errors first

     

       35
       35
       +
       	var actorNotFound *actorNotFoundError

     

       36
       36
       +
       	if errors.As(err, &actorNotFound) {

     

       37
       37
       +
       		writeError(w, http.StatusNotFound, "ActorNotFound", "Actor not found")

     

       38
       38
       +
       		return

     

       39
       39
       +
       	}

     

       40
       40
       +
       

     

       41
       41
       +
       	// Check for service-level errors

     

       42
       42
       +
       	switch {

     

       43
       43
       +
       	case errors.Is(err, posts.ErrNotFound):

     

       44
       44
       +
       		writeError(w, http.StatusNotFound, "ActorNotFound", "Actor not found")

     

       45
       45
       +
       

     

       46
       46
       +
       	case errors.Is(err, posts.ErrActorNotFound):

     

       47
       47
       +
       		writeError(w, http.StatusNotFound, "ActorNotFound", "Actor not found")

     

       48
       48
       +
       

     

       49
       49
       +
       	case errors.Is(err, posts.ErrCommunityNotFound):

     

       50
       50
       +
       		writeError(w, http.StatusNotFound, "CommunityNotFound", "Community not found")

     

       51
       51
       +
       

     

       52
       52
       +
       	case errors.Is(err, posts.ErrInvalidCursor):

     

       53
       53
       +
       		writeError(w, http.StatusBadRequest, "InvalidCursor", "Invalid pagination cursor")

     

       54
       54
       +
       

     

       55
       55
       +
       	case posts.IsValidationError(err):

     

       56
       56
       +
       		// Extract message from ValidationError for cleaner response

     

       57
       57
       +
       		var valErr *posts.ValidationError

     

       58
       58
       +
       		if errors.As(err, &valErr) {

     

       59
       59
       +
       			writeError(w, http.StatusBadRequest, "InvalidRequest", valErr.Message)

     

       60
       60
       +
       		} else {

     

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

     

       62
       62
       +
       		}

     

       63
       63
       +
       

     

       64
       64
       +
       	default:

     

       65
       65
       +
       		// Internal server error - don't leak details

     

       66
       66
       +
       		log.Printf("ERROR: Actor posts service error: %v", err)

     

       67
       67
       +
       		writeError(w, http.StatusInternalServerError, "InternalServerError", "An internal error occurred")

     

       68
       68
       +
       	}

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       // actorNotFoundError represents an actor not found error

     

       72
       72
       +
       type actorNotFoundError struct {

     

       73
       73
       +
       	actor string

     

       74
       74
       +
       }

     

       75
       75
       +
       

     

       76
       76
       +
       func (e *actorNotFoundError) Error() string {

     

       77
       77
       +
       	return fmt.Sprintf("actor not found: %s", e.actor)

     

       78
       78
       +
       }

     

       79
       79
       +
       

     

       80
       80
       +
       // resolutionFailedError represents an infrastructure failure during resolution

     

       81
       81
       +
       // (database down, DNS failures, TLS errors, etc.)

     

       82
       82
       +
       // This is distinct from actorNotFoundError to avoid masking real problems as "not found"

     

       83
       83
       +
       type resolutionFailedError struct {

     

       84
       84
       +
       	actor string

     

       85
       85
       +
       	cause error

     

       86
       86
       +
       }

     

       87
       87
       +
       

     

       88
       88
       +
       func (e *resolutionFailedError) Error() string {

     

       89
       89
       +
       	return fmt.Sprintf("failed to resolve actor %s: %v", e.actor, e.cause)

     

       90
       90
       +
       }

     

       91
       91
       +
       

     

       92
       92
       +
       func (e *resolutionFailedError) Unwrap() error {

     

       93
       93
       +
       	return e.cause

     

       94
       94
       +
       }

+185

internal/api/handlers/actor/get_posts.go

···

       1
       1
       +
       package actor

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"errors"

     

       6
       6
       +
       	"log"

     

       7
       7
       +
       	"net/http"

     

       8
       8
       +
       	"strconv"

     

       9
       9
       +
       	"strings"

     

       10
       10
       +
       

     

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

     

       12
       12
       +
       	"Coves/internal/api/middleware"

     

       13
       13
       +
       	"Coves/internal/core/blueskypost"

     

       14
       14
       +
       	"Coves/internal/core/posts"

     

       15
       15
       +
       	"Coves/internal/core/users"

     

       16
       16
       +
       	"Coves/internal/core/votes"

     

       17
       17
       +
       )

     

       18
       18
       +
       

     

       19
       19
       +
       // GetPostsHandler handles actor post retrieval

     

       20
       20
       +
       type GetPostsHandler struct {

     

       21
       21
       +
       	postService    posts.Service

     

       22
       22
       +
       	userService    users.UserService

     

       23
       23
       +
       	voteService    votes.Service

     

       24
       24
       +
       	blueskyService blueskypost.Service

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       // NewGetPostsHandler creates a new actor posts handler

     

       28
       28
       +
       func NewGetPostsHandler(

     

       29
       29
       +
       	postService posts.Service,

     

       30
       30
       +
       	userService users.UserService,

     

       31
       31
       +
       	voteService votes.Service,

     

       32
       32
       +
       	blueskyService blueskypost.Service,

     

       33
       33
       +
       ) *GetPostsHandler {

     

       34
       34
       +
       	if blueskyService == nil {

     

       35
       35
       +
       		log.Printf("[ACTOR-HANDLER] WARNING: blueskyService is nil - Bluesky post embeds will not be resolved")

     

       36
       36
       +
       	}

     

       37
       37
       +
       	return &GetPostsHandler{

     

       38
       38
       +
       		postService:    postService,

     

       39
       39
       +
       		userService:    userService,

     

       40
       40
       +
       		voteService:    voteService,

     

       41
       41
       +
       		blueskyService: blueskyService,

     

       42
       42
       +
       	}

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       // HandleGetPosts retrieves posts by an actor (user)

     

       46
       46
       +
       // GET /xrpc/social.coves.actor.getPosts?actor={did_or_handle}&filter=posts_with_replies&community=...&limit=50&cursor=...

     

       47
       47
       +
       func (h *GetPostsHandler) HandleGetPosts(w http.ResponseWriter, r *http.Request) {

     

       48
       48
       +
       	if r.Method != http.MethodGet {

     

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

     

       50
       50
       +
       		return

     

       51
       51
       +
       	}

     

       52
       52
       +
       

     

       53
       53
       +
       	// Parse query parameters

     

       54
       54
       +
       	req, err := h.parseRequest(r)

     

       55
       55
       +
       	if err != nil {

     

       56
       56
       +
       		// Check if it's an actor not found error (from handle resolution)

     

       57
       57
       +
       		var actorNotFound *actorNotFoundError

     

       58
       58
       +
       		if errors.As(err, &actorNotFound) {

     

       59
       59
       +
       			writeError(w, http.StatusNotFound, "ActorNotFound", "Actor not found")

     

       60
       60
       +
       			return

     

       61
       61
       +
       		}

     

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

     

       63
       63
       +
       		return

     

       64
       64
       +
       	}

     

       65
       65
       +
       

     

       66
       66
       +
       	// Get viewer DID for populating viewer state (optional)

     

       67
       67
       +
       	viewerDID := middleware.GetUserDID(r)

     

       68
       68
       +
       	req.ViewerDID = viewerDID

     

       69
       69
       +
       

     

       70
       70
       +
       	// Get actor posts from service

     

       71
       71
       +
       	response, err := h.postService.GetAuthorPosts(r.Context(), req)

     

       72
       72
       +
       	if err != nil {

     

       73
       73
       +
       		handleServiceError(w, err)

     

       74
       74
       +
       		return

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	// Populate viewer vote state if authenticated

     

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

     

       79
       79
       +
       

     

       80
       80
       +
       	// Transform blob refs to URLs and resolve post embeds for all posts

     

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

     

       82
       82
       +
       		if feedPost.Post != nil {

     

       83
       83
       +
       			posts.TransformBlobRefsToURLs(feedPost.Post)

     

       84
       84
       +
       			posts.TransformPostEmbeds(r.Context(), feedPost.Post, h.blueskyService)

     

       85
       85
       +
       		}

     

       86
       86
       +
       	}

     

       87
       87
       +
       

     

       88
       88
       +
       	// Pre-encode response to buffer before writing headers

     

       89
       89
       +
       	// This ensures we can return a proper error if encoding fails

     

       90
       90
       +
       	responseBytes, err := json.Marshal(response)

     

       91
       91
       +
       	if err != nil {

     

       92
       92
       +
       		log.Printf("ERROR: Failed to encode actor posts response: %v", err)

     

       93
       93
       +
       		writeError(w, http.StatusInternalServerError, "InternalServerError", "Failed to encode response")

     

       94
       94
       +
       		return

     

       95
       95
       +
       	}

     

       96
       96
       +
       

     

       97
       97
       +
       	// Return feed

     

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

     

       99
       99
       +
       	w.WriteHeader(http.StatusOK)

     

       100
       100
       +
       	if _, err := w.Write(responseBytes); err != nil {

     

       101
       101
       +
       		log.Printf("ERROR: Failed to write actor posts response: %v", err)

     

       102
       102
       +
       	}

     

       103
       103
       +
       }

     

       104
       104
       +
       

     

       105
       105
       +
       // parseRequest parses query parameters into GetAuthorPostsRequest

     

       106
       106
       +
       func (h *GetPostsHandler) parseRequest(r *http.Request) (posts.GetAuthorPostsRequest, error) {

     

       107
       107
       +
       	req := posts.GetAuthorPostsRequest{}

     

       108
       108
       +
       

     

       109
       109
       +
       	// Required: actor (handle or DID)

     

       110
       110
       +
       	actor := r.URL.Query().Get("actor")

     

       111
       111
       +
       	if actor == "" {

     

       112
       112
       +
       		return req, posts.NewValidationError("actor", "actor parameter is required")

     

       113
       113
       +
       	}

     

       114
       114
       +
       	// Validate actor length to prevent DoS via massive strings

     

       115
       115
       +
       	// Max DID length is ~2048 chars (did:plc: is 8 + 24 base32 = 32, but did:web: can be longer)

     

       116
       116
       +
       	// Max handle length is 253 chars (DNS limit)

     

       117
       117
       +
       	const maxActorLength = 2048

     

       118
       118
       +
       	if len(actor) > maxActorLength {

     

       119
       119
       +
       		return req, posts.NewValidationError("actor", "actor parameter exceeds maximum length")

     

       120
       120
       +
       	}

     

       121
       121
       +
       

     

       122
       122
       +
       	// Resolve actor to DID if it's a handle

     

       123
       123
       +
       	actorDID, err := h.resolveActor(r, actor)

     

       124
       124
       +
       	if err != nil {

     

       125
       125
       +
       		return req, err

     

       126
       126
       +
       	}

     

       127
       127
       +
       	req.ActorDID = actorDID

     

       128
       128
       +
       

     

       129
       129
       +
       	// Optional: filter (default: posts_with_replies)

     

       130
       130
       +
       	req.Filter = r.URL.Query().Get("filter")

     

       131
       131
       +
       

     

       132
       132
       +
       	// Optional: community (handle or DID)

     

       133
       133
       +
       	req.Community = r.URL.Query().Get("community")

     

       134
       134
       +
       

     

       135
       135
       +
       	// Optional: limit (default: 50, max: 100)

     

       136
       136
       +
       	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {

     

       137
       137
       +
       		limit, err := strconv.Atoi(limitStr)

     

       138
       138
       +
       		if err != nil {

     

       139
       139
       +
       			return req, posts.NewValidationError("limit", "limit must be a valid integer")

     

       140
       140
       +
       		}

     

       141
       141
       +
       		req.Limit = limit

     

       142
       142
       +
       	}

     

       143
       143
       +
       

     

       144
       144
       +
       	// Optional: cursor

     

       145
       145
       +
       	if cursor := r.URL.Query().Get("cursor"); cursor != "" {

     

       146
       146
       +
       		req.Cursor = &cursor

     

       147
       147
       +
       	}

     

       148
       148
       +
       

     

       149
       149
       +
       	return req, nil

     

       150
       150
       +
       }

     

       151
       151
       +
       

     

       152
       152
       +
       // resolveActor converts an actor identifier (handle or DID) to a DID

     

       153
       153
       +
       func (h *GetPostsHandler) resolveActor(r *http.Request, actor string) (string, error) {

     

       154
       154
       +
       	// If it's already a DID, return it

     

       155
       155
       +
       	if strings.HasPrefix(actor, "did:") {

     

       156
       156
       +
       		return actor, nil

     

       157
       157
       +
       	}

     

       158
       158
       +
       

     

       159
       159
       +
       	// It's a handle - resolve to DID using user service

     

       160
       160
       +
       	did, err := h.userService.ResolveHandleToDID(r.Context(), actor)

     

       161
       161
       +
       	if err != nil {

     

       162
       162
       +
       		// Check for context errors (timeouts, cancellation) - these are infrastructure errors

     

       163
       163
       +
       		if r.Context().Err() != nil {

     

       164
       164
       +
       			log.Printf("WARN: Handle resolution failed due to context error for %s: %v", actor, err)

     

       165
       165
       +
       			return "", &resolutionFailedError{actor: actor, cause: r.Context().Err()}

     

       166
       166
       +
       		}

     

       167
       167
       +
       

     

       168
       168
       +
       		// Check for common "not found" patterns in error message

     

       169
       169
       +
       		errStr := err.Error()

     

       170
       170
       +
       		isNotFound := strings.Contains(errStr, "not found") ||

     

       171
       171
       +
       			strings.Contains(errStr, "no rows") ||

     

       172
       172
       +
       			strings.Contains(errStr, "unable to resolve")

     

       173
       173
       +
       

     

       174
       174
       +
       		if isNotFound {

     

       175
       175
       +
       			return "", &actorNotFoundError{actor: actor}

     

       176
       176
       +
       		}

     

       177
       177
       +
       

     

       178
       178
       +
       		// For other errors (network, database, DNS failures), return infrastructure error

     

       179
       179
       +
       		// This ensures users see "internal error" not "actor not found" for real problems

     

       180
       180
       +
       		log.Printf("WARN: Handle resolution infrastructure failure for %s: %v", actor, err)

     

       181
       181
       +
       		return "", &resolutionFailedError{actor: actor, cause: err}

     

       182
       182
       +
       	}

     

       183
       183
       +
       

     

       184
       184
       +
       	return did, nil

     

       185
       185
       +
       }

+66

internal/atproto/lexicon/social/coves/actor/getPosts.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "social.coves.actor.getPosts",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get a user's posts for their profile page.",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": ["actor"],

     

       11
       11
       +
               "properties": {

     

       12
       12
       +
                 "actor": {

     

       13
       13
       +
                   "type": "string",

     

       14
       14
       +
                   "format": "at-identifier",

     

       15
       15
       +
                   "description": "DID or handle of the user"

     

       16
       16
       +
                 },

     

       17
       17
       +
                 "filter": {

     

       18
       18
       +
                   "type": "string",

     

       19
       19
       +
                   "knownValues": ["posts_with_replies", "posts_no_replies", "posts_with_media"],

     

       20
       20
       +
                   "default": "posts_with_replies",

     

       21
       21
       +
                   "description": "Filter for post types"

     

       22
       22
       +
                 },

     

       23
       23
       +
                 "community": {

     

       24
       24
       +
                   "type": "string",

     

       25
       25
       +
                   "format": "at-identifier",

     

       26
       26
       +
                   "description": "Filter to posts in a specific community"

     

       27
       27
       +
                 },

     

       28
       28
       +
                 "limit": {

     

       29
       29
       +
                   "type": "integer",

     

       30
       30
       +
                   "minimum": 1,

     

       31
       31
       +
                   "maximum": 100,

     

       32
       32
       +
                   "default": 50

     

       33
       33
       +
                 },

     

       34
       34
       +
                 "cursor": {

     

       35
       35
       +
                   "type": "string"

     

       36
       36
       +
                 }

     

       37
       37
       +
               }

     

       38
       38
       +
             },

     

       39
       39
       +
             "output": {

     

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

     

       41
       41
       +
               "schema": {

     

       42
       42
       +
                 "type": "object",

     

       43
       43
       +
                 "required": ["feed"],

     

       44
       44
       +
                 "properties": {

     

       45
       45
       +
                   "feed": {

     

       46
       46
       +
                     "type": "array",

     

       47
       47
       +
                     "items": {

     

       48
       48
       +
                       "type": "ref",

     

       49
       49
       +
                       "ref": "social.coves.feed.defs#feedViewPost"

     

       50
       50
       +
                     }

     

       51
       51
       +
                   },

     

       52
       52
       +
                   "cursor": {

     

       53
       53
       +
                     "type": "string"

     

       54
       54
       +
                   }

     

       55
       55
       +
                 }

     

       56
       56
       +
               }

     

       57
       57
       +
             },

     

       58
       58
       +
             "errors": [

     

       59
       59
       +
               {

     

       60
       60
       +
                 "name": "NotFound",

     

       61
       61
       +
                 "description": "Actor not found"

     

       62
       62
       +
               }

     

       63
       63
       +
             ]

     

       64
       64
       +
           }

     

       65
       65
       +
         }

     

       66
       66
       +
       }

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

     

       29
       29
       +
       	// ErrInvalidCursor is returned when a pagination cursor is malformed

     

       30
       30
       +
       	ErrInvalidCursor = errors.New("invalid pagination cursor")

     

       31
       31
       +
       

     

       32
       32
       +
       	// ErrActorNotFound is returned when the requested actor does not exist

     

       33
       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

···

       16
       16
        
       	// AppView indexing happens asynchronously via Jetstream consumer

     

       17
       17
        
       	CreatePost(ctx context.Context, req CreatePostRequest) (*CreatePostResponse, error)

     

       18
       18
        
       

     

       19
       19
       +
       	// GetAuthorPosts retrieves posts authored by a specific user for their profile page

     

       20
       20
       +
       	// Supports filtering by post type (with/without replies, media only) and community

     

       21
       21
       +
       	// Returns paginated feed with cursor

     

       22
       22
       +
       	GetAuthorPosts(ctx context.Context, req GetAuthorPostsRequest) (*GetAuthorPostsResponse, error)

     

       23
       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)

     
···

       34
       39
        
       	// Used for E2E test verification and future GET endpoint

     

       35
       40
        
       	GetByURI(ctx context.Context, uri string) (*Post, error)

     

       36
       41
        
       

     

       42
       42
       +
       	// GetByAuthor retrieves posts authored by a specific user

     

       43
       43
       +
       	// Supports filtering by post type and community

     

       44
       44
       +
       	// Returns posts, cursor for pagination, and error

     

       45
       45
       +
       	GetByAuthor(ctx context.Context, req GetAuthorPostsRequest) ([]*PostView, *string, error)

     

       46
       46
       +
       

     

       37
       47
        
       	// Future methods (Beta):

     

       38
       48
        
       	// Update(ctx context.Context, post *Post) error

     

       39
       49
        
       	// Delete(ctx context.Context, uri string) error

+71

internal/core/posts/post.go

···

       143
       143
        
       	Tags     []string `json:"tags,omitempty"`

     

       144
       144
        
       	Saved    bool     `json:"saved"`

     

       145
       145
        
       }

     

       146
       146
       +
       

     

       147
       147
       +
       // Filter constants for GetAuthorPosts

     

       148
       148
       +
       const (

     

       149
       149
       +
       	FilterPostsWithReplies = "posts_with_replies"

     

       150
       150
       +
       	FilterPostsNoReplies   = "posts_no_replies"

     

       151
       151
       +
       	FilterPostsWithMedia   = "posts_with_media"

     

       152
       152
       +
       )

     

       153
       153
       +
       

     

       154
       154
       +
       // GetAuthorPostsRequest represents input for fetching author's posts

     

       155
       155
       +
       // Matches social.coves.actor.getPosts lexicon input

     

       156
       156
       +
       type GetAuthorPostsRequest struct {

     

       157
       157
       +
       	ActorDID  string  // Resolved DID from actor param (handle or DID)

     

       158
       158
       +
       	Filter    string  // FilterPostsWithReplies, FilterPostsNoReplies, FilterPostsWithMedia

     

       159
       159
       +
       	Community string  // Optional community DID filter

     

       160
       160
       +
       	Limit     int     // Number of posts to return (1-100, default 50)

     

       161
       161
       +
       	Cursor    *string // Pagination cursor

     

       162
       162
       +
       	ViewerDID string  // Viewer's DID for enriching viewer state

     

       163
       163
       +
       }

     

       164
       164
       +
       

     

       165
       165
       +
       // GetAuthorPostsResponse represents author posts response

     

       166
       166
       +
       // Matches social.coves.actor.getPosts lexicon output

     

       167
       167
       +
       type GetAuthorPostsResponse struct {

     

       168
       168
       +
       	Feed   []*FeedViewPost `json:"feed"`

     

       169
       169
       +
       	Cursor *string         `json:"cursor,omitempty"`

     

       170
       170
       +
       }

     

       171
       171
       +
       

     

       172
       172
       +
       // FeedViewPost matches social.coves.feed.defs#feedViewPost

     

       173
       173
       +
       // Wraps a post with optional context about why it appears in a feed

     

       174
       174
       +
       type FeedViewPost struct {

     

       175
       175
       +
       	Post   *PostView   `json:"post"`

     

       176
       176
       +
       	Reason *FeedReason `json:"reason,omitempty"` // Context for why post appears in feed

     

       177
       177
       +
       	Reply  *ReplyRef   `json:"reply,omitempty"`  // Reply context if post is a reply

     

       178
       178
       +
       }

     

       179
       179
       +
       

     

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

     

       181
       181
       +
       func (f *FeedViewPost) GetPost() *PostView {

     

       182
       182
       +
       	return f.Post

     

       183
       183
       +
       }

     

       184
       184
       +
       

     

       185
       185
       +
       // FeedReason represents the reason a post appears in a feed

     

       186
       186
       +
       // Matches social.coves.feed.defs union type for feed context

     

       187
       187
       +
       type FeedReason struct {

     

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

     

       189
       189
       +
       	Repost *ReasonRepost `json:"repost,omitempty"`

     

       190
       190
       +
       	Pin    *ReasonPin    `json:"pin,omitempty"`

     

       191
       191
       +
       }

     

       192
       192
       +
       

     

       193
       193
       +
       // ReasonRepost indicates the post was reposted by another user

     

       194
       194
       +
       type ReasonRepost struct {

     

       195
       195
       +
       	By        *AuthorView `json:"by"`

     

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

     

       197
       197
       +
       }

     

       198
       198
       +
       

     

       199
       199
       +
       // ReasonPin indicates the post is pinned by the community

     

       200
       200
       +
       type ReasonPin struct {

     

       201
       201
       +
       	Community *CommunityRef `json:"community"`

     

       202
       202
       +
       }

     

       203
       203
       +
       

     

       204
       204
       +
       // ReplyRef contains context about post replies

     

       205
       205
       +
       // Matches social.coves.feed.defs#replyRef

     

       206
       206
       +
       type ReplyRef struct {

     

       207
       207
       +
       	Root   *PostRef `json:"root"`

     

       208
       208
       +
       	Parent *PostRef `json:"parent"`

     

       209
       209
       +
       }

     

       210
       210
       +
       

     

       211
       211
       +
       // PostRef is a minimal reference to a post (URI + CID)

     

       212
       212
       +
       // Matches social.coves.feed.defs#postRef

     

       213
       213
       +
       type PostRef struct {

     

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

     

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

     

       216
       216
       +
       }

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

     

       562
       562
       +
       // GetAuthorPosts retrieves posts by a specific author with optional filtering

     

       563
       563
       +
       // Supports filtering by: posts_with_replies, posts_no_replies, posts_with_media

     

       564
       564
       +
       // Optionally filter to a specific community

     

       565
       565
       +
       func (s *postService) GetAuthorPosts(ctx context.Context, req GetAuthorPostsRequest) (*GetAuthorPostsResponse, error) {

     

       566
       566
       +
       	// 1. Validate request

     

       567
       567
       +
       	if err := s.validateGetAuthorPostsRequest(&req); err != nil {

     

       568
       568
       +
       		return nil, err

     

       569
       569
       +
       	}

     

       570
       570
       +
       

     

       571
       571
       +
       	// 2. If community is provided, resolve it to DID

     

       572
       572
       +
       	if req.Community != "" {

     

       573
       573
       +
       		communityDID, err := s.communityService.ResolveCommunityIdentifier(ctx, req.Community)

     

       574
       574
       +
       		if err != nil {

     

       575
       575
       +
       			if communities.IsNotFound(err) {

     

       576
       576
       +
       				return nil, ErrCommunityNotFound

     

       577
       577
       +
       			}

     

       578
       578
       +
       			if communities.IsValidationError(err) {

     

       579
       579
       +
       				return nil, NewValidationError("community", err.Error())

     

       580
       580
       +
       			}

     

       581
       581
       +
       			return nil, fmt.Errorf("failed to resolve community identifier: %w", err)

     

       582
       582
       +
       		}

     

       583
       583
       +
       		req.Community = communityDID

     

       584
       584
       +
       	}

     

       585
       585
       +
       

     

       586
       586
       +
       	// 3. Fetch posts from repository

     

       587
       587
       +
       	postViews, cursor, err := s.repo.GetByAuthor(ctx, req)

     

       588
       588
       +
       	if err != nil {

     

       589
       589
       +
       		return nil, fmt.Errorf("failed to get author posts: %w", err)

     

       590
       590
       +
       	}

     

       591
       591
       +
       

     

       592
       592
       +
       	// 4. Wrap PostViews in FeedViewPost

     

       593
       593
       +
       	feed := make([]*FeedViewPost, len(postViews))

     

       594
       594
       +
       	for i, postView := range postViews {

     

       595
       595
       +
       		feed[i] = &FeedViewPost{

     

       596
       596
       +
       			Post: postView,

     

       597
       597
       +
       		}

     

       598
       598
       +
       	}

     

       599
       599
       +
       

     

       600
       600
       +
       	// 5. Return response

     

       601
       601
       +
       	return &GetAuthorPostsResponse{

     

       602
       602
       +
       		Feed:   feed,

     

       603
       603
       +
       		Cursor: cursor,

     

       604
       604
       +
       	}, nil

     

       605
       605
       +
       }

     

       606
       606
       +
       

     

       607
       607
       +
       // validateGetAuthorPostsRequest validates the GetAuthorPosts request

     

       608
       608
       +
       func (s *postService) validateGetAuthorPostsRequest(req *GetAuthorPostsRequest) error {

     

       609
       609
       +
       	// Validate actor DID is set

     

       610
       610
       +
       	if req.ActorDID == "" {

     

       611
       611
       +
       		return NewValidationError("actor", "actor is required")

     

       612
       612
       +
       	}

     

       613
       613
       +
       

     

       614
       614
       +
       	// Validate DID format - AT Protocol supports did:plc and did:web

     

       615
       615
       +
       	if err := validateDIDFormat(req.ActorDID); err != nil {

     

       616
       616
       +
       		return NewValidationError("actor", err.Error())

     

       617
       617
       +
       	}

     

       618
       618
       +
       

     

       619
       619
       +
       	// Validate and set defaults for filter

     

       620
       620
       +
       	validFilters := map[string]bool{

     

       621
       621
       +
       		FilterPostsWithReplies: true,

     

       622
       622
       +
       		FilterPostsNoReplies:   true,

     

       623
       623
       +
       		FilterPostsWithMedia:   true,

     

       624
       624
       +
       	}

     

       625
       625
       +
       	if req.Filter == "" {

     

       626
       626
       +
       		req.Filter = FilterPostsWithReplies // Default

     

       627
       627
       +
       	}

     

       628
       628
       +
       	if !validFilters[req.Filter] {

     

       629
       629
       +
       		return NewValidationError("filter", "filter must be one of: posts_with_replies, posts_no_replies, posts_with_media")

     

       630
       630
       +
       	}

     

       631
       631
       +
       

     

       632
       632
       +
       	// Validate and set defaults for limit

     

       633
       633
       +
       	if req.Limit <= 0 {

     

       634
       634
       +
       		req.Limit = 50 // Default

     

       635
       635
       +
       	}

     

       636
       636
       +
       	if req.Limit > 100 {

     

       637
       637
       +
       		req.Limit = 100 // Max

     

       638
       638
       +
       	}

     

       639
       639
       +
       

     

       640
       640
       +
       	return nil

     

       641
       641
       +
       }

     

       642
       642
       +
       

     

       643
       643
       +
       // validateDIDFormat validates that a string is a properly formatted DID

     

       644
       644
       +
       // Supports did:plc: (24 char base32 identifier) and did:web: (domain-based)

     

       645
       645
       +
       func validateDIDFormat(did string) error {

     

       646
       646
       +
       	const maxDIDLength = 2048

     

       647
       647
       +
       

     

       648
       648
       +
       	if len(did) > maxDIDLength {

     

       649
       649
       +
       		return fmt.Errorf("DID exceeds maximum length")

     

       650
       650
       +
       	}

     

       651
       651
       +
       

     

       652
       652
       +
       	switch {

     

       653
       653
       +
       	case strings.HasPrefix(did, "did:plc:"):

     

       654
       654
       +
       		// did:plc: format - identifier is 24 lowercase alphanumeric chars

     

       655
       655
       +
       		identifier := strings.TrimPrefix(did, "did:plc:")

     

       656
       656
       +
       		if len(identifier) == 0 {

     

       657
       657
       +
       			return fmt.Errorf("invalid did:plc format: missing identifier")

     

       658
       658
       +
       		}

     

       659
       659
       +
       		// Base32 uses lowercase a-z and 2-7

     

       660
       660
       +
       		for _, c := range identifier {

     

       661
       661
       +
       			if !((c >= 'a' && c <= 'z') || (c >= '2' && c <= '7')) {

     

       662
       662
       +
       				return fmt.Errorf("invalid did:plc format: identifier contains invalid characters")

     

       663
       663
       +
       			}

     

       664
       664
       +
       		}

     

       665
       665
       +
       		return nil

     

       666
       666
       +
       

     

       667
       667
       +
       	case strings.HasPrefix(did, "did:web:"):

     

       668
       668
       +
       		// did:web: format - domain-based identifier

     

       669
       669
       +
       		domain := strings.TrimPrefix(did, "did:web:")

     

       670
       670
       +
       		if len(domain) == 0 {

     

       671
       671
       +
       			return fmt.Errorf("invalid did:web format: missing domain")

     

       672
       672
       +
       		}

     

       673
       673
       +
       		// Basic domain validation - must contain at least one dot or be localhost

     

       674
       674
       +
       		if !strings.Contains(domain, ".") && domain != "localhost" {

     

       675
       675
       +
       			return fmt.Errorf("invalid did:web format: invalid domain")

     

       676
       676
       +
       		}

     

       677
       677
       +
       		return nil

     

       678
       678
       +
       

     

       679
       679
       +
       	default:

     

       680
       680
       +
       		return fmt.Errorf("unsupported DID method: must be did:plc or did:web")

     

       681
       681
       +
       	}

     

       682
       682
       +
       }

+277

internal/core/posts/service_author_posts_test.go

···

       1
       1
       +
       package posts

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"testing"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       // mockRepository implements Repository for testing

     

       9
       9
       +
       type mockRepository struct {

     

       10
       10
       +
       	getByAuthorFunc func(ctx context.Context, req GetAuthorPostsRequest) ([]*PostView, *string, error)

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       func (m *mockRepository) Create(ctx context.Context, post *Post) error {

     

       14
       14
       +
       	return nil

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       func (m *mockRepository) GetByURI(ctx context.Context, uri string) (*Post, error) {

     

       18
       18
       +
       	return nil, nil

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       func (m *mockRepository) GetByAuthor(ctx context.Context, req GetAuthorPostsRequest) ([]*PostView, *string, error) {

     

       22
       22
       +
       	if m.getByAuthorFunc != nil {

     

       23
       23
       +
       		return m.getByAuthorFunc(ctx, req)

     

       24
       24
       +
       	}

     

       25
       25
       +
       	return []*PostView{}, nil, nil

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       func (m *mockRepository) SoftDelete(ctx context.Context, uri string) error {

     

       29
       29
       +
       	return nil

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       func (m *mockRepository) Update(ctx context.Context, post *Post) error {

     

       33
       33
       +
       	return nil

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       func (m *mockRepository) UpdateVoteCounts(ctx context.Context, uri string, upvotes, downvotes int) error {

     

       37
       37
       +
       	return nil

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       func TestValidateDIDFormat(t *testing.T) {

     

       41
       41
       +
       	tests := []struct {

     

       42
       42
       +
       		name    string

     

       43
       43
       +
       		did     string

     

       44
       44
       +
       		wantErr bool

     

       45
       45
       +
       		errMsg  string

     

       46
       46
       +
       	}{

     

       47
       47
       +
       		{

     

       48
       48
       +
       			name:    "valid did:plc",

     

       49
       49
       +
       			did:     "did:plc:ewvi7nxzyoun6zhxrhs64oiz",

     

       50
       50
       +
       			wantErr: false,

     

       51
       51
       +
       		},

     

       52
       52
       +
       		{

     

       53
       53
       +
       			name:    "valid did:web",

     

       54
       54
       +
       			did:     "did:web:example.com",

     

       55
       55
       +
       			wantErr: false,

     

       56
       56
       +
       		},

     

       57
       57
       +
       		{

     

       58
       58
       +
       			name:    "valid did:web with subdomain",

     

       59
       59
       +
       			did:     "did:web:bsky.social",

     

       60
       60
       +
       			wantErr: false,

     

       61
       61
       +
       		},

     

       62
       62
       +
       		{

     

       63
       63
       +
       			name:    "valid did:web localhost",

     

       64
       64
       +
       			did:     "did:web:localhost",

     

       65
       65
       +
       			wantErr: false,

     

       66
       66
       +
       		},

     

       67
       67
       +
       		{

     

       68
       68
       +
       			name:    "invalid - missing method",

     

       69
       69
       +
       			did:     "did:",

     

       70
       70
       +
       			wantErr: true,

     

       71
       71
       +
       			errMsg:  "unsupported DID method",

     

       72
       72
       +
       		},

     

       73
       73
       +
       		{

     

       74
       74
       +
       			name:    "invalid - unsupported method",

     

       75
       75
       +
       			did:     "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK",

     

       76
       76
       +
       			wantErr: true,

     

       77
       77
       +
       			errMsg:  "unsupported DID method",

     

       78
       78
       +
       		},

     

       79
       79
       +
       		{

     

       80
       80
       +
       			name:    "invalid did:plc - empty identifier",

     

       81
       81
       +
       			did:     "did:plc:",

     

       82
       82
       +
       			wantErr: true,

     

       83
       83
       +
       			errMsg:  "missing identifier",

     

       84
       84
       +
       		},

     

       85
       85
       +
       		{

     

       86
       86
       +
       			name:    "invalid did:plc - uppercase chars",

     

       87
       87
       +
       			did:     "did:plc:UPPERCASE",

     

       88
       88
       +
       			wantErr: true,

     

       89
       89
       +
       			errMsg:  "invalid characters",

     

       90
       90
       +
       		},

     

       91
       91
       +
       		{

     

       92
       92
       +
       			name:    "invalid did:plc - numbers outside base32",

     

       93
       93
       +
       			did:     "did:plc:abc0189",

     

       94
       94
       +
       			wantErr: true,

     

       95
       95
       +
       			errMsg:  "invalid characters",

     

       96
       96
       +
       		},

     

       97
       97
       +
       		{

     

       98
       98
       +
       			name:    "invalid did:web - empty domain",

     

       99
       99
       +
       			did:     "did:web:",

     

       100
       100
       +
       			wantErr: true,

     

       101
       101
       +
       			errMsg:  "missing domain",

     

       102
       102
       +
       		},

     

       103
       103
       +
       		{

     

       104
       104
       +
       			name:    "invalid did:web - no dot in domain",

     

       105
       105
       +
       			did:     "did:web:nodot",

     

       106
       106
       +
       			wantErr: true,

     

       107
       107
       +
       			errMsg:  "invalid domain",

     

       108
       108
       +
       		},

     

       109
       109
       +
       		{

     

       110
       110
       +
       			name:    "invalid - not a DID",

     

       111
       111
       +
       			did:     "notadid",

     

       112
       112
       +
       			wantErr: true,

     

       113
       113
       +
       			errMsg:  "unsupported DID method",

     

       114
       114
       +
       		},

     

       115
       115
       +
       		{

     

       116
       116
       +
       			name:    "invalid - too long",

     

       117
       117
       +
       			did:     "did:plc:" + string(make([]byte, 2100)),

     

       118
       118
       +
       			wantErr: true,

     

       119
       119
       +
       			errMsg:  "exceeds maximum length",

     

       120
       120
       +
       		},

     

       121
       121
       +
       	}

     

       122
       122
       +
       

     

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

     

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

     

       125
       125
       +
       			err := validateDIDFormat(tt.did)

     

       126
       126
       +
       			if tt.wantErr {

     

       127
       127
       +
       				if err == nil {

     

       128
       128
       +
       					t.Errorf("validateDIDFormat(%q) = nil, want error containing %q", tt.did, tt.errMsg)

     

       129
       129
       +
       				} else if tt.errMsg != "" && !testContains(err.Error(), tt.errMsg) {

     

       130
       130
       +
       					t.Errorf("validateDIDFormat(%q) = %v, want error containing %q", tt.did, err, tt.errMsg)

     

       131
       131
       +
       				}

     

       132
       132
       +
       			} else {

     

       133
       133
       +
       				if err != nil {

     

       134
       134
       +
       					t.Errorf("validateDIDFormat(%q) = %v, want nil", tt.did, err)

     

       135
       135
       +
       				}

     

       136
       136
       +
       			}

     

       137
       137
       +
       		})

     

       138
       138
       +
       	}

     

       139
       139
       +
       }

     

       140
       140
       +
       

     

       141
       141
       +
       // helper function for contains check (named testContains to avoid conflict with package function)

     

       142
       142
       +
       func testContains(s, substr string) bool {

     

       143
       143
       +
       	for i := 0; i <= len(s)-len(substr); i++ {

     

       144
       144
       +
       		if s[i:i+len(substr)] == substr {

     

       145
       145
       +
       			return true

     

       146
       146
       +
       		}

     

       147
       147
       +
       	}

     

       148
       148
       +
       	return false

     

       149
       149
       +
       }

     

       150
       150
       +
       

     

       151
       151
       +
       func TestValidateGetAuthorPostsRequest(t *testing.T) {

     

       152
       152
       +
       	// Create a minimal service for testing validation

     

       153
       153
       +
       	// We only need to test the validation logic, not the full service

     

       154
       154
       +
       

     

       155
       155
       +
       	tests := []struct {

     

       156
       156
       +
       		name    string

     

       157
       157
       +
       		req     GetAuthorPostsRequest

     

       158
       158
       +
       		wantErr bool

     

       159
       159
       +
       		errMsg  string

     

       160
       160
       +
       	}{

     

       161
       161
       +
       		{

     

       162
       162
       +
       			name: "valid request - minimal",

     

       163
       163
       +
       			req: GetAuthorPostsRequest{

     

       164
       164
       +
       				ActorDID: "did:plc:ewvi7nxzyoun6zhxrhs64oiz",

     

       165
       165
       +
       			},

     

       166
       166
       +
       			wantErr: false,

     

       167
       167
       +
       		},

     

       168
       168
       +
       		{

     

       169
       169
       +
       			name: "valid request - with filter",

     

       170
       170
       +
       			req: GetAuthorPostsRequest{

     

       171
       171
       +
       				ActorDID: "did:plc:ewvi7nxzyoun6zhxrhs64oiz",

     

       172
       172
       +
       				Filter:   FilterPostsWithMedia,

     

       173
       173
       +
       			},

     

       174
       174
       +
       			wantErr: false,

     

       175
       175
       +
       		},

     

       176
       176
       +
       		{

     

       177
       177
       +
       			name: "valid request - with limit",

     

       178
       178
       +
       			req: GetAuthorPostsRequest{

     

       179
       179
       +
       				ActorDID: "did:plc:ewvi7nxzyoun6zhxrhs64oiz",

     

       180
       180
       +
       				Limit:    25,

     

       181
       181
       +
       			},

     

       182
       182
       +
       			wantErr: false,

     

       183
       183
       +
       		},

     

       184
       184
       +
       		{

     

       185
       185
       +
       			name: "invalid - empty actor",

     

       186
       186
       +
       			req: GetAuthorPostsRequest{

     

       187
       187
       +
       				ActorDID: "",

     

       188
       188
       +
       			},

     

       189
       189
       +
       			wantErr: true,

     

       190
       190
       +
       			errMsg:  "actor is required",

     

       191
       191
       +
       		},

     

       192
       192
       +
       		{

     

       193
       193
       +
       			name: "invalid - bad DID format",

     

       194
       194
       +
       			req: GetAuthorPostsRequest{

     

       195
       195
       +
       				ActorDID: "notadid",

     

       196
       196
       +
       			},

     

       197
       197
       +
       			wantErr: true,

     

       198
       198
       +
       			errMsg:  "unsupported DID method",

     

       199
       199
       +
       		},

     

       200
       200
       +
       		{

     

       201
       201
       +
       			name: "invalid - unknown filter",

     

       202
       202
       +
       			req: GetAuthorPostsRequest{

     

       203
       203
       +
       				ActorDID: "did:plc:ewvi7nxzyoun6zhxrhs64oiz",

     

       204
       204
       +
       				Filter:   "unknown_filter",

     

       205
       205
       +
       			},

     

       206
       206
       +
       			wantErr: true,

     

       207
       207
       +
       			errMsg:  "filter must be one of",

     

       208
       208
       +
       		},

     

       209
       209
       +
       	}

     

       210
       210
       +
       

     

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

     

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

     

       213
       213
       +
       			// Create service with nil dependencies - we only test validation

     

       214
       214
       +
       			s := &postService{}

     

       215
       215
       +
       			err := s.validateGetAuthorPostsRequest(&tt.req)

     

       216
       216
       +
       

     

       217
       217
       +
       			if tt.wantErr {

     

       218
       218
       +
       				if err == nil {

     

       219
       219
       +
       					t.Errorf("validateGetAuthorPostsRequest() = nil, want error containing %q", tt.errMsg)

     

       220
       220
       +
       				} else if tt.errMsg != "" && !testContains(err.Error(), tt.errMsg) {

     

       221
       221
       +
       					t.Errorf("validateGetAuthorPostsRequest() = %v, want error containing %q", err, tt.errMsg)

     

       222
       222
       +
       				}

     

       223
       223
       +
       			} else {

     

       224
       224
       +
       				if err != nil {

     

       225
       225
       +
       					t.Errorf("validateGetAuthorPostsRequest() = %v, want nil", err)

     

       226
       226
       +
       				}

     

       227
       227
       +
       			}

     

       228
       228
       +
       		})

     

       229
       229
       +
       	}

     

       230
       230
       +
       }

     

       231
       231
       +
       

     

       232
       232
       +
       func TestValidateGetAuthorPostsRequest_DefaultsSet(t *testing.T) {

     

       233
       233
       +
       	s := &postService{}

     

       234
       234
       +
       

     

       235
       235
       +
       	// Test that defaults are set

     

       236
       236
       +
       	t.Run("filter defaults to posts_with_replies", func(t *testing.T) {

     

       237
       237
       +
       		req := GetAuthorPostsRequest{

     

       238
       238
       +
       			ActorDID: "did:plc:ewvi7nxzyoun6zhxrhs64oiz",

     

       239
       239
       +
       			Filter:   "", // empty

     

       240
       240
       +
       		}

     

       241
       241
       +
       		err := s.validateGetAuthorPostsRequest(&req)

     

       242
       242
       +
       		if err != nil {

     

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

     

       244
       244
       +
       		}

     

       245
       245
       +
       		if req.Filter != FilterPostsWithReplies {

     

       246
       246
       +
       			t.Errorf("Filter = %q, want %q", req.Filter, FilterPostsWithReplies)

     

       247
       247
       +
       		}

     

       248
       248
       +
       	})

     

       249
       249
       +
       

     

       250
       250
       +
       	t.Run("limit defaults to 50 when 0", func(t *testing.T) {

     

       251
       251
       +
       		req := GetAuthorPostsRequest{

     

       252
       252
       +
       			ActorDID: "did:plc:ewvi7nxzyoun6zhxrhs64oiz",

     

       253
       253
       +
       			Limit:    0,

     

       254
       254
       +
       		}

     

       255
       255
       +
       		err := s.validateGetAuthorPostsRequest(&req)

     

       256
       256
       +
       		if err != nil {

     

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

     

       258
       258
       +
       		}

     

       259
       259
       +
       		if req.Limit != 50 {

     

       260
       260
       +
       			t.Errorf("Limit = %d, want 50", req.Limit)

     

       261
       261
       +
       		}

     

       262
       262
       +
       	})

     

       263
       263
       +
       

     

       264
       264
       +
       	t.Run("limit capped at 100", func(t *testing.T) {

     

       265
       265
       +
       		req := GetAuthorPostsRequest{

     

       266
       266
       +
       			ActorDID: "did:plc:ewvi7nxzyoun6zhxrhs64oiz",

     

       267
       267
       +
       			Limit:    200,

     

       268
       268
       +
       		}

     

       269
       269
       +
       		err := s.validateGetAuthorPostsRequest(&req)

     

       270
       270
       +
       		if err != nil {

     

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

     

       272
       272
       +
       		}

     

       273
       273
       +
       		if req.Limit != 100 {

     

       274
       274
       +
       			t.Errorf("Limit = %d, want 100", req.Limit)

     

       275
       275
       +
       		}

     

       276
       276
       +
       	})

     

       277
       277
       +
       }

+12

internal/db/migrations/026_add_author_posts_index.sql

···

       1
       1
       +
       -- +goose Up

     

       2
       2
       +
       -- +goose NO TRANSACTION

     

       3
       3
       +
       -- Add optimized index for author posts queries with soft delete filter

     

       4
       4
       +
       -- This supports the social.coves.actor.getPosts endpoint which retrieves posts by author

     

       5
       5
       +
       -- The existing idx_posts_author doesn't filter deleted posts, causing full index scans

     

       6
       6
       +
       CREATE INDEX CONCURRENTLY idx_posts_author_created

     

       7
       7
       +
       ON posts(author_did, created_at DESC)

     

       8
       8
       +
       WHERE deleted_at IS NULL;

     

       9
       9
       +
       

     

       10
       10
       +
       -- +goose Down

     

       11
       11
       +
       -- +goose NO TRANSACTION

     

       12
       12
       +
       DROP INDEX CONCURRENTLY IF EXISTS idx_posts_author_created;

+285

internal/db/postgres/post_repo.go

···

       4
       4
        
       	"Coves/internal/core/posts"

     

       5
       5
        
       	"context"

     

       6
       6
        
       	"database/sql"

     

       7
       7
       +
       	"encoding/base64"

     

       8
       8
       +
       	"encoding/json"

     

       7
       9
        
       	"fmt"

     

       10
       10
       +
       	"log"

     

       8
       11
        
       	"strings"

     

       12
       12
       +
       	"time"

     

       9
       13
        
       )

     

       10
       14
        
       

     

       11
       15
        
       type postgresPostRepo struct {

     
···

       128
       132
        
       

     

       129
       133
        
       	return &post, nil

     

       130
       134
        
       }

     

       135
       135
       +
       

     

       136
       136
       +
       // GetByAuthor retrieves posts by author with filtering and pagination

     

       137
       137
       +
       // Supports filter options: posts_with_replies (default), posts_no_replies, posts_with_media

     

       138
       138
       +
       // Uses cursor-based pagination with created_at + uri for stable ordering

     

       139
       139
       +
       // Returns []*PostView, next cursor, and error

     

       140
       140
       +
       func (r *postgresPostRepo) GetByAuthor(ctx context.Context, req posts.GetAuthorPostsRequest) ([]*posts.PostView, *string, error) {

     

       141
       141
       +
       	// Build WHERE clauses based on filters

     

       142
       142
       +
       	whereConditions := []string{

     

       143
       143
       +
       		"p.author_did = $1",

     

       144
       144
       +
       		"p.deleted_at IS NULL",

     

       145
       145
       +
       	}

     

       146
       146
       +
       	args := []interface{}{req.ActorDID}

     

       147
       147
       +
       	paramIndex := 2

     

       148
       148
       +
       

     

       149
       149
       +
       	// Optional community filter

     

       150
       150
       +
       	if req.Community != "" {

     

       151
       151
       +
       		whereConditions = append(whereConditions, fmt.Sprintf("p.community_did = $%d", paramIndex))

     

       152
       152
       +
       		args = append(args, req.Community)

     

       153
       153
       +
       		paramIndex++

     

       154
       154
       +
       	}

     

       155
       155
       +
       

     

       156
       156
       +
       	// Filter by post type

     

       157
       157
       +
       	// Design note: Coves architecture separates posts from comments (unlike Bluesky where

     

       158
       158
       +
       	// posts can be replies to other posts). The posts_no_replies filter exists for API

     

       159
       159
       +
       	// compatibility with Bluesky's getAuthorFeed, but is intentionally a no-op in Coves

     

       160
       160
       +
       	// since all Coves posts are top-level (comments are stored in a separate table).

     

       161
       161
       +
       	switch req.Filter {

     

       162
       162
       +
       	case posts.FilterPostsWithMedia:

     

       163
       163
       +
       		whereConditions = append(whereConditions, "p.embed IS NOT NULL")

     

       164
       164
       +
       	case posts.FilterPostsNoReplies:

     

       165
       165
       +
       		// No-op: All Coves posts are top-level; comments are in the comments table.

     

       166
       166
       +
       		// This filter exists for Bluesky API compatibility.

     

       167
       167
       +
       	case posts.FilterPostsWithReplies, "":

     

       168
       168
       +
       		// Default: return all posts (no additional filter needed)

     

       169
       169
       +
       	}

     

       170
       170
       +
       

     

       171
       171
       +
       	// Build cursor filter for pagination

     

       172
       172
       +
       	cursorFilter, cursorArgs, cursorErr := r.parseAuthorPostsCursor(req.Cursor, paramIndex)

     

       173
       173
       +
       	if cursorErr != nil {

     

       174
       174
       +
       		return nil, nil, cursorErr

     

       175
       175
       +
       	}

     

       176
       176
       +
       	if cursorFilter != "" {

     

       177
       177
       +
       		whereConditions = append(whereConditions, cursorFilter)

     

       178
       178
       +
       		args = append(args, cursorArgs...)

     

       179
       179
       +
       		paramIndex += len(cursorArgs)

     

       180
       180
       +
       	}

     

       181
       181
       +
       

     

       182
       182
       +
       	// Add limit to args

     

       183
       183
       +
       	limit := req.Limit

     

       184
       184
       +
       	if limit <= 0 {

     

       185
       185
       +
       		limit = 50 // default

     

       186
       186
       +
       	}

     

       187
       187
       +
       	if limit > 100 {

     

       188
       188
       +
       		limit = 100 // max

     

       189
       189
       +
       	}

     

       190
       190
       +
       	args = append(args, limit+1) // +1 to check for next page

     

       191
       191
       +
       

     

       192
       192
       +
       	whereClause := strings.Join(whereConditions, " AND ")

     

       193
       193
       +
       

     

       194
       194
       +
       	query := fmt.Sprintf(`

     

       195
       195
       +
       		SELECT

     

       196
       196
       +
       			p.uri, p.cid, p.rkey,

     

       197
       197
       +
       			p.author_did, u.handle as author_handle,

     

       198
       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
       199
       +
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       200
       200
       +
       			p.created_at, p.edited_at, p.indexed_at,

     

       201
       201
       +
       			p.upvote_count, p.downvote_count, p.score, p.comment_count

     

       202
       202
       +
       		FROM posts p

     

       203
       203
       +
       		INNER JOIN users u ON p.author_did = u.did

     

       204
       204
       +
       		INNER JOIN communities c ON p.community_did = c.did

     

       205
       205
       +
       		WHERE %s

     

       206
       206
       +
       		ORDER BY p.created_at DESC, p.uri DESC

     

       207
       207
       +
       		LIMIT $%d

     

       208
       208
       +
       	`, whereClause, paramIndex)

     

       209
       209
       +
       

     

       210
       210
       +
       	// Execute query

     

       211
       211
       +
       	rows, err := r.db.QueryContext(ctx, query, args...)

     

       212
       212
       +
       	if err != nil {

     

       213
       213
       +
       		return nil, nil, fmt.Errorf("failed to query author posts: %w", err)

     

       214
       214
       +
       	}

     

       215
       215
       +
       	defer func() {

     

       216
       216
       +
       		if err := rows.Close(); err != nil {

     

       217
       217
       +
       			log.Printf("WARN: failed to close rows: %v", err)

     

       218
       218
       +
       		}

     

       219
       219
       +
       	}()

     

       220
       220
       +
       

     

       221
       221
       +
       	// Scan results

     

       222
       222
       +
       	var postViews []*posts.PostView

     

       223
       223
       +
       	for rows.Next() {

     

       224
       224
       +
       		postView, err := r.scanAuthorPost(rows)

     

       225
       225
       +
       		if err != nil {

     

       226
       226
       +
       			return nil, nil, fmt.Errorf("failed to scan author post: %w", err)

     

       227
       227
       +
       		}

     

       228
       228
       +
       		postViews = append(postViews, postView)

     

       229
       229
       +
       	}

     

       230
       230
       +
       

     

       231
       231
       +
       	if err := rows.Err(); err != nil {

     

       232
       232
       +
       		return nil, nil, fmt.Errorf("error iterating author posts results: %w", err)

     

       233
       233
       +
       	}

     

       234
       234
       +
       

     

       235
       235
       +
       	// Handle pagination cursor

     

       236
       236
       +
       	var cursor *string

     

       237
       237
       +
       	if len(postViews) > limit && limit > 0 {

     

       238
       238
       +
       		postViews = postViews[:limit]

     

       239
       239
       +
       		lastPost := postViews[len(postViews)-1]

     

       240
       240
       +
       		cursorStr := r.buildAuthorPostsCursor(lastPost)

     

       241
       241
       +
       		cursor = &cursorStr

     

       242
       242
       +
       	}

     

       243
       243
       +
       

     

       244
       244
       +
       	return postViews, cursor, nil

     

       245
       245
       +
       }

     

       246
       246
       +
       

     

       247
       247
       +
       // parseAuthorPostsCursor decodes pagination cursor for author posts

     

       248
       248
       +
       // Cursor format: base64(created_at|uri)

     

       249
       249
       +
       // Uses simple | delimiter since this is an internal cursor (not signed like feed cursors)

     

       250
       250
       +
       // Returns filter clause, arguments, and error. Error is returned for malformed cursors

     

       251
       251
       +
       // to provide clear feedback rather than silently returning the first page.

     

       252
       252
       +
       func (r *postgresPostRepo) parseAuthorPostsCursor(cursor *string, paramOffset int) (string, []interface{}, error) {

     

       253
       253
       +
       	if cursor == nil || *cursor == "" {

     

       254
       254
       +
       		return "", nil, nil

     

       255
       255
       +
       	}

     

       256
       256
       +
       

     

       257
       257
       +
       	// Validate cursor size to prevent DoS via massive base64 strings

     

       258
       258
       +
       	const maxCursorSize = 512

     

       259
       259
       +
       	if len(*cursor) > maxCursorSize {

     

       260
       260
       +
       		return "", nil, fmt.Errorf("%w: cursor exceeds maximum length", posts.ErrInvalidCursor)

     

       261
       261
       +
       	}

     

       262
       262
       +
       

     

       263
       263
       +
       	// Decode base64 cursor

     

       264
       264
       +
       	decoded, err := base64.URLEncoding.DecodeString(*cursor)

     

       265
       265
       +
       	if err != nil {

     

       266
       266
       +
       		return "", nil, fmt.Errorf("%w: invalid base64 encoding", posts.ErrInvalidCursor)

     

       267
       267
       +
       	}

     

       268
       268
       +
       

     

       269
       269
       +
       	// Parse cursor: created_at|uri

     

       270
       270
       +
       	parts := strings.Split(string(decoded), "|")

     

       271
       271
       +
       	if len(parts) != 2 {

     

       272
       272
       +
       		return "", nil, fmt.Errorf("%w: malformed cursor format", posts.ErrInvalidCursor)

     

       273
       273
       +
       	}

     

       274
       274
       +
       

     

       275
       275
       +
       	createdAt := parts[0]

     

       276
       276
       +
       	uri := parts[1]

     

       277
       277
       +
       

     

       278
       278
       +
       	// Validate timestamp format

     

       279
       279
       +
       	if _, err := time.Parse(time.RFC3339Nano, createdAt); err != nil {

     

       280
       280
       +
       		return "", nil, fmt.Errorf("%w: invalid timestamp in cursor", posts.ErrInvalidCursor)

     

       281
       281
       +
       	}

     

       282
       282
       +
       

     

       283
       283
       +
       	// Validate URI format (must be AT-URI)

     

       284
       284
       +
       	if !strings.HasPrefix(uri, "at://") {

     

       285
       285
       +
       		return "", nil, fmt.Errorf("%w: invalid URI format in cursor", posts.ErrInvalidCursor)

     

       286
       286
       +
       	}

     

       287
       287
       +
       

     

       288
       288
       +
       	// Use composite key comparison for stable cursor pagination

     

       289
       289
       +
       	// (created_at, uri) < (cursor_created_at, cursor_uri)

     

       290
       290
       +
       	filter := fmt.Sprintf("(p.created_at < $%d OR (p.created_at = $%d AND p.uri < $%d))",

     

       291
       291
       +
       		paramOffset, paramOffset, paramOffset+1)

     

       292
       292
       +
       	return filter, []interface{}{createdAt, uri}, nil

     

       293
       293
       +
       }

     

       294
       294
       +
       

     

       295
       295
       +
       // buildAuthorPostsCursor creates pagination cursor from last post

     

       296
       296
       +
       // Cursor format: base64(created_at|uri)

     

       297
       297
       +
       func (r *postgresPostRepo) buildAuthorPostsCursor(post *posts.PostView) string {

     

       298
       298
       +
       	cursorStr := fmt.Sprintf("%s|%s", post.CreatedAt.Format(time.RFC3339Nano), post.URI)

     

       299
       299
       +
       	return base64.URLEncoding.EncodeToString([]byte(cursorStr))

     

       300
       300
       +
       }

     

       301
       301
       +
       

     

       302
       302
       +
       // scanAuthorPost scans a database row into a PostView for author posts query

     

       303
       303
       +
       func (r *postgresPostRepo) scanAuthorPost(rows *sql.Rows) (*posts.PostView, error) {

     

       304
       304
       +
       	var (

     

       305
       305
       +
       		postView        posts.PostView

     

       306
       306
       +
       		authorView      posts.AuthorView

     

       307
       307
       +
       		communityRef    posts.CommunityRef

     

       308
       308
       +
       		title, content  sql.NullString

     

       309
       309
       +
       		facets, embed   sql.NullString

     

       310
       310
       +
       		labelsJSON      sql.NullString

     

       311
       311
       +
       		editedAt        sql.NullTime

     

       312
       312
       +
       		communityHandle sql.NullString

     

       313
       313
       +
       		communityAvatar sql.NullString

     

       314
       314
       +
       		communityPDSURL sql.NullString

     

       315
       315
       +
       	)

     

       316
       316
       +
       

     

       317
       317
       +
       	err := rows.Scan(

     

       318
       318
       +
       		&postView.URI, &postView.CID, &postView.RKey,

     

       319
       319
       +
       		&authorView.DID, &authorView.Handle,

     

       320
       320
       +
       		&communityRef.DID, &communityHandle, &communityRef.Name, &communityAvatar, &communityPDSURL,

     

       321
       321
       +
       		&title, &content, &facets, &embed, &labelsJSON,

     

       322
       322
       +
       		&postView.CreatedAt, &editedAt, &postView.IndexedAt,

     

       323
       323
       +
       		&postView.UpvoteCount, &postView.DownvoteCount, &postView.Score, &postView.CommentCount,

     

       324
       324
       +
       	)

     

       325
       325
       +
       	if err != nil {

     

       326
       326
       +
       		return nil, err

     

       327
       327
       +
       	}

     

       328
       328
       +
       

     

       329
       329
       +
       	// Build author view

     

       330
       330
       +
       	postView.Author = &authorView

     

       331
       331
       +
       

     

       332
       332
       +
       	// Build community ref

     

       333
       333
       +
       	if communityHandle.Valid {

     

       334
       334
       +
       		communityRef.Handle = communityHandle.String

     

       335
       335
       +
       	}

     

       336
       336
       +
       	if communityAvatar.Valid {

     

       337
       337
       +
       		communityRef.Avatar = &communityAvatar.String

     

       338
       338
       +
       	}

     

       339
       339
       +
       	if communityPDSURL.Valid {

     

       340
       340
       +
       		communityRef.PDSURL = communityPDSURL.String

     

       341
       341
       +
       	}

     

       342
       342
       +
       	postView.Community = &communityRef

     

       343
       343
       +
       

     

       344
       344
       +
       	// Set optional fields

     

       345
       345
       +
       	if title.Valid {

     

       346
       346
       +
       		postView.Title = &title.String

     

       347
       347
       +
       	}

     

       348
       348
       +
       	if content.Valid {

     

       349
       349
       +
       		postView.Text = &content.String

     

       350
       350
       +
       	}

     

       351
       351
       +
       	if editedAt.Valid {

     

       352
       352
       +
       		postView.EditedAt = &editedAt.Time

     

       353
       353
       +
       	}

     

       354
       354
       +
       

     

       355
       355
       +
       	// Parse facets JSON

     

       356
       356
       +
       	if facets.Valid {

     

       357
       357
       +
       		var facetArray []interface{}

     

       358
       358
       +
       		if err := json.Unmarshal([]byte(facets.String), &facetArray); err != nil {

     

       359
       359
       +
       			return nil, fmt.Errorf("failed to parse facets JSON for post %s: %w", postView.URI, err)

     

       360
       360
       +
       		}

     

       361
       361
       +
       		postView.TextFacets = facetArray

     

       362
       362
       +
       	}

     

       363
       363
       +
       

     

       364
       364
       +
       	// Parse embed JSON

     

       365
       365
       +
       	if embed.Valid {

     

       366
       366
       +
       		var embedData interface{}

     

       367
       367
       +
       		if err := json.Unmarshal([]byte(embed.String), &embedData); err != nil {

     

       368
       368
       +
       			return nil, fmt.Errorf("failed to parse embed JSON for post %s: %w", postView.URI, err)

     

       369
       369
       +
       		}

     

       370
       370
       +
       		postView.Embed = embedData

     

       371
       371
       +
       	}

     

       372
       372
       +
       

     

       373
       373
       +
       	// Build stats

     

       374
       374
       +
       	postView.Stats = &posts.PostStats{

     

       375
       375
       +
       		Upvotes:      postView.UpvoteCount,

     

       376
       376
       +
       		Downvotes:    postView.DownvoteCount,

     

       377
       377
       +
       		Score:        postView.Score,

     

       378
       378
       +
       		CommentCount: postView.CommentCount,

     

       379
       379
       +
       	}

     

       380
       380
       +
       

     

       381
       381
       +
       	// Build the record (required by lexicon)

     

       382
       382
       +
       	record := map[string]interface{}{

     

       383
       383
       +
       		"$type":     "social.coves.community.post",

     

       384
       384
       +
       		"community": communityRef.DID,

     

       385
       385
       +
       		"author":    authorView.DID,

     

       386
       386
       +
       		"createdAt": postView.CreatedAt.Format(time.RFC3339),

     

       387
       387
       +
       	}

     

       388
       388
       +
       

     

       389
       389
       +
       	// Add optional fields to record if present

     

       390
       390
       +
       	if title.Valid {

     

       391
       391
       +
       		record["title"] = title.String

     

       392
       392
       +
       	}

     

       393
       393
       +
       	if content.Valid {

     

       394
       394
       +
       		record["content"] = content.String

     

       395
       395
       +
       	}

     

       396
       396
       +
       	// Reuse already-parsed facets and embed from PostView to avoid double parsing

     

       397
       397
       +
       	if facets.Valid {

     

       398
       398
       +
       		record["facets"] = postView.TextFacets

     

       399
       399
       +
       	}

     

       400
       400
       +
       	if embed.Valid {

     

       401
       401
       +
       		record["embed"] = postView.Embed

     

       402
       402
       +
       	}

     

       403
       403
       +
       	if labelsJSON.Valid {

     

       404
       404
       +
       		// Labels are stored as JSONB containing full com.atproto.label.defs#selfLabels structure

     

       405
       405
       +
       		var selfLabels posts.SelfLabels

     

       406
       406
       +
       		if err := json.Unmarshal([]byte(labelsJSON.String), &selfLabels); err != nil {

     

       407
       407
       +
       			return nil, fmt.Errorf("failed to parse labels JSON for post %s: %w", postView.URI, err)

     

       408
       408
       +
       		}

     

       409
       409
       +
       		record["labels"] = selfLabels

     

       410
       410
       +
       	}

     

       411
       411
       +
       

     

       412
       412
       +
       	postView.Record = record

     

       413
       413
       +
       

     

       414
       414
       +
       	return &postView, nil

     

       415
       415
       +
       }

+244

internal/db/postgres/post_repo_cursor_test.go

···

       1
       1
       +
       package postgres

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"database/sql"

     

       6
       6
       +
       	"encoding/base64"

     

       7
       7
       +
       	"testing"

     

       8
       8
       +
       	"time"

     

       9
       9
       +
       

     

       10
       10
       +
       	"Coves/internal/core/posts"

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       func TestParseAuthorPostsCursor(t *testing.T) {

     

       14
       14
       +
       	repo := &postgresPostRepo{db: nil} // db not needed for cursor parsing

     

       15
       15
       +
       

     

       16
       16
       +
       	// Helper to create a valid cursor

     

       17
       17
       +
       	makeCursor := func(timestamp, uri string) string {

     

       18
       18
       +
       		return base64.URLEncoding.EncodeToString([]byte(timestamp + "|" + uri))

     

       19
       19
       +
       	}

     

       20
       20
       +
       

     

       21
       21
       +
       	validTimestamp := time.Now().Format(time.RFC3339Nano)

     

       22
       22
       +
       	validURI := "at://did:plc:test123/social.coves.community.post/abc123"

     

       23
       23
       +
       

     

       24
       24
       +
       	tests := []struct {

     

       25
       25
       +
       		name       string

     

       26
       26
       +
       		cursor     *string

     

       27
       27
       +
       		wantFilter bool

     

       28
       28
       +
       		wantErr    bool

     

       29
       29
       +
       		errMsg     string

     

       30
       30
       +
       	}{

     

       31
       31
       +
       		{

     

       32
       32
       +
       			name:       "nil cursor returns empty filter",

     

       33
       33
       +
       			cursor:     nil,

     

       34
       34
       +
       			wantFilter: false,

     

       35
       35
       +
       			wantErr:    false,

     

       36
       36
       +
       		},

     

       37
       37
       +
       		{

     

       38
       38
       +
       			name:       "empty cursor returns empty filter",

     

       39
       39
       +
       			cursor:     strPtr(""),

     

       40
       40
       +
       			wantFilter: false,

     

       41
       41
       +
       			wantErr:    false,

     

       42
       42
       +
       		},

     

       43
       43
       +
       		{

     

       44
       44
       +
       			name:       "valid cursor",

     

       45
       45
       +
       			cursor:     strPtr(makeCursor(validTimestamp, validURI)),

     

       46
       46
       +
       			wantFilter: true,

     

       47
       47
       +
       			wantErr:    false,

     

       48
       48
       +
       		},

     

       49
       49
       +
       		{

     

       50
       50
       +
       			name:       "cursor too long",

     

       51
       51
       +
       			cursor:     strPtr(makeCursor(validTimestamp, string(make([]byte, 600)))),

     

       52
       52
       +
       			wantFilter: false,

     

       53
       53
       +
       			wantErr:    true,

     

       54
       54
       +
       			errMsg:     "exceeds maximum length",

     

       55
       55
       +
       		},

     

       56
       56
       +
       		{

     

       57
       57
       +
       			name:       "invalid base64",

     

       58
       58
       +
       			cursor:     strPtr("not-valid-base64!!!"),

     

       59
       59
       +
       			wantFilter: false,

     

       60
       60
       +
       			wantErr:    true,

     

       61
       61
       +
       			errMsg:     "invalid base64",

     

       62
       62
       +
       		},

     

       63
       63
       +
       		{

     

       64
       64
       +
       			name:       "missing pipe delimiter",

     

       65
       65
       +
       			cursor:     strPtr(base64.URLEncoding.EncodeToString([]byte("no-pipe-here"))),

     

       66
       66
       +
       			wantFilter: false,

     

       67
       67
       +
       			wantErr:    true,

     

       68
       68
       +
       			errMsg:     "malformed cursor format",

     

       69
       69
       +
       		},

     

       70
       70
       +
       		{

     

       71
       71
       +
       			name:       "invalid timestamp",

     

       72
       72
       +
       			cursor:     strPtr(base64.URLEncoding.EncodeToString([]byte("not-a-timestamp|" + validURI))),

     

       73
       73
       +
       			wantFilter: false,

     

       74
       74
       +
       			wantErr:    true,

     

       75
       75
       +
       			errMsg:     "invalid timestamp",

     

       76
       76
       +
       		},

     

       77
       77
       +
       		{

     

       78
       78
       +
       			name:       "invalid URI format",

     

       79
       79
       +
       			cursor:     strPtr(base64.URLEncoding.EncodeToString([]byte(validTimestamp + "|not-an-at-uri"))),

     

       80
       80
       +
       			wantFilter: false,

     

       81
       81
       +
       			wantErr:    true,

     

       82
       82
       +
       			errMsg:     "invalid URI format",

     

       83
       83
       +
       		},

     

       84
       84
       +
       	}

     

       85
       85
       +
       

     

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

     

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

     

       88
       88
       +
       			filter, args, err := repo.parseAuthorPostsCursor(tt.cursor, 1)

     

       89
       89
       +
       

     

       90
       90
       +
       			if tt.wantErr {

     

       91
       91
       +
       				if err == nil {

     

       92
       92
       +
       					t.Errorf("parseAuthorPostsCursor() = nil error, want error containing %q", tt.errMsg)

     

       93
       93
       +
       				} else if !posts.IsValidationError(err) && err != posts.ErrInvalidCursor {

     

       94
       94
       +
       					// Check if error wraps ErrInvalidCursor

     

       95
       95
       +
       					if tt.errMsg != "" && !containsStr(err.Error(), tt.errMsg) {

     

       96
       96
       +
       						t.Errorf("parseAuthorPostsCursor() error = %v, want error containing %q", err, tt.errMsg)

     

       97
       97
       +
       					}

     

       98
       98
       +
       				}

     

       99
       99
       +
       			} else {

     

       100
       100
       +
       				if err != nil {

     

       101
       101
       +
       					t.Errorf("parseAuthorPostsCursor() = %v, want nil error", err)

     

       102
       102
       +
       				}

     

       103
       103
       +
       			}

     

       104
       104
       +
       

     

       105
       105
       +
       			if tt.wantFilter {

     

       106
       106
       +
       				if filter == "" {

     

       107
       107
       +
       					t.Error("parseAuthorPostsCursor() filter = empty, want non-empty filter")

     

       108
       108
       +
       				}

     

       109
       109
       +
       				if len(args) == 0 {

     

       110
       110
       +
       					t.Error("parseAuthorPostsCursor() args = empty, want non-empty args")

     

       111
       111
       +
       				}

     

       112
       112
       +
       			} else if !tt.wantErr {

     

       113
       113
       +
       				if filter != "" {

     

       114
       114
       +
       					t.Errorf("parseAuthorPostsCursor() filter = %q, want empty", filter)

     

       115
       115
       +
       				}

     

       116
       116
       +
       			}

     

       117
       117
       +
       		})

     

       118
       118
       +
       	}

     

       119
       119
       +
       }

     

       120
       120
       +
       

     

       121
       121
       +
       func TestBuildAuthorPostsCursor(t *testing.T) {

     

       122
       122
       +
       	repo := &postgresPostRepo{db: nil}

     

       123
       123
       +
       

     

       124
       124
       +
       	now := time.Now()

     

       125
       125
       +
       	post := &posts.PostView{

     

       126
       126
       +
       		URI:       "at://did:plc:test123/social.coves.community.post/abc123",

     

       127
       127
       +
       		CreatedAt: now,

     

       128
       128
       +
       	}

     

       129
       129
       +
       

     

       130
       130
       +
       	cursor := repo.buildAuthorPostsCursor(post)

     

       131
       131
       +
       

     

       132
       132
       +
       	// Decode and verify cursor

     

       133
       133
       +
       	decoded, err := base64.URLEncoding.DecodeString(cursor)

     

       134
       134
       +
       	if err != nil {

     

       135
       135
       +
       		t.Fatalf("Failed to decode cursor: %v", err)

     

       136
       136
       +
       	}

     

       137
       137
       +
       

     

       138
       138
       +
       	// Should contain timestamp|uri

     

       139
       139
       +
       	decodedStr := string(decoded)

     

       140
       140
       +
       	if !containsStr(decodedStr, "|") {

     

       141
       141
       +
       		t.Errorf("Cursor should contain '|' delimiter, got %q", decodedStr)

     

       142
       142
       +
       	}

     

       143
       143
       +
       	if !containsStr(decodedStr, post.URI) {

     

       144
       144
       +
       		t.Errorf("Cursor should contain URI, got %q", decodedStr)

     

       145
       145
       +
       	}

     

       146
       146
       +
       	if !containsStr(decodedStr, now.Format(time.RFC3339Nano)) {

     

       147
       147
       +
       		t.Errorf("Cursor should contain timestamp, got %q", decodedStr)

     

       148
       148
       +
       	}

     

       149
       149
       +
       }

     

       150
       150
       +
       

     

       151
       151
       +
       func TestBuildAndParseCursorRoundTrip(t *testing.T) {

     

       152
       152
       +
       	repo := &postgresPostRepo{db: nil}

     

       153
       153
       +
       

     

       154
       154
       +
       	now := time.Now()

     

       155
       155
       +
       	post := &posts.PostView{

     

       156
       156
       +
       		URI:       "at://did:plc:test123/social.coves.community.post/abc123",

     

       157
       157
       +
       		CreatedAt: now,

     

       158
       158
       +
       	}

     

       159
       159
       +
       

     

       160
       160
       +
       	// Build cursor

     

       161
       161
       +
       	cursor := repo.buildAuthorPostsCursor(post)

     

       162
       162
       +
       

     

       163
       163
       +
       	// Parse it back

     

       164
       164
       +
       	filter, args, err := repo.parseAuthorPostsCursor(&cursor, 1)

     

       165
       165
       +
       

     

       166
       166
       +
       	if err != nil {

     

       167
       167
       +
       		t.Fatalf("Failed to parse cursor: %v", err)

     

       168
       168
       +
       	}

     

       169
       169
       +
       

     

       170
       170
       +
       	if filter == "" {

     

       171
       171
       +
       		t.Error("Expected non-empty filter")

     

       172
       172
       +
       	}

     

       173
       173
       +
       

     

       174
       174
       +
       	if len(args) != 2 {

     

       175
       175
       +
       		t.Errorf("Expected 2 args, got %d", len(args))

     

       176
       176
       +
       	}

     

       177
       177
       +
       

     

       178
       178
       +
       	// First arg should be timestamp string

     

       179
       179
       +
       	if ts, ok := args[0].(string); ok {

     

       180
       180
       +
       		parsedTime, err := time.Parse(time.RFC3339Nano, ts)

     

       181
       181
       +
       		if err != nil {

     

       182
       182
       +
       			t.Errorf("First arg is not a valid timestamp: %v", err)

     

       183
       183
       +
       		}

     

       184
       184
       +
       		if !parsedTime.Equal(now) {

     

       185
       185
       +
       			t.Errorf("Timestamp mismatch: got %v, want %v", parsedTime, now)

     

       186
       186
       +
       		}

     

       187
       187
       +
       	} else {

     

       188
       188
       +
       		t.Errorf("First arg should be string, got %T", args[0])

     

       189
       189
       +
       	}

     

       190
       190
       +
       

     

       191
       191
       +
       	// Second arg should be URI

     

       192
       192
       +
       	if uri, ok := args[1].(string); ok {

     

       193
       193
       +
       		if uri != post.URI {

     

       194
       194
       +
       			t.Errorf("URI mismatch: got %q, want %q", uri, post.URI)

     

       195
       195
       +
       		}

     

       196
       196
       +
       	} else {

     

       197
       197
       +
       		t.Errorf("Second arg should be string, got %T", args[1])

     

       198
       198
       +
       	}

     

       199
       199
       +
       }

     

       200
       200
       +
       

     

       201
       201
       +
       // Helper functions

     

       202
       202
       +
       func strPtr(s string) *string {

     

       203
       203
       +
       	return &s

     

       204
       204
       +
       }

     

       205
       205
       +
       

     

       206
       206
       +
       func containsStr(s, substr string) bool {

     

       207
       207
       +
       	for i := 0; i <= len(s)-len(substr); i++ {

     

       208
       208
       +
       		if s[i:i+len(substr)] == substr {

     

       209
       209
       +
       			return true

     

       210
       210
       +
       		}

     

       211
       211
       +
       	}

     

       212
       212
       +
       	return false

     

       213
       213
       +
       }

     

       214
       214
       +
       

     

       215
       215
       +
       // Ensure the mock repository satisfies the interface

     

       216
       216
       +
       var _ posts.Repository = (*mockPostRepository)(nil)

     

       217
       217
       +
       

     

       218
       218
       +
       type mockPostRepository struct {

     

       219
       219
       +
       	db *sql.DB

     

       220
       220
       +
       }

     

       221
       221
       +
       

     

       222
       222
       +
       func (m *mockPostRepository) Create(ctx context.Context, post *posts.Post) error {

     

       223
       223
       +
       	return nil

     

       224
       224
       +
       }

     

       225
       225
       +
       

     

       226
       226
       +
       func (m *mockPostRepository) GetByURI(ctx context.Context, uri string) (*posts.Post, error) {

     

       227
       227
       +
       	return nil, nil

     

       228
       228
       +
       }

     

       229
       229
       +
       

     

       230
       230
       +
       func (m *mockPostRepository) GetByAuthor(ctx context.Context, req posts.GetAuthorPostsRequest) ([]*posts.PostView, *string, error) {

     

       231
       231
       +
       	return nil, nil, nil

     

       232
       232
       +
       }

     

       233
       233
       +
       

     

       234
       234
       +
       func (m *mockPostRepository) SoftDelete(ctx context.Context, uri string) error {

     

       235
       235
       +
       	return nil

     

       236
       236
       +
       }

     

       237
       237
       +
       

     

       238
       238
       +
       func (m *mockPostRepository) Update(ctx context.Context, post *posts.Post) error {

     

       239
       239
       +
       	return nil

     

       240
       240
       +
       }

     

       241
       241
       +
       

     

       242
       242
       +
       func (m *mockPostRepository) UpdateVoteCounts(ctx context.Context, uri string, upvotes, downvotes int) error {

     

       243
       243
       +
       	return nil

     

       244
       244
       +
       }

CLAUDE.md

···

       56
       56
        
       - [ ]  **Does the Lexicon make sense?** (Would it work for other forums?)

     

       57
       57
        
       - [ ]  **AppView only indexes**: We don't write to CAR files, only read from firehose

     

       58
       58
        
       

     

       59
       59
       +
       Always prefer error codes over dataintegrity boolean markers

     

       60
       60
       +
       

     

       59
       61
        
       ## Security-First Building

     

       60
       62
        
       

     

       61
       63
        
       ### Every Feature MUST:

+47 -1

Makefile

···

       1
       1
       -
       .PHONY: help dev-up dev-down dev-logs dev-status dev-reset test e2e-test clean verify-stack create-test-account mobile-full-setup

     

       1
       1
       +
       .PHONY: help dev-up dev-down dev-logs dev-status dev-reset test test-all e2e-test clean verify-stack create-test-account mobile-full-setup

     

       2
       2
        
       

     

       3
       3
        
       # Default target - show help

     

       4
       4
        
       .DEFAULT_GOAL := help

     
···

       8
       8
        
       RESET := \033[0m

     

       9
       9
        
       GREEN := \033[32m

     

       10
       10
        
       YELLOW := \033[33m

     

       11
       11
       +
       RED := \033[31m

     

       11
       12
        
       

     

       12
       13
        
       # Load test database configuration from .env.dev

     

       13
       14
        
       include .env.dev

     
···

       156
       157
        
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test stop postgres-test

     

       157
       158
        
       	@echo "$(GREEN)✓ Test database stopped$(RESET)"

     

       158
       159
        
       

     

       160
       160
       +
       test-all: ## Run ALL tests with live infrastructure (required before merge)

     

       161
       161
       +
       	@echo ""

     

       162
       162
       +
       	@echo "$(CYAN)═══════════════════════════════════════════════════════════════$(RESET)"

     

       163
       163
       +
       	@echo "$(CYAN)  FULL TEST SUITE - All tests with live infrastructure         $(RESET)"

     

       164
       164
       +
       	@echo "$(CYAN)═══════════════════════════════════════════════════════════════$(RESET)"

     

       165
       165
       +
       	@echo ""

     

       166
       166
       +
       	@echo "$(YELLOW)▶ Checking infrastructure...$(RESET)"

     

       167
       167
       +
       	@echo ""

     

       168
       168
       +
       	@# Check dev stack is running

     

       169
       169
       +
       	@echo "  Checking dev stack (PDS, Jetstream, PLC)..."

     

       170
       170
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev ps 2>/dev/null | grep -q "Up" || \

     

       171
       171
       +
       		(echo "$(RED)  ✗ Dev stack not running. Run 'make dev-up' first.$(RESET)" && exit 1)

     

       172
       172
       +
       	@echo "  $(GREEN)✓ Dev stack is running$(RESET)"

     

       173
       173
       +
       	@# Check AppView is running

     

       174
       174
       +
       	@echo "  Checking AppView (port 8081)..."

     

       175
       175
       +
       	@curl -sf http://127.0.0.1:8081/xrpc/_health >/dev/null 2>&1 || \

     

       176
       176
       +
       		curl -sf http://127.0.0.1:8081/ >/dev/null 2>&1 || \

     

       177
       177
       +
       		(echo "$(RED)  ✗ AppView not running. Run 'make run' in another terminal.$(RESET)" && exit 1)

     

       178
       178
       +
       	@echo "  $(GREEN)✓ AppView is running$(RESET)"

     

       179
       179
       +
       	@# Check test database

     

       180
       180
       +
       	@echo "  Checking test database (port 5434)..."

     

       181
       181
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev ps postgres-test 2>/dev/null | grep -q "Up" || \

     

       182
       182
       +
       		(echo "$(YELLOW)  ⚠ Test database not running, starting it...$(RESET)" && \

     

       183
       183
       +
       		docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test up -d postgres-test && \

     

       184
       184
       +
       		sleep 3 && \

     

       185
       185
       +
       		goose -dir internal/db/migrations postgres "postgresql://$(POSTGRES_TEST_USER):$(POSTGRES_TEST_PASSWORD)@localhost:$(POSTGRES_TEST_PORT)/$(POSTGRES_TEST_DB)?sslmode=disable" up)

     

       186
       186
       +
       	@echo "  $(GREEN)✓ Test database is running$(RESET)"

     

       187
       187
       +
       	@echo ""

     

       188
       188
       +
       	@echo "$(GREEN)▶ [1/3] Unit & Package Tests (./cmd/... ./internal/...)$(RESET)"

     

       189
       189
       +
       	@echo "$(CYAN)───────────────────────────────────────────────────────────────$(RESET)"

     

       190
       190
       +
       	@LOG_ENABLED=false go test ./cmd/... ./internal/... -timeout 120s

     

       191
       191
       +
       	@echo ""

     

       192
       192
       +
       	@echo "$(GREEN)▶ [2/3] Integration Tests (./tests/integration/...)$(RESET)"

     

       193
       193
       +
       	@echo "$(CYAN)───────────────────────────────────────────────────────────────$(RESET)"

     

       194
       194
       +
       	@LOG_ENABLED=false go test ./tests/integration/... -timeout 180s

     

       195
       195
       +
       	@echo ""

     

       196
       196
       +
       	@echo "$(GREEN)▶ [3/3] E2E Tests (./tests/e2e/...)$(RESET)"

     

       197
       197
       +
       	@echo "$(CYAN)───────────────────────────────────────────────────────────────$(RESET)"

     

       198
       198
       +
       	@LOG_ENABLED=false go test ./tests/e2e/... -timeout 180s

     

       199
       199
       +
       	@echo ""

     

       200
       200
       +
       	@echo "$(GREEN)═══════════════════════════════════════════════════════════════$(RESET)"

     

       201
       201
       +
       	@echo "$(GREEN)  ✓ ALL TESTS PASSED - Safe to merge                           $(RESET)"

     

       202
       202
       +
       	@echo "$(GREEN)═══════════════════════════════════════════════════════════════$(RESET)"

     

       203
       203
       +
       	@echo ""

     

       204
       204
       +
       

     

       159
       205
        
       ##@ Code Quality

     

       160
       206
        
       

     

       161
       207
        
       fmt: ## Format all Go code with gofmt

+13

tests/lexicon_validation_test.go

···

       1
       1
        
       package tests

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"io"

     

       5
       5
       +
       	"log"

     

       4
       6
        
       	"os"

     

       5
       7
        
       	"path/filepath"

     

       6
       8
        
       	"strings"

     
···

       9
       11
        
       	lexicon "github.com/bluesky-social/indigo/atproto/lexicon"

     

       10
       12
        
       )

     

       11
       13
        
       

     

       14
       14
       +
       // TestMain controls test setup for the tests package.

     

       15
       15
       +
       // Set LOG_ENABLED=false to suppress application log output during tests.

     

       16
       16
       +
       func TestMain(m *testing.M) {

     

       17
       17
       +
       	// Silence logs when LOG_ENABLED=false (used by make test-all)

     

       18
       18
       +
       	if os.Getenv("LOG_ENABLED") == "false" {

     

       19
       19
       +
       		log.SetOutput(io.Discard)

     

       20
       20
       +
       	}

     

       21
       21
       +
       

     

       22
       22
       +
       	os.Exit(m.Run())

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       12
       25
        
       func TestLexiconSchemaValidation(t *testing.T) {

     

       13
       26
        
       	// Create a new catalog

     

       14
       27
        
       	catalog := lexicon.NewBaseCatalog()

+14

tests/unit/community_service_test.go

···

       4
       4
        
       	"Coves/internal/core/communities"

     

       5
       5
        
       	"context"

     

       6
       6
        
       	"fmt"

     

       7
       7
       +
       	"io"

     

       8
       8
       +
       	"log"

     

       7
       9
        
       	"net/http"

     

       8
       10
        
       	"net/http/httptest"

     

       11
       11
       +
       	"os"

     

       9
       12
        
       	"strings"

     

       10
       13
        
       	"sync/atomic"

     

       11
       14
        
       	"testing"

     

       12
       15
        
       	"time"

     

       13
       16
        
       )

     

       14
       17
        
       

     

       18
       18
       +
       // TestMain controls test setup for the unit package.

     

       19
       19
       +
       // Set LOG_ENABLED=false to suppress application log output during tests.

     

       20
       20
       +
       func TestMain(m *testing.M) {

     

       21
       21
       +
       	// Silence logs when LOG_ENABLED=false (used by make test-all)

     

       22
       22
       +
       	if os.Getenv("LOG_ENABLED") == "false" {

     

       23
       23
       +
       		log.SetOutput(io.Discard)

     

       24
       24
       +
       	}

     

       25
       25
       +
       

     

       26
       26
       +
       	os.Exit(m.Run())

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       15
       29
        
       // mockCommunityRepo is a minimal mock for testing service layer

     

       16
       30
        
       type mockCommunityRepo struct {

     

       17
       31
        
       	communities map[string]*communities.Community

+82 -17

tests/e2e/error_recovery_test.go

···

       86
       86
        
       	t.Run("Events processed successfully after connection", func(t *testing.T) {

     

       87
       87
        
       		// Even though we can't easily test WebSocket reconnection in unit tests,

     

       88
       88
        
       		// we can verify that events are processed correctly after establishing connection

     

       89
       89
       -
       		consumer := jetstream.NewUserEventConsumer(userService, resolver, "", "")

     

       90
       89
        
       		ctx := context.Background()

     

       91
       90
        
       

     

       91
       91
       +
       		// Pre-create user - identity events only update existing users

     

       92
       92
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       93
       93
       +
       			DID:    "did:plc:reconnect123",

     

       94
       94
       +
       			Handle: "reconnect.old.test",

     

       95
       95
       +
       			PDSURL: "http://localhost:3001",

     

       96
       96
       +
       		})

     

       97
       97
       +
       		if err != nil {

     

       98
       98
       +
       			t.Fatalf("Failed to create test user: %v", err)

     

       99
       99
       +
       		}

     

       100
       100
       +
       

     

       101
       101
       +
       		consumer := jetstream.NewUserEventConsumer(userService, resolver, "", "")

     

       102
       102
       +
       

     

       103
       103
       +
       		// Send identity event with new handle

     

       92
       104
        
       		event := jetstream.JetstreamEvent{

     

       93
       105
        
       			Did:  "did:plc:reconnect123",

     

       94
       106
        
       			Kind: "identity",

     
···

       100
       112
        
       			},

     

       101
       113
        
       		}

     

       102
       114
        
       

     

       103
       103
       -
       		err := consumer.HandleIdentityEventPublic(ctx, &event)

     

       115
       115
       +
       		err = consumer.HandleIdentityEventPublic(ctx, &event)

     

       104
       116
        
       		if err != nil {

     

       105
       117
        
       			t.Fatalf("Failed to process event: %v", err)

     

       106
       118
        
       		}

     
···

       217
       229
        
       

     

       218
       230
        
       	// Verify consumer can still process valid events after malformed ones

     

       219
       231
        
       	t.Run("Valid event after malformed events", func(t *testing.T) {

     

       220
       220
       -
       		consumer := jetstream.NewUserEventConsumer(userService, resolver, "", "")

     

       221
       232
        
       		ctx := context.Background()

     

       222
       233
        
       

     

       234
       234
       +
       		// Pre-create user - identity events only update existing users

     

       235
       235
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       236
       236
       +
       			DID:    "did:plc:recovery123",

     

       237
       237
       +
       			Handle: "recovery.old.test",

     

       238
       238
       +
       			PDSURL: "http://localhost:3001",

     

       239
       239
       +
       		})

     

       240
       240
       +
       		if err != nil {

     

       241
       241
       +
       			t.Fatalf("Failed to create test user: %v", err)

     

       242
       242
       +
       		}

     

       243
       243
       +
       

     

       244
       244
       +
       		consumer := jetstream.NewUserEventConsumer(userService, resolver, "", "")

     

       245
       245
       +
       

     

       246
       246
       +
       		// Send valid identity event with new handle

     

       223
       247
        
       		validEvent := jetstream.JetstreamEvent{

     

       224
       248
        
       			Did:  "did:plc:recovery123",

     

       225
       249
        
       			Kind: "identity",

     
···

       231
       255
        
       			},

     

       232
       256
        
       		}

     

       233
       257
        
       

     

       234
       234
       -
       		err := consumer.HandleIdentityEventPublic(ctx, &validEvent)

     

       258
       258
       +
       		err = consumer.HandleIdentityEventPublic(ctx, &validEvent)

     

       235
       259
        
       		if err != nil {

     

       236
       260
        
       			t.Fatalf("Failed to process valid event after malformed events: %v", err)

     

       237
       261
        
       		}

     

       238
       262
        
       

     

       239
       239
       -
       		// Verify user was indexed

     

       263
       263
       +
       		// Verify user handle was updated

     

       240
       264
        
       		user, err := userService.GetUserByDID(ctx, "did:plc:recovery123")

     

       241
       265
        
       		if err != nil {

     

       242
       242
       -
       			t.Fatalf("User not indexed after malformed events: %v", err)

     

       266
       266
       +
       			t.Fatalf("User not found after valid event: %v", err)

     

       243
       267
        
       		}

     

       244
       268
        
       

     

       245
       269
        
       		if user.Handle != "recovery.test" {

     
···

       362
       386
        
       	ctx := context.Background()

     

       363
       387
        
       

     

       364
       388
        
       	t.Run("Indexing continues during PDS unavailability", func(t *testing.T) {

     

       365
       365
       -
       		// Even though PDS is "unavailable", we can still index events from Jetstream

     

       389
       389
       +
       		// Even though PDS is "unavailable", we can still update events from Jetstream

     

       366
       390
        
       		// because we don't need to contact PDS for identity events

     

       391
       391
       +
       

     

       392
       392
       +
       		// Pre-create user - identity events only update existing users

     

       393
       393
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       394
       394
       +
       			DID:    "did:plc:pdsfail123",

     

       395
       395
       +
       			Handle: "pdsfail.old.test",

     

       396
       396
       +
       			PDSURL: mockPDS.URL,

     

       397
       397
       +
       		})

     

       398
       398
       +
       		if err != nil {

     

       399
       399
       +
       			t.Fatalf("Failed to create test user: %v", err)

     

       400
       400
       +
       		}

     

       401
       401
       +
       

     

       367
       402
        
       		consumer := jetstream.NewUserEventConsumer(userService, resolver, "", "")

     

       368
       403
        
       

     

       369
       404
        
       		event := jetstream.JetstreamEvent{

     
···

       377
       412
        
       			},

     

       378
       413
        
       		}

     

       379
       414
        
       

     

       380
       380
       -
       		err := consumer.HandleIdentityEventPublic(ctx, &event)

     

       415
       415
       +
       		err = consumer.HandleIdentityEventPublic(ctx, &event)

     

       381
       416
        
       		if err != nil {

     

       382
       382
       -
       			t.Fatalf("Failed to index event during PDS unavailability: %v", err)

     

       417
       417
       +
       			t.Fatalf("Failed to process event during PDS unavailability: %v", err)

     

       383
       418
        
       		}

     

       384
       419
        
       

     

       385
       385
       -
       		// Verify user was indexed

     

       420
       420
       +
       		// Verify user handle was updated

     

       386
       421
        
       		user, err := userService.GetUserByDID(ctx, "did:plc:pdsfail123")

     

       387
       422
        
       		if err != nil {

     

       388
       423
        
       			t.Fatalf("Failed to get user during PDS unavailability: %v", err)

     
···

       392
       427
        
       			t.Errorf("Expected handle pdsfail.test, got %s", user.Handle)

     

       393
       428
        
       		}

     

       394
       429
        
       

     

       395
       395
       -
       		t.Log("✓ Indexing continues successfully even when PDS is unavailable")

     

       430
       430
       +
       		t.Log("✓ Handle updates continue successfully even when PDS is unavailable")

     

       396
       431
        
       	})

     

       397
       432
        
       

     

       398
       433
        
       	t.Run("System recovers when PDS comes back online", func(t *testing.T) {

     

       399
       434
        
       		// Mark PDS as available again

     

       400
       435
        
       		shouldFail.Store(false)

     

       401
       436
        
       

     

       437
       437
       +
       		// Pre-create user - identity events only update existing users

     

       438
       438
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       439
       439
       +
       			DID:    "did:plc:pdsrecovery123",

     

       440
       440
       +
       			Handle: "pdsrecovery.old.test",

     

       441
       441
       +
       			PDSURL: mockPDS.URL,

     

       442
       442
       +
       		})

     

       443
       443
       +
       		if err != nil {

     

       444
       444
       +
       			t.Fatalf("Failed to create test user: %v", err)

     

       445
       445
       +
       		}

     

       446
       446
       +
       

     

       402
       447
        
       		// Now operations that require PDS should work

     

       403
       448
        
       		consumer := jetstream.NewUserEventConsumer(userService, resolver, "", "")

     

       404
       449
        
       

     
···

       413
       458
        
       			},

     

       414
       459
        
       		}

     

       415
       460
        
       

     

       416
       416
       -
       		err := consumer.HandleIdentityEventPublic(ctx, &event)

     

       461
       461
       +
       		err = consumer.HandleIdentityEventPublic(ctx, &event)

     

       417
       462
        
       		if err != nil {

     

       418
       418
       -
       			t.Fatalf("Failed to index event after PDS recovery: %v", err)

     

       463
       463
       +
       			t.Fatalf("Failed to process event after PDS recovery: %v", err)

     

       419
       464
        
       		}

     

       420
       465
        
       

     

       421
       466
        
       		user, err := userService.GetUserByDID(ctx, "did:plc:pdsrecovery123")

     
···

       449
       494
        
       	t.Run("Handle updates arriving out of order", func(t *testing.T) {

     

       450
       495
        
       		did := "did:plc:outoforder123"

     

       451
       496
        
       

     

       497
       497
       +
       		// Pre-create user - identity events only update existing users

     

       498
       498
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       499
       499
       +
       			DID:    did,

     

       500
       500
       +
       			Handle: "initial.handle",

     

       501
       501
       +
       			PDSURL: "http://localhost:3001",

     

       502
       502
       +
       		})

     

       503
       503
       +
       		if err != nil {

     

       504
       504
       +
       			t.Fatalf("Failed to create test user: %v", err)

     

       505
       505
       +
       		}

     

       506
       506
       +
       

     

       452
       507
        
       		// Event 3: Latest handle

     

       453
       508
        
       		event3 := jetstream.JetstreamEvent{

     

       454
       509
        
       			Did:  did,

     
···

       511
       566
        
       	})

     

       512
       567
        
       

     

       513
       568
        
       	t.Run("Duplicate events at different times", func(t *testing.T) {

     

       514
       514
       -
       		did := "did:plc:duplicate123"

     

       569
       569
       +
       		did := "did:plc:dupevents123"

     

       570
       570
       +
       

     

       571
       571
       +
       		// Pre-create user - identity events only update existing users

     

       572
       572
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       573
       573
       +
       			DID:    did,

     

       574
       574
       +
       			Handle: "duplicate.handle",

     

       575
       575
       +
       			PDSURL: "http://localhost:3001",

     

       576
       576
       +
       		})

     

       577
       577
       +
       		if err != nil {

     

       578
       578
       +
       			t.Fatalf("Failed to create test user: %v", err)

     

       579
       579
       +
       		}

     

       515
       580
        
       

     

       516
       516
       -
       		// Create user

     

       581
       581
       +
       		// Send identity event

     

       517
       582
        
       		event1 := jetstream.JetstreamEvent{

     

       518
       583
        
       			Did:  did,

     

       519
       584
        
       			Kind: "identity",

     
···

       525
       590
        
       			},

     

       526
       591
        
       		}

     

       527
       592
        
       

     

       528
       528
       -
       		err := consumer.HandleIdentityEventPublic(ctx, &event1)

     

       593
       593
       +
       		err = consumer.HandleIdentityEventPublic(ctx, &event1)

     

       529
       594
        
       		if err != nil {

     

       530
       595
        
       			t.Fatalf("Failed to process first event: %v", err)

     

       531
       596
        
       		}

     
···

       536
       601
        
       			t.Fatalf("Failed to process duplicate event: %v", err)

     

       537
       602
        
       		}

     

       538
       603
        
       

     

       539
       539
       -
       		// Verify still only one user

     

       604
       604
       +
       		// Verify still only one user with same handle

     

       540
       605
        
       		user, err := userService.GetUserByDID(ctx, did)

     

       541
       606
        
       		if err != nil {

     

       542
       607
        
       			t.Fatalf("Failed to get user: %v", err)

+43 -35

tests/integration/jetstream_consumer_test.go

···

       25
       25
        
       

     

       26
       26
        
       	ctx := context.Background()

     

       27
       27
        
       

     

       28
       28
       -
       	t.Run("Index new user from identity event", func(t *testing.T) {

     

       29
       29
       -
       		// Simulate an identity event from Jetstream

     

       28
       28
       +
       	t.Run("Skip identity event for non-existent user", func(t *testing.T) {

     

       29
       29
       +
       		// Identity events for users not in our database should be silently skipped

     

       30
       30
       +
       		// Users are only indexed during OAuth login/signup, not from Jetstream events

     

       30
       31
        
       		event := jetstream.JetstreamEvent{

     

       31
       31
       -
       			Did:  "did:plc:jetstream123",

     

       32
       32
       +
       			Did:  "did:plc:nonexistent123",

     

       32
       33
        
       			Kind: "identity",

     

       33
       34
        
       			Identity: &jetstream.IdentityEvent{

     

       34
       34
       -
       				Did:    "did:plc:jetstream123",

     

       35
       35
       -
       				Handle: "alice.jetstream.test",

     

       35
       35
       +
       				Did:    "did:plc:nonexistent123",

     

       36
       36
       +
       				Handle: "nonexistent.jetstream.test",

     

       36
       37
        
       				Seq:    12345,

     

       37
       38
        
       				Time:   time.Now().Format(time.RFC3339),

     

       38
       39
        
       			},

     
···

       40
       41
        
       

     

       41
       42
        
       		consumer := jetstream.NewUserEventConsumer(userService, resolver, "", "")

     

       42
       43
        
       

     

       43
       43
       -
       		// Handle the event

     

       44
       44
       +
       		// Handle the event - should return nil (skip silently, not error)

     

       44
       45
        
       		err := consumer.HandleIdentityEventPublic(ctx, &event)

     

       45
       46
        
       		if err != nil {

     

       46
       46
       -
       			t.Fatalf("failed to handle identity event: %v", err)

     

       47
       47
       +
       			t.Fatalf("expected nil error for non-existent user, got: %v", err)

     

       47
       48
        
       		}

     

       48
       49
        
       

     

       49
       49
       -
       		// Verify user was indexed

     

       50
       50
       -
       		user, err := userService.GetUserByDID(ctx, "did:plc:jetstream123")

     

       51
       51
       -
       		if err != nil {

     

       52
       52
       -
       			t.Fatalf("failed to get indexed user: %v", err)

     

       53
       53
       -
       		}

     

       54
       54
       -
       

     

       55
       55
       -
       		if user.DID != "did:plc:jetstream123" {

     

       56
       56
       -
       			t.Errorf("expected DID did:plc:jetstream123, got %s", user.DID)

     

       57
       57
       -
       		}

     

       58
       58
       -
       

     

       59
       59
       -
       		if user.Handle != "alice.jetstream.test" {

     

       60
       60
       -
       			t.Errorf("expected handle alice.jetstream.test, got %s", user.Handle)

     

       50
       50
       +
       		// Verify user was NOT created

     

       51
       51
       +
       		_, err = userService.GetUserByDID(ctx, "did:plc:nonexistent123")

     

       52
       52
       +
       		if err == nil {

     

       53
       53
       +
       			t.Fatal("expected user to NOT be created, but found in database")

     

       61
       54
        
       		}

     

       62
       55
        
       	})

     

       63
       56
        
       

     
···

       103
       96
        
       		}

     

       104
       97
        
       	})

     

       105
       98
        
       

     

       106
       106
       -
       	t.Run("Index multiple users", func(t *testing.T) {

     

       107
       107
       -
       		consumer := jetstream.NewUserEventConsumer(userService, resolver, "", "")

     

       108
       108
       -
       

     

       109
       109
       -
       		users := []struct {

     

       110
       110
       -
       			did    string

     

       111
       111
       -
       			handle string

     

       99
       99
       +
       	t.Run("Update multiple existing users via identity events", func(t *testing.T) {

     

       100
       100
       +
       		// Pre-create users - identity events only update existing users

     

       101
       101
       +
       		testUsers := []struct {

     

       102
       102
       +
       			did       string

     

       103
       103
       +
       			oldHandle string

     

       104
       104
       +
       			newHandle string

     

       112
       105
        
       		}{

     

       113
       113
       -
       			{"did:plc:multi1", "user1.test"},

     

       114
       114
       -
       			{"did:plc:multi2", "user2.test"},

     

       115
       115
       -
       			{"did:plc:multi3", "user3.test"},

     

       106
       106
       +
       			{"did:plc:multi1", "user1.old.test", "user1.new.test"},

     

       107
       107
       +
       			{"did:plc:multi2", "user2.old.test", "user2.new.test"},

     

       108
       108
       +
       			{"did:plc:multi3", "user3.old.test", "user3.new.test"},

     

       109
       109
       +
       		}

     

       110
       110
       +
       

     

       111
       111
       +
       		// Create users first

     

       112
       112
       +
       		for _, u := range testUsers {

     

       113
       113
       +
       			_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       114
       114
       +
       				DID:    u.did,

     

       115
       115
       +
       				Handle: u.oldHandle,

     

       116
       116
       +
       				PDSURL: "https://bsky.social",

     

       117
       117
       +
       			})

     

       118
       118
       +
       			if err != nil {

     

       119
       119
       +
       				t.Fatalf("failed to create user %s: %v", u.oldHandle, err)

     

       120
       120
       +
       			}

     

       116
       121
        
       		}

     

       117
       122
        
       

     

       118
       118
       -
       		for _, u := range users {

     

       123
       123
       +
       		consumer := jetstream.NewUserEventConsumer(userService, resolver, "", "")

     

       124
       124
       +
       

     

       125
       125
       +
       		// Send identity events with new handles

     

       126
       126
       +
       		for _, u := range testUsers {

     

       119
       127
        
       			event := jetstream.JetstreamEvent{

     

       120
       128
        
       				Did:  u.did,

     

       121
       129
        
       				Kind: "identity",

     

       122
       130
        
       				Identity: &jetstream.IdentityEvent{

     

       123
       131
        
       					Did:    u.did,

     

       124
       124
       -
       					Handle: u.handle,

     

       132
       132
       +
       					Handle: u.newHandle,

     

       125
       133
        
       					Seq:    12345,

     

       126
       134
        
       					Time:   time.Now().Format(time.RFC3339),

     

       127
       135
        
       				},

     
···

       129
       137
        
       

     

       130
       138
        
       			err := consumer.HandleIdentityEventPublic(ctx, &event)

     

       131
       139
        
       			if err != nil {

     

       132
       132
       -
       				t.Fatalf("failed to index user %s: %v", u.handle, err)

     

       140
       140
       +
       				t.Fatalf("failed to handle identity event for %s: %v", u.newHandle, err)

     

       133
       141
        
       			}

     

       134
       142
        
       		}

     

       135
       143
        
       

     

       136
       136
       -
       		// Verify all users indexed

     

       137
       137
       -
       		for _, u := range users {

     

       144
       144
       +
       		// Verify all users have updated handles

     

       145
       145
       +
       		for _, u := range testUsers {

     

       138
       146
        
       			user, err := userService.GetUserByDID(ctx, u.did)

     

       139
       147
        
       			if err != nil {

     

       140
       148
        
       				t.Fatalf("user %s not found: %v", u.did, err)

     

       141
       149
        
       			}

     

       142
       150
        
       

     

       143
       143
       -
       			if user.Handle != u.handle {

     

       144
       144
       -
       				t.Errorf("expected handle %s, got %s", u.handle, user.Handle)

     

       151
       151
       +
       			if user.Handle != u.newHandle {

     

       152
       152
       +
       				t.Errorf("expected handle %s, got %s", u.newHandle, user.Handle)

     

       145
       153
        
       			}

     

       146
       154
        
       		}

     

       147
       155
        
       	})

+42 -21

internal/api/routes/user.go

···

       6
       6
        
       	"errors"

     

       7
       7
        
       	"log"

     

       8
       8
        
       	"net/http"

     

       9
       9
       -
       	"time"

     

       9
       9
       +
       	"strings"

     

       10
       10
        
       

     

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

     

       12
       12
        
       )

     
···

       37
       37
        
       

     

       38
       38
        
       // GetProfile handles social.coves.actor.getprofile

     

       39
       39
        
       // Query endpoint that retrieves a user profile by DID or handle

     

       40
       40
       +
       // Returns profileViewDetailed with stats per lexicon specification

     

       40
       41
        
       func (h *UserHandler) GetProfile(w http.ResponseWriter, r *http.Request) {

     

       41
       42
        
       	ctx := r.Context()

     

       42
       43
        
       

     

       43
       44
        
       	// Get actor parameter (DID or handle)

     

       44
       45
        
       	actor := r.URL.Query().Get("actor")

     

       45
       46
        
       	if actor == "" {

     

       46
       46
       -
       		http.Error(w, "actor parameter is required", http.StatusBadRequest)

     

       47
       47
       +
       		writeXRPCError(w, "InvalidRequest", "actor parameter is required", http.StatusBadRequest)

     

       47
       48
        
       		return

     

       48
       49
        
       	}

     

       49
       50
        
       

     

       50
       50
       -
       	var user *users.User

     

       51
       51
       -
       	var err error

     

       52
       52
       -
       

     

       53
       53
       -
       	// Determine if actor is a DID or handle

     

       54
       54
       -
       	// DIDs start with "did:", handles don't

     

       55
       55
       -
       	if len(actor) > 4 && actor[:4] == "did:" {

     

       56
       56
       -
       		user, err = h.userService.GetUserByDID(ctx, actor)

     

       51
       51
       +
       	// Resolve actor to DID

     

       52
       52
       +
       	var did string

     

       53
       53
       +
       	if strings.HasPrefix(actor, "did:") {

     

       54
       54
       +
       		did = actor

     

       57
       55
        
       	} else {

     

       58
       58
       -
       		user, err = h.userService.GetUserByHandle(ctx, actor)

     

       56
       56
       +
       		// Resolve handle to DID

     

       57
       57
       +
       		resolvedDID, err := h.userService.ResolveHandleToDID(ctx, actor)

     

       58
       58
       +
       		if err != nil {

     

       59
       59
       +
       			writeXRPCError(w, "ProfileNotFound", "user not found", http.StatusNotFound)

     

       60
       60
       +
       			return

     

       61
       61
       +
       		}

     

       62
       62
       +
       		did = resolvedDID

     

       59
       63
        
       	}

     

       60
       64
        
       

     

       65
       65
       +
       	// Get full profile with stats

     

       66
       66
       +
       	profile, err := h.userService.GetProfile(ctx, did)

     

       61
       67
        
       	if err != nil {

     

       62
       62
       -
       		http.Error(w, "user not found", http.StatusNotFound)

     

       68
       68
       +
       		if errors.Is(err, users.ErrUserNotFound) {

     

       69
       69
       +
       			writeXRPCError(w, "ProfileNotFound", "user not found", http.StatusNotFound)

     

       70
       70
       +
       			return

     

       71
       71
       +
       		}

     

       72
       72
       +
       		log.Printf("Failed to get profile for %s: %v", did, err)

     

       73
       73
       +
       		writeXRPCError(w, "InternalError", "failed to get profile", http.StatusInternalServerError)

     

       63
       74
        
       		return

     

       64
       75
        
       	}

     

       65
       76
        
       

     

       66
       66
       -
       	// Minimal profile response (matching lexicon structure)

     

       67
       67
       -
       	response := map[string]interface{}{

     

       68
       68
       -
       		"did": user.DID,

     

       69
       69
       -
       		"profile": map[string]interface{}{

     

       70
       70
       -
       			"handle":    user.Handle,

     

       71
       71
       -
       			"createdAt": user.CreatedAt.Format(time.RFC3339),

     

       72
       72
       -
       		},

     

       77
       77
       +
       	// Marshal to bytes first to avoid partial writes on encoding errors

     

       78
       78
       +
       	responseBytes, err := json.Marshal(profile)

     

       79
       79
       +
       	if err != nil {

     

       80
       80
       +
       		log.Printf("Failed to marshal profile response: %v", err)

     

       81
       81
       +
       		writeXRPCError(w, "InternalError", "failed to encode response", http.StatusInternalServerError)

     

       82
       82
       +
       		return

     

       73
       83
        
       	}

     

       74
       84
        
       

     

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

     

       76
       76
       -
       	w.WriteHeader(http.StatusOK)

     

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

     

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

     

       86
       86
       +
       	if _, err := w.Write(responseBytes); err != nil {

     

       87
       87
       +
       		log.Printf("Failed to write response: %v", err)

     

       88
       88
       +
       	}

     

       89
       89
       +
       }

     

       90
       90
       +
       

     

       91
       91
       +
       // writeXRPCError writes a standardized XRPC error response

     

       92
       92
       +
       func writeXRPCError(w http.ResponseWriter, errorName, message string, statusCode int) {

     

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

     

       94
       94
       +
       	w.WriteHeader(statusCode)

     

       95
       95
       +
       	if err := json.NewEncoder(w).Encode(map[string]interface{}{

     

       96
       96
       +
       		"error":   errorName,

     

       97
       97
       +
       		"message": message,

     

       98
       98
       +
       	}); err != nil {

     

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

     

       79
       100
        
       	}

     

       80
       101
        
       }

     

       81
       102

+33 -1

internal/core/users/service.go

···

       147
       147
        
       	if err == nil && user != nil {

     

       148
       148
        
       		return user.DID, nil

     

       149
       149
        
       	}

     

       150
       150
       -
       	// If not found locally, fall through to external resolution

     

       150
       150
       +
       	// Log database errors (but not "not found" which is expected for unindexed users)

     

       151
       151
       +
       	if err != nil && !errors.Is(err, ErrUserNotFound) {

     

       152
       152
       +
       		log.Printf("Warning: database error during handle lookup for %s (falling back to external resolution): %v", handle, err)

     

       153
       153
       +
       	}

     

       154
       154
       +
       	// If not found locally or error, fall through to external resolution

     

       151
       155
        
       

     

       152
       156
        
       	// Slow path: use identity resolver for external DNS/HTTPS resolution

     

       153
       157
        
       	did, _, err := s.identityResolver.ResolveHandle(ctx, handle)

     
···

       259
       263
        
       	return nil

     

       260
       264
        
       }

     

       261
       265
        
       

     

       266
       266
       +
       // GetProfile retrieves a user's full profile with aggregated statistics.

     

       267
       267
       +
       // Returns a ProfileViewDetailed matching the social.coves.actor.defs#profileViewDetailed lexicon.

     

       268
       268
       +
       func (s *userService) GetProfile(ctx context.Context, did string) (*ProfileViewDetailed, error) {

     

       269
       269
       +
       	did = strings.TrimSpace(did)

     

       270
       270
       +
       	if did == "" {

     

       271
       271
       +
       		return nil, fmt.Errorf("DID is required")

     

       272
       272
       +
       	}

     

       273
       273
       +
       

     

       274
       274
       +
       	// Get the user first

     

       275
       275
       +
       	user, err := s.userRepo.GetByDID(ctx, did)

     

       276
       276
       +
       	if err != nil {

     

       277
       277
       +
       		return nil, fmt.Errorf("failed to get user: %w", err)

     

       278
       278
       +
       	}

     

       279
       279
       +
       

     

       280
       280
       +
       	// Get aggregated stats

     

       281
       281
       +
       	stats, err := s.userRepo.GetProfileStats(ctx, did)

     

       282
       282
       +
       	if err != nil {

     

       283
       283
       +
       		return nil, fmt.Errorf("failed to get profile stats: %w", err)

     

       284
       284
       +
       	}

     

       285
       285
       +
       

     

       286
       286
       +
       	return &ProfileViewDetailed{

     

       287
       287
       +
       		DID:       user.DID,

     

       288
       288
       +
       		Handle:    user.Handle,

     

       289
       289
       +
       		CreatedAt: user.CreatedAt,

     

       290
       290
       +
       		Stats:     stats,

     

       291
       291
       +
       	}, nil

     

       292
       292
       +
       }

     

       293
       293
       +
       

     

       262
       294
        
       func (s *userService) validateCreateRequest(req CreateUserRequest) error {

     

       263
       295
        
       	if strings.TrimSpace(req.DID) == "" {

     

       264
       296
        
       		return fmt.Errorf("DID is required")

+22

internal/core/users/user.go

···

       38
       38
        
       	RefreshJwt string `json:"refreshJwt"`

     

       39
       39
        
       	PDSURL     string `json:"pdsUrl"`

     

       40
       40
        
       }

     

       41
       41
       +
       

     

       42
       42
       +
       // ProfileStats contains aggregated user statistics

     

       43
       43
       +
       // Matches the social.coves.actor.defs#profileStats lexicon

     

       44
       44
       +
       type ProfileStats struct {

     

       45
       45
       +
       	PostCount       int `json:"postCount"`

     

       46
       46
       +
       	CommentCount    int `json:"commentCount"`

     

       47
       47
       +
       	CommunityCount  int `json:"communityCount"`  // Number of communities subscribed to

     

       48
       48
       +
       	Reputation      int `json:"reputation"`      // Global reputation score (sum across communities)

     

       49
       49
       +
       	MembershipCount int `json:"membershipCount"` // Number of communities with active membership

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       // ProfileViewDetailed is the full profile response

     

       53
       53
       +
       // Matches the social.coves.actor.defs#profileViewDetailed lexicon

     

       54
       54
       +
       type ProfileViewDetailed struct {

     

       55
       55
       +
       	DID       string        `json:"did"`

     

       56
       56
       +
       	Handle    string        `json:"handle,omitempty"`

     

       57
       57
       +
       	CreatedAt time.Time     `json:"createdAt"`

     

       58
       58
       +
       	Stats     *ProfileStats `json:"stats,omitempty"`

     

       59
       59
       +
       	// Future fields (require additional infrastructure):

     

       60
       60
       +
       	// DisplayName, Bio, Avatar, Banner (from PDS profile record)

     

       61
       61
       +
       	// Viewer (requires user-to-user blocking infrastructure)

     

       62
       62
       +
       }

+265

internal/api/handlers/actor/get_comments.go

···

       1
       1
       +
       package actor

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"errors"

     

       6
       6
       +
       	"log"

     

       7
       7
       +
       	"net/http"

     

       8
       8
       +
       	"strconv"

     

       9
       9
       +
       	"strings"

     

       10
       10
       +
       

     

       11
       11
       +
       	"Coves/internal/api/middleware"

     

       12
       12
       +
       	"Coves/internal/core/comments"

     

       13
       13
       +
       	"Coves/internal/core/users"

     

       14
       14
       +
       	"Coves/internal/core/votes"

     

       15
       15
       +
       )

     

       16
       16
       +
       

     

       17
       17
       +
       // GetCommentsHandler handles actor comment retrieval

     

       18
       18
       +
       type GetCommentsHandler struct {

     

       19
       19
       +
       	commentService comments.Service

     

       20
       20
       +
       	userService    users.UserService

     

       21
       21
       +
       	voteService    votes.Service

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       // NewGetCommentsHandler creates a new actor comments handler

     

       25
       25
       +
       func NewGetCommentsHandler(

     

       26
       26
       +
       	commentService comments.Service,

     

       27
       27
       +
       	userService users.UserService,

     

       28
       28
       +
       	voteService votes.Service,

     

       29
       29
       +
       ) *GetCommentsHandler {

     

       30
       30
       +
       	return &GetCommentsHandler{

     

       31
       31
       +
       		commentService: commentService,

     

       32
       32
       +
       		userService:    userService,

     

       33
       33
       +
       		voteService:    voteService,

     

       34
       34
       +
       	}

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       // HandleGetComments retrieves comments by an actor (user)

     

       38
       38
       +
       // GET /xrpc/social.coves.actor.getComments?actor={did_or_handle}&community=...&limit=50&cursor=...

     

       39
       39
       +
       func (h *GetCommentsHandler) HandleGetComments(w http.ResponseWriter, r *http.Request) {

     

       40
       40
       +
       	if r.Method != http.MethodGet {

     

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

     

       42
       42
       +
       		return

     

       43
       43
       +
       	}

     

       44
       44
       +
       

     

       45
       45
       +
       	// Parse query parameters

     

       46
       46
       +
       	req, err := h.parseRequest(r)

     

       47
       47
       +
       	if err != nil {

     

       48
       48
       +
       		// Check if it's an actor not found error (from handle resolution)

     

       49
       49
       +
       		var actorNotFound *actorNotFoundError

     

       50
       50
       +
       		if errors.As(err, &actorNotFound) {

     

       51
       51
       +
       			writeError(w, http.StatusNotFound, "ActorNotFound", "Actor not found")

     

       52
       52
       +
       			return

     

       53
       53
       +
       		}

     

       54
       54
       +
       

     

       55
       55
       +
       		// Check if it's an infrastructure failure during resolution

     

       56
       56
       +
       		// (database down, DNS failures, network errors, etc.)

     

       57
       57
       +
       		var resolutionFailed *resolutionFailedError

     

       58
       58
       +
       		if errors.As(err, &resolutionFailed) {

     

       59
       59
       +
       			log.Printf("ERROR: Actor resolution infrastructure failure: %v", err)

     

       60
       60
       +
       			writeError(w, http.StatusInternalServerError, "InternalServerError", "Failed to resolve actor identity")

     

       61
       61
       +
       			return

     

       62
       62
       +
       		}

     

       63
       63
       +
       

     

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

     

       65
       65
       +
       		return

     

       66
       66
       +
       	}

     

       67
       67
       +
       

     

       68
       68
       +
       	// Get viewer DID for populating viewer state (optional)

     

       69
       69
       +
       	viewerDID := middleware.GetUserDID(r)

     

       70
       70
       +
       	if viewerDID != "" {

     

       71
       71
       +
       		req.ViewerDID = &viewerDID

     

       72
       72
       +
       	}

     

       73
       73
       +
       

     

       74
       74
       +
       	// Get actor comments from service

     

       75
       75
       +
       	response, err := h.commentService.GetActorComments(r.Context(), req)

     

       76
       76
       +
       	if err != nil {

     

       77
       77
       +
       		handleCommentServiceError(w, err)

     

       78
       78
       +
       		return

     

       79
       79
       +
       	}

     

       80
       80
       +
       

     

       81
       81
       +
       	// Populate viewer vote state if authenticated

     

       82
       82
       +
       	h.populateViewerVoteState(r, response)

     

       83
       83
       +
       

     

       84
       84
       +
       	// Pre-encode response to buffer before writing headers

     

       85
       85
       +
       	// This ensures we can return a proper error if encoding fails

     

       86
       86
       +
       	responseBytes, err := json.Marshal(response)

     

       87
       87
       +
       	if err != nil {

     

       88
       88
       +
       		log.Printf("ERROR: Failed to encode actor comments response: %v", err)

     

       89
       89
       +
       		writeError(w, http.StatusInternalServerError, "InternalServerError", "Failed to encode response")

     

       90
       90
       +
       		return

     

       91
       91
       +
       	}

     

       92
       92
       +
       

     

       93
       93
       +
       	// Return comments

     

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

     

       95
       95
       +
       	w.WriteHeader(http.StatusOK)

     

       96
       96
       +
       	if _, err := w.Write(responseBytes); err != nil {

     

       97
       97
       +
       		log.Printf("ERROR: Failed to write actor comments response: %v", err)

     

       98
       98
       +
       	}

     

       99
       99
       +
       }

     

       100
       100
       +
       

     

       101
       101
       +
       // parseRequest parses query parameters into GetActorCommentsRequest

     

       102
       102
       +
       func (h *GetCommentsHandler) parseRequest(r *http.Request) (*comments.GetActorCommentsRequest, error) {

     

       103
       103
       +
       	req := &comments.GetActorCommentsRequest{}

     

       104
       104
       +
       

     

       105
       105
       +
       	// Required: actor (handle or DID)

     

       106
       106
       +
       	actor := r.URL.Query().Get("actor")

     

       107
       107
       +
       	if actor == "" {

     

       108
       108
       +
       		return nil, &validationError{field: "actor", message: "actor parameter is required"}

     

       109
       109
       +
       	}

     

       110
       110
       +
       	// Validate actor length to prevent DoS via massive strings

     

       111
       111
       +
       	// Max DID length is ~2048 chars (did:plc: is 8 + 24 base32 = 32, but did:web: can be longer)

     

       112
       112
       +
       	// Max handle length is 253 chars (DNS limit)

     

       113
       113
       +
       	const maxActorLength = 2048

     

       114
       114
       +
       	if len(actor) > maxActorLength {

     

       115
       115
       +
       		return nil, &validationError{field: "actor", message: "actor parameter exceeds maximum length"}

     

       116
       116
       +
       	}

     

       117
       117
       +
       

     

       118
       118
       +
       	// Resolve actor to DID if it's a handle

     

       119
       119
       +
       	actorDID, err := h.resolveActor(r, actor)

     

       120
       120
       +
       	if err != nil {

     

       121
       121
       +
       		return nil, err

     

       122
       122
       +
       	}

     

       123
       123
       +
       	req.ActorDID = actorDID

     

       124
       124
       +
       

     

       125
       125
       +
       	// Optional: community (handle or DID)

     

       126
       126
       +
       	req.Community = r.URL.Query().Get("community")

     

       127
       127
       +
       

     

       128
       128
       +
       	// Optional: limit (default: 50, max: 100)

     

       129
       129
       +
       	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {

     

       130
       130
       +
       		limit, err := strconv.Atoi(limitStr)

     

       131
       131
       +
       		if err != nil {

     

       132
       132
       +
       			return nil, &validationError{field: "limit", message: "limit must be a valid integer"}

     

       133
       133
       +
       		}

     

       134
       134
       +
       		req.Limit = limit

     

       135
       135
       +
       	}

     

       136
       136
       +
       

     

       137
       137
       +
       	// Optional: cursor

     

       138
       138
       +
       	if cursor := r.URL.Query().Get("cursor"); cursor != "" {

     

       139
       139
       +
       		req.Cursor = &cursor

     

       140
       140
       +
       	}

     

       141
       141
       +
       

     

       142
       142
       +
       	return req, nil

     

       143
       143
       +
       }

     

       144
       144
       +
       

     

       145
       145
       +
       // resolveActor converts an actor identifier (handle or DID) to a DID

     

       146
       146
       +
       func (h *GetCommentsHandler) resolveActor(r *http.Request, actor string) (string, error) {

     

       147
       147
       +
       	// If it's already a DID, return it

     

       148
       148
       +
       	if strings.HasPrefix(actor, "did:") {

     

       149
       149
       +
       		return actor, nil

     

       150
       150
       +
       	}

     

       151
       151
       +
       

     

       152
       152
       +
       	// It's a handle - resolve to DID using user service

     

       153
       153
       +
       	did, err := h.userService.ResolveHandleToDID(r.Context(), actor)

     

       154
       154
       +
       	if err != nil {

     

       155
       155
       +
       		// Check for context errors (timeouts, cancellation) - these are infrastructure errors

     

       156
       156
       +
       		if r.Context().Err() != nil {

     

       157
       157
       +
       			log.Printf("WARN: Handle resolution failed due to context error for %s: %v", actor, err)

     

       158
       158
       +
       			return "", &resolutionFailedError{actor: actor, cause: r.Context().Err()}

     

       159
       159
       +
       		}

     

       160
       160
       +
       

     

       161
       161
       +
       		// Check for common "not found" patterns in error message

     

       162
       162
       +
       		errStr := err.Error()

     

       163
       163
       +
       		isNotFound := strings.Contains(errStr, "not found") ||

     

       164
       164
       +
       			strings.Contains(errStr, "no rows") ||

     

       165
       165
       +
       			strings.Contains(errStr, "unable to resolve")

     

       166
       166
       +
       

     

       167
       167
       +
       		if isNotFound {

     

       168
       168
       +
       			return "", &actorNotFoundError{actor: actor}

     

       169
       169
       +
       		}

     

       170
       170
       +
       

     

       171
       171
       +
       		// For other errors (network, database, DNS failures), return infrastructure error

     

       172
       172
       +
       		// This ensures users see "internal error" not "actor not found" for real problems

     

       173
       173
       +
       		log.Printf("WARN: Handle resolution infrastructure failure for %s: %v", actor, err)

     

       174
       174
       +
       		return "", &resolutionFailedError{actor: actor, cause: err}

     

       175
       175
       +
       	}

     

       176
       176
       +
       

     

       177
       177
       +
       	return did, nil

     

       178
       178
       +
       }

     

       179
       179
       +
       

     

       180
       180
       +
       // populateViewerVoteState enriches comment views with the authenticated user's vote state

     

       181
       181
       +
       func (h *GetCommentsHandler) populateViewerVoteState(r *http.Request, response *comments.GetActorCommentsResponse) {

     

       182
       182
       +
       	if h.voteService == nil || response == nil || len(response.Comments) == 0 {

     

       183
       183
       +
       		return

     

       184
       184
       +
       	}

     

       185
       185
       +
       

     

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

     

       187
       187
       +
       	if session == nil {

     

       188
       188
       +
       		return

     

       189
       189
       +
       	}

     

       190
       190
       +
       

     

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

     

       192
       192
       +
       	if userDID == "" {

     

       193
       193
       +
       		return

     

       194
       194
       +
       	}

     

       195
       195
       +
       

     

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

     

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

     

       198
       198
       +
       		log.Printf("Warning: failed to populate vote cache for actor comments: %v", err)

     

       199
       199
       +
       		return

     

       200
       200
       +
       	}

     

       201
       201
       +
       

     

       202
       202
       +
       	// Collect comment URIs to batch lookup

     

       203
       203
       +
       	commentURIs := make([]string, 0, len(response.Comments))

     

       204
       204
       +
       	for _, comment := range response.Comments {

     

       205
       205
       +
       		if comment != nil {

     

       206
       206
       +
       			commentURIs = append(commentURIs, comment.URI)

     

       207
       207
       +
       		}

     

       208
       208
       +
       	}

     

       209
       209
       +
       

     

       210
       210
       +
       	// Get viewer votes for all comments

     

       211
       211
       +
       	viewerVotes := h.voteService.GetViewerVotesForSubjects(userDID, commentURIs)

     

       212
       212
       +
       

     

       213
       213
       +
       	// Populate viewer state on each comment

     

       214
       214
       +
       	for _, comment := range response.Comments {

     

       215
       215
       +
       		if comment != nil {

     

       216
       216
       +
       			if vote, exists := viewerVotes[comment.URI]; exists {

     

       217
       217
       +
       				comment.Viewer = &comments.CommentViewerState{

     

       218
       218
       +
       					Vote:    &vote.Direction,

     

       219
       219
       +
       					VoteURI: &vote.URI,

     

       220
       220
       +
       				}

     

       221
       221
       +
       			}

     

       222
       222
       +
       		}

     

       223
       223
       +
       	}

     

       224
       224
       +
       }

     

       225
       225
       +
       

     

       226
       226
       +
       // handleCommentServiceError maps service errors to HTTP responses

     

       227
       227
       +
       func handleCommentServiceError(w http.ResponseWriter, err error) {

     

       228
       228
       +
       	if err == nil {

     

       229
       229
       +
       		return

     

       230
       230
       +
       	}

     

       231
       231
       +
       

     

       232
       232
       +
       	errStr := err.Error()

     

       233
       233
       +
       

     

       234
       234
       +
       	// Check for validation errors

     

       235
       235
       +
       	if strings.Contains(errStr, "invalid request") {

     

       236
       236
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", errStr)

     

       237
       237
       +
       		return

     

       238
       238
       +
       	}

     

       239
       239
       +
       

     

       240
       240
       +
       	// Check for not found errors

     

       241
       241
       +
       	if comments.IsNotFound(err) || strings.Contains(errStr, "not found") {

     

       242
       242
       +
       		writeError(w, http.StatusNotFound, "NotFound", "Resource not found")

     

       243
       243
       +
       		return

     

       244
       244
       +
       	}

     

       245
       245
       +
       

     

       246
       246
       +
       	// Check for authorization errors

     

       247
       247
       +
       	if errors.Is(err, comments.ErrNotAuthorized) {

     

       248
       248
       +
       		writeError(w, http.StatusForbidden, "NotAuthorized", "Not authorized")

     

       249
       249
       +
       		return

     

       250
       250
       +
       	}

     

       251
       251
       +
       

     

       252
       252
       +
       	// Default to internal server error

     

       253
       253
       +
       	log.Printf("ERROR: Comment service error: %v", err)

     

       254
       254
       +
       	writeError(w, http.StatusInternalServerError, "InternalServerError", "An unexpected error occurred")

     

       255
       255
       +
       }

     

       256
       256
       +
       

     

       257
       257
       +
       // validationError represents a validation error for a specific field

     

       258
       258
       +
       type validationError struct {

     

       259
       259
       +
       	field   string

     

       260
       260
       +
       	message string

     

       261
       261
       +
       }

     

       262
       262
       +
       

     

       263
       263
       +
       func (e *validationError) Error() string {

     

       264
       264
       +
       	return e.message

     

       265
       265
       +
       }

+617

internal/api/handlers/actor/get_comments_test.go

···

       1
       1
       +
       package actor

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"encoding/json"

     

       6
       6
       +
       	"errors"

     

       7
       7
       +
       	"net/http"

     

       8
       8
       +
       	"net/http/httptest"

     

       9
       9
       +
       	"testing"

     

       10
       10
       +
       	"time"

     

       11
       11
       +
       

     

       12
       12
       +
       	"Coves/internal/core/comments"

     

       13
       13
       +
       	"Coves/internal/core/posts"

     

       14
       14
       +
       	"Coves/internal/core/users"

     

       15
       15
       +
       	"Coves/internal/core/votes"

     

       16
       16
       +
       

     

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

     

       18
       18
       +
       )

     

       19
       19
       +
       

     

       20
       20
       +
       // mockCommentService implements a comment service interface for testing

     

       21
       21
       +
       type mockCommentService struct {

     

       22
       22
       +
       	getActorCommentsFunc func(ctx context.Context, req *comments.GetActorCommentsRequest) (*comments.GetActorCommentsResponse, error)

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       func (m *mockCommentService) GetActorComments(ctx context.Context, req *comments.GetActorCommentsRequest) (*comments.GetActorCommentsResponse, error) {

     

       26
       26
       +
       	if m.getActorCommentsFunc != nil {

     

       27
       27
       +
       		return m.getActorCommentsFunc(ctx, req)

     

       28
       28
       +
       	}

     

       29
       29
       +
       	return &comments.GetActorCommentsResponse{

     

       30
       30
       +
       		Comments: []*comments.CommentView{},

     

       31
       31
       +
       		Cursor:   nil,

     

       32
       32
       +
       	}, nil

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       // Implement other Service methods as no-ops

     

       36
       36
       +
       func (m *mockCommentService) GetComments(ctx context.Context, req *comments.GetCommentsRequest) (*comments.GetCommentsResponse, error) {

     

       37
       37
       +
       	return nil, nil

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       func (m *mockCommentService) CreateComment(ctx context.Context, session *oauthlib.ClientSessionData, req comments.CreateCommentRequest) (*comments.CreateCommentResponse, error) {

     

       41
       41
       +
       	return nil, nil

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       func (m *mockCommentService) UpdateComment(ctx context.Context, session *oauthlib.ClientSessionData, req comments.UpdateCommentRequest) (*comments.UpdateCommentResponse, error) {

     

       45
       45
       +
       	return nil, nil

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       func (m *mockCommentService) DeleteComment(ctx context.Context, session *oauthlib.ClientSessionData, req comments.DeleteCommentRequest) error {

     

       49
       49
       +
       	return nil

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       // mockUserServiceForComments implements users.UserService for testing getComments

     

       53
       53
       +
       type mockUserServiceForComments struct {

     

       54
       54
       +
       	resolveHandleToDIDFunc func(ctx context.Context, handle string) (string, error)

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       func (m *mockUserServiceForComments) CreateUser(ctx context.Context, req users.CreateUserRequest) (*users.User, error) {

     

       58
       58
       +
       	return nil, nil

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       func (m *mockUserServiceForComments) GetUserByDID(ctx context.Context, did string) (*users.User, error) {

     

       62
       62
       +
       	return nil, nil

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       func (m *mockUserServiceForComments) GetUserByHandle(ctx context.Context, handle string) (*users.User, error) {

     

       66
       66
       +
       	return nil, nil

     

       67
       67
       +
       }

     

       68
       68
       +
       

     

       69
       69
       +
       func (m *mockUserServiceForComments) UpdateHandle(ctx context.Context, did, newHandle string) (*users.User, error) {

     

       70
       70
       +
       	return nil, nil

     

       71
       71
       +
       }

     

       72
       72
       +
       

     

       73
       73
       +
       func (m *mockUserServiceForComments) ResolveHandleToDID(ctx context.Context, handle string) (string, error) {

     

       74
       74
       +
       	if m.resolveHandleToDIDFunc != nil {

     

       75
       75
       +
       		return m.resolveHandleToDIDFunc(ctx, handle)

     

       76
       76
       +
       	}

     

       77
       77
       +
       	return "did:plc:testuser", nil

     

       78
       78
       +
       }

     

       79
       79
       +
       

     

       80
       80
       +
       func (m *mockUserServiceForComments) RegisterAccount(ctx context.Context, req users.RegisterAccountRequest) (*users.RegisterAccountResponse, error) {

     

       81
       81
       +
       	return nil, nil

     

       82
       82
       +
       }

     

       83
       83
       +
       

     

       84
       84
       +
       func (m *mockUserServiceForComments) IndexUser(ctx context.Context, did, handle, pdsURL string) error {

     

       85
       85
       +
       	return nil

     

       86
       86
       +
       }

     

       87
       87
       +
       

     

       88
       88
       +
       func (m *mockUserServiceForComments) GetProfile(ctx context.Context, did string) (*users.ProfileViewDetailed, error) {

     

       89
       89
       +
       	return nil, nil

     

       90
       90
       +
       }

     

       91
       91
       +
       

     

       92
       92
       +
       // mockVoteServiceForComments implements votes.Service for testing getComments

     

       93
       93
       +
       type mockVoteServiceForComments struct{}

     

       94
       94
       +
       

     

       95
       95
       +
       func (m *mockVoteServiceForComments) CreateVote(ctx context.Context, session *oauthlib.ClientSessionData, req votes.CreateVoteRequest) (*votes.CreateVoteResponse, error) {

     

       96
       96
       +
       	return nil, nil

     

       97
       97
       +
       }

     

       98
       98
       +
       

     

       99
       99
       +
       func (m *mockVoteServiceForComments) DeleteVote(ctx context.Context, session *oauthlib.ClientSessionData, req votes.DeleteVoteRequest) error {

     

       100
       100
       +
       	return nil

     

       101
       101
       +
       }

     

       102
       102
       +
       

     

       103
       103
       +
       func (m *mockVoteServiceForComments) EnsureCachePopulated(ctx context.Context, session *oauthlib.ClientSessionData) error {

     

       104
       104
       +
       	return nil

     

       105
       105
       +
       }

     

       106
       106
       +
       

     

       107
       107
       +
       func (m *mockVoteServiceForComments) GetViewerVote(userDID, subjectURI string) *votes.CachedVote {

     

       108
       108
       +
       	return nil

     

       109
       109
       +
       }

     

       110
       110
       +
       

     

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

     

       112
       112
       +
       	return nil

     

       113
       113
       +
       }

     

       114
       114
       +
       

     

       115
       115
       +
       func TestGetCommentsHandler_Success(t *testing.T) {

     

       116
       116
       +
       	createdAt := time.Now().Format(time.RFC3339)

     

       117
       117
       +
       	indexedAt := time.Now().Format(time.RFC3339)

     

       118
       118
       +
       

     

       119
       119
       +
       	mockComments := &mockCommentService{

     

       120
       120
       +
       		getActorCommentsFunc: func(ctx context.Context, req *comments.GetActorCommentsRequest) (*comments.GetActorCommentsResponse, error) {

     

       121
       121
       +
       			return &comments.GetActorCommentsResponse{

     

       122
       122
       +
       				Comments: []*comments.CommentView{

     

       123
       123
       +
       					{

     

       124
       124
       +
       						URI:       "at://did:plc:testuser/social.coves.community.comment/abc123",

     

       125
       125
       +
       						CID:       "bafytest123",

     

       126
       126
       +
       						Content:   "Test comment content",

     

       127
       127
       +
       						CreatedAt: createdAt,

     

       128
       128
       +
       						IndexedAt: indexedAt,

     

       129
       129
       +
       						Author: &posts.AuthorView{

     

       130
       130
       +
       							DID:    "did:plc:testuser",

     

       131
       131
       +
       							Handle: "test.user",

     

       132
       132
       +
       						},

     

       133
       133
       +
       						Stats: &comments.CommentStats{

     

       134
       134
       +
       							Upvotes:    5,

     

       135
       135
       +
       							Downvotes:  1,

     

       136
       136
       +
       							Score:      4,

     

       137
       137
       +
       							ReplyCount: 2,

     

       138
       138
       +
       						},

     

       139
       139
       +
       					},

     

       140
       140
       +
       				},

     

       141
       141
       +
       			}, nil

     

       142
       142
       +
       		},

     

       143
       143
       +
       	}

     

       144
       144
       +
       	mockUsers := &mockUserServiceForComments{}

     

       145
       145
       +
       	mockVotes := &mockVoteServiceForComments{}

     

       146
       146
       +
       

     

       147
       147
       +
       	handler := NewGetCommentsHandler(mockComments, mockUsers, mockVotes)

     

       148
       148
       +
       

     

       149
       149
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=did:plc:testuser", nil)

     

       150
       150
       +
       	rec := httptest.NewRecorder()

     

       151
       151
       +
       

     

       152
       152
       +
       	handler.HandleGetComments(rec, req)

     

       153
       153
       +
       

     

       154
       154
       +
       	if rec.Code != http.StatusOK {

     

       155
       155
       +
       		t.Errorf("Expected status 200, got %d", rec.Code)

     

       156
       156
       +
       	}

     

       157
       157
       +
       

     

       158
       158
       +
       	var response comments.GetActorCommentsResponse

     

       159
       159
       +
       	if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {

     

       160
       160
       +
       		t.Fatalf("Failed to decode response: %v", err)

     

       161
       161
       +
       	}

     

       162
       162
       +
       

     

       163
       163
       +
       	if len(response.Comments) != 1 {

     

       164
       164
       +
       		t.Errorf("Expected 1 comment in response, got %d", len(response.Comments))

     

       165
       165
       +
       	}

     

       166
       166
       +
       

     

       167
       167
       +
       	if response.Comments[0].URI != "at://did:plc:testuser/social.coves.community.comment/abc123" {

     

       168
       168
       +
       		t.Errorf("Expected correct comment URI, got '%s'", response.Comments[0].URI)

     

       169
       169
       +
       	}

     

       170
       170
       +
       

     

       171
       171
       +
       	if response.Comments[0].Content != "Test comment content" {

     

       172
       172
       +
       		t.Errorf("Expected correct comment content, got '%s'", response.Comments[0].Content)

     

       173
       173
       +
       	}

     

       174
       174
       +
       }

     

       175
       175
       +
       

     

       176
       176
       +
       func TestGetCommentsHandler_MissingActor(t *testing.T) {

     

       177
       177
       +
       	handler := NewGetCommentsHandler(

     

       178
       178
       +
       		&mockCommentService{},

     

       179
       179
       +
       		&mockUserServiceForComments{},

     

       180
       180
       +
       		&mockVoteServiceForComments{},

     

       181
       181
       +
       	)

     

       182
       182
       +
       

     

       183
       183
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments", nil)

     

       184
       184
       +
       	rec := httptest.NewRecorder()

     

       185
       185
       +
       

     

       186
       186
       +
       	handler.HandleGetComments(rec, req)

     

       187
       187
       +
       

     

       188
       188
       +
       	if rec.Code != http.StatusBadRequest {

     

       189
       189
       +
       		t.Errorf("Expected status 400, got %d", rec.Code)

     

       190
       190
       +
       	}

     

       191
       191
       +
       

     

       192
       192
       +
       	var response ErrorResponse

     

       193
       193
       +
       	if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {

     

       194
       194
       +
       		t.Fatalf("Failed to decode response: %v", err)

     

       195
       195
       +
       	}

     

       196
       196
       +
       

     

       197
       197
       +
       	if response.Error != "InvalidRequest" {

     

       198
       198
       +
       		t.Errorf("Expected error 'InvalidRequest', got '%s'", response.Error)

     

       199
       199
       +
       	}

     

       200
       200
       +
       }

     

       201
       201
       +
       

     

       202
       202
       +
       func TestGetCommentsHandler_InvalidLimit(t *testing.T) {

     

       203
       203
       +
       	handler := NewGetCommentsHandler(

     

       204
       204
       +
       		&mockCommentService{},

     

       205
       205
       +
       		&mockUserServiceForComments{},

     

       206
       206
       +
       		&mockVoteServiceForComments{},

     

       207
       207
       +
       	)

     

       208
       208
       +
       

     

       209
       209
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=did:plc:test&limit=abc", nil)

     

       210
       210
       +
       	rec := httptest.NewRecorder()

     

       211
       211
       +
       

     

       212
       212
       +
       	handler.HandleGetComments(rec, req)

     

       213
       213
       +
       

     

       214
       214
       +
       	if rec.Code != http.StatusBadRequest {

     

       215
       215
       +
       		t.Errorf("Expected status 400, got %d", rec.Code)

     

       216
       216
       +
       	}

     

       217
       217
       +
       

     

       218
       218
       +
       	var response ErrorResponse

     

       219
       219
       +
       	if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {

     

       220
       220
       +
       		t.Fatalf("Failed to decode response: %v", err)

     

       221
       221
       +
       	}

     

       222
       222
       +
       

     

       223
       223
       +
       	if response.Error != "InvalidRequest" {

     

       224
       224
       +
       		t.Errorf("Expected error 'InvalidRequest', got '%s'", response.Error)

     

       225
       225
       +
       	}

     

       226
       226
       +
       }

     

       227
       227
       +
       

     

       228
       228
       +
       func TestGetCommentsHandler_ActorNotFound(t *testing.T) {

     

       229
       229
       +
       	mockUsers := &mockUserServiceForComments{

     

       230
       230
       +
       		resolveHandleToDIDFunc: func(ctx context.Context, handle string) (string, error) {

     

       231
       231
       +
       			return "", posts.ErrActorNotFound

     

       232
       232
       +
       		},

     

       233
       233
       +
       	}

     

       234
       234
       +
       

     

       235
       235
       +
       	handler := NewGetCommentsHandler(

     

       236
       236
       +
       		&mockCommentService{},

     

       237
       237
       +
       		mockUsers,

     

       238
       238
       +
       		&mockVoteServiceForComments{},

     

       239
       239
       +
       	)

     

       240
       240
       +
       

     

       241
       241
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=nonexistent.user", nil)

     

       242
       242
       +
       	rec := httptest.NewRecorder()

     

       243
       243
       +
       

     

       244
       244
       +
       	handler.HandleGetComments(rec, req)

     

       245
       245
       +
       

     

       246
       246
       +
       	if rec.Code != http.StatusNotFound {

     

       247
       247
       +
       		t.Errorf("Expected status 404, got %d", rec.Code)

     

       248
       248
       +
       	}

     

       249
       249
       +
       

     

       250
       250
       +
       	var response ErrorResponse

     

       251
       251
       +
       	if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {

     

       252
       252
       +
       		t.Fatalf("Failed to decode response: %v", err)

     

       253
       253
       +
       	}

     

       254
       254
       +
       

     

       255
       255
       +
       	if response.Error != "ActorNotFound" {

     

       256
       256
       +
       		t.Errorf("Expected error 'ActorNotFound', got '%s'", response.Error)

     

       257
       257
       +
       	}

     

       258
       258
       +
       }

     

       259
       259
       +
       

     

       260
       260
       +
       func TestGetCommentsHandler_ActorLengthExceedsMax(t *testing.T) {

     

       261
       261
       +
       	handler := NewGetCommentsHandler(

     

       262
       262
       +
       		&mockCommentService{},

     

       263
       263
       +
       		&mockUserServiceForComments{},

     

       264
       264
       +
       		&mockVoteServiceForComments{},

     

       265
       265
       +
       	)

     

       266
       266
       +
       

     

       267
       267
       +
       	// Create an actor parameter that exceeds 2048 characters using valid URL characters

     

       268
       268
       +
       	longActorBytes := make([]byte, 2100)

     

       269
       269
       +
       	for i := range longActorBytes {

     

       270
       270
       +
       		longActorBytes[i] = 'a'

     

       271
       271
       +
       	}

     

       272
       272
       +
       	longActor := "did:plc:" + string(longActorBytes)

     

       273
       273
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor="+longActor, nil)

     

       274
       274
       +
       	rec := httptest.NewRecorder()

     

       275
       275
       +
       

     

       276
       276
       +
       	handler.HandleGetComments(rec, req)

     

       277
       277
       +
       

     

       278
       278
       +
       	if rec.Code != http.StatusBadRequest {

     

       279
       279
       +
       		t.Errorf("Expected status 400, got %d", rec.Code)

     

       280
       280
       +
       	}

     

       281
       281
       +
       }

     

       282
       282
       +
       

     

       283
       283
       +
       func TestGetCommentsHandler_InvalidCursor(t *testing.T) {

     

       284
       284
       +
       	// The handleCommentServiceError function checks for "invalid request" in error message

     

       285
       285
       +
       	// to return a BadRequest. An invalid cursor error falls under this category.

     

       286
       286
       +
       	mockComments := &mockCommentService{

     

       287
       287
       +
       		getActorCommentsFunc: func(ctx context.Context, req *comments.GetActorCommentsRequest) (*comments.GetActorCommentsResponse, error) {

     

       288
       288
       +
       			return nil, errors.New("invalid request: invalid cursor format")

     

       289
       289
       +
       		},

     

       290
       290
       +
       	}

     

       291
       291
       +
       

     

       292
       292
       +
       	handler := NewGetCommentsHandler(

     

       293
       293
       +
       		mockComments,

     

       294
       294
       +
       		&mockUserServiceForComments{},

     

       295
       295
       +
       		&mockVoteServiceForComments{},

     

       296
       296
       +
       	)

     

       297
       297
       +
       

     

       298
       298
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=did:plc:test&cursor=invalid", nil)

     

       299
       299
       +
       	rec := httptest.NewRecorder()

     

       300
       300
       +
       

     

       301
       301
       +
       	handler.HandleGetComments(rec, req)

     

       302
       302
       +
       

     

       303
       303
       +
       	if rec.Code != http.StatusBadRequest {

     

       304
       304
       +
       		t.Errorf("Expected status 400, got %d", rec.Code)

     

       305
       305
       +
       	}

     

       306
       306
       +
       

     

       307
       307
       +
       	var response ErrorResponse

     

       308
       308
       +
       	if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {

     

       309
       309
       +
       		t.Fatalf("Failed to decode response: %v", err)

     

       310
       310
       +
       	}

     

       311
       311
       +
       

     

       312
       312
       +
       	if response.Error != "InvalidRequest" {

     

       313
       313
       +
       		t.Errorf("Expected error 'InvalidRequest', got '%s'", response.Error)

     

       314
       314
       +
       	}

     

       315
       315
       +
       }

     

       316
       316
       +
       

     

       317
       317
       +
       func TestGetCommentsHandler_MethodNotAllowed(t *testing.T) {

     

       318
       318
       +
       	handler := NewGetCommentsHandler(

     

       319
       319
       +
       		&mockCommentService{},

     

       320
       320
       +
       		&mockUserServiceForComments{},

     

       321
       321
       +
       		&mockVoteServiceForComments{},

     

       322
       322
       +
       	)

     

       323
       323
       +
       

     

       324
       324
       +
       	req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.getComments", nil)

     

       325
       325
       +
       	rec := httptest.NewRecorder()

     

       326
       326
       +
       

     

       327
       327
       +
       	handler.HandleGetComments(rec, req)

     

       328
       328
       +
       

     

       329
       329
       +
       	if rec.Code != http.StatusMethodNotAllowed {

     

       330
       330
       +
       		t.Errorf("Expected status 405, got %d", rec.Code)

     

       331
       331
       +
       	}

     

       332
       332
       +
       }

     

       333
       333
       +
       

     

       334
       334
       +
       func TestGetCommentsHandler_HandleResolution(t *testing.T) {

     

       335
       335
       +
       	resolvedDID := ""

     

       336
       336
       +
       	mockComments := &mockCommentService{

     

       337
       337
       +
       		getActorCommentsFunc: func(ctx context.Context, req *comments.GetActorCommentsRequest) (*comments.GetActorCommentsResponse, error) {

     

       338
       338
       +
       			resolvedDID = req.ActorDID

     

       339
       339
       +
       			return &comments.GetActorCommentsResponse{Comments: []*comments.CommentView{}}, nil

     

       340
       340
       +
       		},

     

       341
       341
       +
       	}

     

       342
       342
       +
       	mockUsers := &mockUserServiceForComments{

     

       343
       343
       +
       		resolveHandleToDIDFunc: func(ctx context.Context, handle string) (string, error) {

     

       344
       344
       +
       			if handle == "test.user" {

     

       345
       345
       +
       				return "did:plc:resolveduser123", nil

     

       346
       346
       +
       			}

     

       347
       347
       +
       			return "", posts.ErrActorNotFound

     

       348
       348
       +
       		},

     

       349
       349
       +
       	}

     

       350
       350
       +
       

     

       351
       351
       +
       	handler := NewGetCommentsHandler(

     

       352
       352
       +
       		mockComments,

     

       353
       353
       +
       		mockUsers,

     

       354
       354
       +
       		&mockVoteServiceForComments{},

     

       355
       355
       +
       	)

     

       356
       356
       +
       

     

       357
       357
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=test.user", nil)

     

       358
       358
       +
       	rec := httptest.NewRecorder()

     

       359
       359
       +
       

     

       360
       360
       +
       	handler.HandleGetComments(rec, req)

     

       361
       361
       +
       

     

       362
       362
       +
       	if rec.Code != http.StatusOK {

     

       363
       363
       +
       		t.Errorf("Expected status 200, got %d", rec.Code)

     

       364
       364
       +
       	}

     

       365
       365
       +
       

     

       366
       366
       +
       	if resolvedDID != "did:plc:resolveduser123" {

     

       367
       367
       +
       		t.Errorf("Expected resolved DID 'did:plc:resolveduser123', got '%s'", resolvedDID)

     

       368
       368
       +
       	}

     

       369
       369
       +
       }

     

       370
       370
       +
       

     

       371
       371
       +
       func TestGetCommentsHandler_DIDPassThrough(t *testing.T) {

     

       372
       372
       +
       	receivedDID := ""

     

       373
       373
       +
       	mockComments := &mockCommentService{

     

       374
       374
       +
       		getActorCommentsFunc: func(ctx context.Context, req *comments.GetActorCommentsRequest) (*comments.GetActorCommentsResponse, error) {

     

       375
       375
       +
       			receivedDID = req.ActorDID

     

       376
       376
       +
       			return &comments.GetActorCommentsResponse{Comments: []*comments.CommentView{}}, nil

     

       377
       377
       +
       		},

     

       378
       378
       +
       	}

     

       379
       379
       +
       

     

       380
       380
       +
       	handler := NewGetCommentsHandler(

     

       381
       381
       +
       		mockComments,

     

       382
       382
       +
       		&mockUserServiceForComments{},

     

       383
       383
       +
       		&mockVoteServiceForComments{},

     

       384
       384
       +
       	)

     

       385
       385
       +
       

     

       386
       386
       +
       	// When actor is already a DID, it should pass through without resolution

     

       387
       387
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=did:plc:directuser", nil)

     

       388
       388
       +
       	rec := httptest.NewRecorder()

     

       389
       389
       +
       

     

       390
       390
       +
       	handler.HandleGetComments(rec, req)

     

       391
       391
       +
       

     

       392
       392
       +
       	if rec.Code != http.StatusOK {

     

       393
       393
       +
       		t.Errorf("Expected status 200, got %d", rec.Code)

     

       394
       394
       +
       	}

     

       395
       395
       +
       

     

       396
       396
       +
       	if receivedDID != "did:plc:directuser" {

     

       397
       397
       +
       		t.Errorf("Expected DID 'did:plc:directuser', got '%s'", receivedDID)

     

       398
       398
       +
       	}

     

       399
       399
       +
       }

     

       400
       400
       +
       

     

       401
       401
       +
       func TestGetCommentsHandler_EmptyCommentsArray(t *testing.T) {

     

       402
       402
       +
       	mockComments := &mockCommentService{

     

       403
       403
       +
       		getActorCommentsFunc: func(ctx context.Context, req *comments.GetActorCommentsRequest) (*comments.GetActorCommentsResponse, error) {

     

       404
       404
       +
       			return &comments.GetActorCommentsResponse{

     

       405
       405
       +
       				Comments: []*comments.CommentView{},

     

       406
       406
       +
       			}, nil

     

       407
       407
       +
       		},

     

       408
       408
       +
       	}

     

       409
       409
       +
       

     

       410
       410
       +
       	handler := NewGetCommentsHandler(

     

       411
       411
       +
       		mockComments,

     

       412
       412
       +
       		&mockUserServiceForComments{},

     

       413
       413
       +
       		&mockVoteServiceForComments{},

     

       414
       414
       +
       	)

     

       415
       415
       +
       

     

       416
       416
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=did:plc:newuser", nil)

     

       417
       417
       +
       	rec := httptest.NewRecorder()

     

       418
       418
       +
       

     

       419
       419
       +
       	handler.HandleGetComments(rec, req)

     

       420
       420
       +
       

     

       421
       421
       +
       	if rec.Code != http.StatusOK {

     

       422
       422
       +
       		t.Errorf("Expected status 200, got %d", rec.Code)

     

       423
       423
       +
       	}

     

       424
       424
       +
       

     

       425
       425
       +
       	var response comments.GetActorCommentsResponse

     

       426
       426
       +
       	if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {

     

       427
       427
       +
       		t.Fatalf("Failed to decode response: %v", err)

     

       428
       428
       +
       	}

     

       429
       429
       +
       

     

       430
       430
       +
       	if response.Comments == nil {

     

       431
       431
       +
       		t.Error("Expected comments array to be non-nil (empty array), got nil")

     

       432
       432
       +
       	}

     

       433
       433
       +
       

     

       434
       434
       +
       	if len(response.Comments) != 0 {

     

       435
       435
       +
       		t.Errorf("Expected 0 comments for new user, got %d", len(response.Comments))

     

       436
       436
       +
       	}

     

       437
       437
       +
       }

     

       438
       438
       +
       

     

       439
       439
       +
       func TestGetCommentsHandler_WithCursor(t *testing.T) {

     

       440
       440
       +
       	receivedCursor := ""

     

       441
       441
       +
       	mockComments := &mockCommentService{

     

       442
       442
       +
       		getActorCommentsFunc: func(ctx context.Context, req *comments.GetActorCommentsRequest) (*comments.GetActorCommentsResponse, error) {

     

       443
       443
       +
       			if req.Cursor != nil {

     

       444
       444
       +
       				receivedCursor = *req.Cursor

     

       445
       445
       +
       			}

     

       446
       446
       +
       			nextCursor := "page2cursor"

     

       447
       447
       +
       			return &comments.GetActorCommentsResponse{

     

       448
       448
       +
       				Comments: []*comments.CommentView{},

     

       449
       449
       +
       				Cursor:   &nextCursor,

     

       450
       450
       +
       			}, nil

     

       451
       451
       +
       		},

     

       452
       452
       +
       	}

     

       453
       453
       +
       

     

       454
       454
       +
       	handler := NewGetCommentsHandler(

     

       455
       455
       +
       		mockComments,

     

       456
       456
       +
       		&mockUserServiceForComments{},

     

       457
       457
       +
       		&mockVoteServiceForComments{},

     

       458
       458
       +
       	)

     

       459
       459
       +
       

     

       460
       460
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=did:plc:test&cursor=testcursor123", nil)

     

       461
       461
       +
       	rec := httptest.NewRecorder()

     

       462
       462
       +
       

     

       463
       463
       +
       	handler.HandleGetComments(rec, req)

     

       464
       464
       +
       

     

       465
       465
       +
       	if rec.Code != http.StatusOK {

     

       466
       466
       +
       		t.Errorf("Expected status 200, got %d", rec.Code)

     

       467
       467
       +
       	}

     

       468
       468
       +
       

     

       469
       469
       +
       	if receivedCursor != "testcursor123" {

     

       470
       470
       +
       		t.Errorf("Expected cursor 'testcursor123', got '%s'", receivedCursor)

     

       471
       471
       +
       	}

     

       472
       472
       +
       

     

       473
       473
       +
       	var response comments.GetActorCommentsResponse

     

       474
       474
       +
       	if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {

     

       475
       475
       +
       		t.Fatalf("Failed to decode response: %v", err)

     

       476
       476
       +
       	}

     

       477
       477
       +
       

     

       478
       478
       +
       	if response.Cursor == nil || *response.Cursor != "page2cursor" {

     

       479
       479
       +
       		t.Error("Expected response to include next cursor")

     

       480
       480
       +
       	}

     

       481
       481
       +
       }

     

       482
       482
       +
       

     

       483
       483
       +
       func TestGetCommentsHandler_WithLimit(t *testing.T) {

     

       484
       484
       +
       	receivedLimit := 0

     

       485
       485
       +
       	mockComments := &mockCommentService{

     

       486
       486
       +
       		getActorCommentsFunc: func(ctx context.Context, req *comments.GetActorCommentsRequest) (*comments.GetActorCommentsResponse, error) {

     

       487
       487
       +
       			receivedLimit = req.Limit

     

       488
       488
       +
       			return &comments.GetActorCommentsResponse{

     

       489
       489
       +
       				Comments: []*comments.CommentView{},

     

       490
       490
       +
       			}, nil

     

       491
       491
       +
       		},

     

       492
       492
       +
       	}

     

       493
       493
       +
       

     

       494
       494
       +
       	handler := NewGetCommentsHandler(

     

       495
       495
       +
       		mockComments,

     

       496
       496
       +
       		&mockUserServiceForComments{},

     

       497
       497
       +
       		&mockVoteServiceForComments{},

     

       498
       498
       +
       	)

     

       499
       499
       +
       

     

       500
       500
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=did:plc:test&limit=25", nil)

     

       501
       501
       +
       	rec := httptest.NewRecorder()

     

       502
       502
       +
       

     

       503
       503
       +
       	handler.HandleGetComments(rec, req)

     

       504
       504
       +
       

     

       505
       505
       +
       	if rec.Code != http.StatusOK {

     

       506
       506
       +
       		t.Errorf("Expected status 200, got %d", rec.Code)

     

       507
       507
       +
       	}

     

       508
       508
       +
       

     

       509
       509
       +
       	if receivedLimit != 25 {

     

       510
       510
       +
       		t.Errorf("Expected limit 25, got %d", receivedLimit)

     

       511
       511
       +
       	}

     

       512
       512
       +
       }

     

       513
       513
       +
       

     

       514
       514
       +
       func TestGetCommentsHandler_WithCommunityFilter(t *testing.T) {

     

       515
       515
       +
       	receivedCommunity := ""

     

       516
       516
       +
       	mockComments := &mockCommentService{

     

       517
       517
       +
       		getActorCommentsFunc: func(ctx context.Context, req *comments.GetActorCommentsRequest) (*comments.GetActorCommentsResponse, error) {

     

       518
       518
       +
       			receivedCommunity = req.Community

     

       519
       519
       +
       			return &comments.GetActorCommentsResponse{

     

       520
       520
       +
       				Comments: []*comments.CommentView{},

     

       521
       521
       +
       			}, nil

     

       522
       522
       +
       		},

     

       523
       523
       +
       	}

     

       524
       524
       +
       

     

       525
       525
       +
       	handler := NewGetCommentsHandler(

     

       526
       526
       +
       		mockComments,

     

       527
       527
       +
       		&mockUserServiceForComments{},

     

       528
       528
       +
       		&mockVoteServiceForComments{},

     

       529
       529
       +
       	)

     

       530
       530
       +
       

     

       531
       531
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=did:plc:test&community=did:plc:community123", nil)

     

       532
       532
       +
       	rec := httptest.NewRecorder()

     

       533
       533
       +
       

     

       534
       534
       +
       	handler.HandleGetComments(rec, req)

     

       535
       535
       +
       

     

       536
       536
       +
       	if rec.Code != http.StatusOK {

     

       537
       537
       +
       		t.Errorf("Expected status 200, got %d", rec.Code)

     

       538
       538
       +
       	}

     

       539
       539
       +
       

     

       540
       540
       +
       	if receivedCommunity != "did:plc:community123" {

     

       541
       541
       +
       		t.Errorf("Expected community 'did:plc:community123', got '%s'", receivedCommunity)

     

       542
       542
       +
       	}

     

       543
       543
       +
       }

     

       544
       544
       +
       

     

       545
       545
       +
       func TestGetCommentsHandler_ServiceError_Returns500(t *testing.T) {

     

       546
       546
       +
       	// Test that generic service errors (database failures, etc.) return 500

     

       547
       547
       +
       	mockComments := &mockCommentService{

     

       548
       548
       +
       		getActorCommentsFunc: func(ctx context.Context, req *comments.GetActorCommentsRequest) (*comments.GetActorCommentsResponse, error) {

     

       549
       549
       +
       			return nil, errors.New("database connection failed")

     

       550
       550
       +
       		},

     

       551
       551
       +
       	}

     

       552
       552
       +
       

     

       553
       553
       +
       	handler := NewGetCommentsHandler(

     

       554
       554
       +
       		mockComments,

     

       555
       555
       +
       		&mockUserServiceForComments{},

     

       556
       556
       +
       		&mockVoteServiceForComments{},

     

       557
       557
       +
       	)

     

       558
       558
       +
       

     

       559
       559
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=did:plc:test", nil)

     

       560
       560
       +
       	rec := httptest.NewRecorder()

     

       561
       561
       +
       

     

       562
       562
       +
       	handler.HandleGetComments(rec, req)

     

       563
       563
       +
       

     

       564
       564
       +
       	if rec.Code != http.StatusInternalServerError {

     

       565
       565
       +
       		t.Errorf("Expected status 500, got %d", rec.Code)

     

       566
       566
       +
       	}

     

       567
       567
       +
       

     

       568
       568
       +
       	var response ErrorResponse

     

       569
       569
       +
       	if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {

     

       570
       570
       +
       		t.Fatalf("Failed to decode response: %v", err)

     

       571
       571
       +
       	}

     

       572
       572
       +
       

     

       573
       573
       +
       	if response.Error != "InternalServerError" {

     

       574
       574
       +
       		t.Errorf("Expected error 'InternalServerError', got '%s'", response.Error)

     

       575
       575
       +
       	}

     

       576
       576
       +
       

     

       577
       577
       +
       	// Verify error message doesn't leak internal details

     

       578
       578
       +
       	if response.Message == "database connection failed" {

     

       579
       579
       +
       		t.Error("Error message should not leak internal error details")

     

       580
       580
       +
       	}

     

       581
       581
       +
       }

     

       582
       582
       +
       

     

       583
       583
       +
       func TestGetCommentsHandler_ResolutionFailedError_Returns500(t *testing.T) {

     

       584
       584
       +
       	// Test that infrastructure failures during handle resolution return 500, not 400

     

       585
       585
       +
       	mockUsers := &mockUserServiceForComments{

     

       586
       586
       +
       		resolveHandleToDIDFunc: func(ctx context.Context, handle string) (string, error) {

     

       587
       587
       +
       			// Simulate a database failure during resolution

     

       588
       588
       +
       			return "", errors.New("connection refused")

     

       589
       589
       +
       		},

     

       590
       590
       +
       	}

     

       591
       591
       +
       

     

       592
       592
       +
       	handler := NewGetCommentsHandler(

     

       593
       593
       +
       		&mockCommentService{},

     

       594
       594
       +
       		mockUsers,

     

       595
       595
       +
       		&mockVoteServiceForComments{},

     

       596
       596
       +
       	)

     

       597
       597
       +
       

     

       598
       598
       +
       	// Use a handle (not a DID) to trigger resolution

     

       599
       599
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.actor.getComments?actor=test.user", nil)

     

       600
       600
       +
       	rec := httptest.NewRecorder()

     

       601
       601
       +
       

     

       602
       602
       +
       	handler.HandleGetComments(rec, req)

     

       603
       603
       +
       

     

       604
       604
       +
       	// Infrastructure failures should return 500, not 400 or 404

     

       605
       605
       +
       	if rec.Code != http.StatusInternalServerError {

     

       606
       606
       +
       		t.Errorf("Expected status 500 for infrastructure failure, got %d", rec.Code)

     

       607
       607
       +
       	}

     

       608
       608
       +
       

     

       609
       609
       +
       	var response ErrorResponse

     

       610
       610
       +
       	if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {

     

       611
       611
       +
       		t.Fatalf("Failed to decode response: %v", err)

     

       612
       612
       +
       	}

     

       613
       613
       +
       

     

       614
       614
       +
       	if response.Error != "InternalServerError" {

     

       615
       615
       +
       		t.Errorf("Expected error 'InternalServerError', got '%s'", response.Error)

     

       616
       616
       +
       	}

     

       617
       617
       +
       }

+60

internal/atproto/lexicon/social/coves/actor/getComments.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "social.coves.actor.getComments",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get a user's comments for their profile page.",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": ["actor"],

     

       11
       11
       +
               "properties": {

     

       12
       12
       +
                 "actor": {

     

       13
       13
       +
                   "type": "string",

     

       14
       14
       +
                   "format": "at-identifier",

     

       15
       15
       +
                   "description": "DID or handle of the user"

     

       16
       16
       +
                 },

     

       17
       17
       +
                 "community": {

     

       18
       18
       +
                   "type": "string",

     

       19
       19
       +
                   "format": "at-identifier",

     

       20
       20
       +
                   "description": "Filter to comments in a specific community"

     

       21
       21
       +
                 },

     

       22
       22
       +
                 "limit": {

     

       23
       23
       +
                   "type": "integer",

     

       24
       24
       +
                   "minimum": 1,

     

       25
       25
       +
                   "maximum": 100,

     

       26
       26
       +
                   "default": 50

     

       27
       27
       +
                 },

     

       28
       28
       +
                 "cursor": {

     

       29
       29
       +
                   "type": "string"

     

       30
       30
       +
                 }

     

       31
       31
       +
               }

     

       32
       32
       +
             },

     

       33
       33
       +
             "output": {

     

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

     

       35
       35
       +
               "schema": {

     

       36
       36
       +
                 "type": "object",

     

       37
       37
       +
                 "required": ["comments"],

     

       38
       38
       +
                 "properties": {

     

       39
       39
       +
                   "comments": {

     

       40
       40
       +
                     "type": "array",

     

       41
       41
       +
                     "items": {

     

       42
       42
       +
                       "type": "ref",

     

       43
       43
       +
                       "ref": "social.coves.community.comment.defs#commentView"

     

       44
       44
       +
                     }

     

       45
       45
       +
                   },

     

       46
       46
       +
                   "cursor": {

     

       47
       47
       +
                     "type": "string"

     

       48
       48
       +
                   }

     

       49
       49
       +
                 }

     

       50
       50
       +
               }

     

       51
       51
       +
             },

     

       52
       52
       +
             "errors": [

     

       53
       53
       +
               {

     

       54
       54
       +
                 "name": "NotFound",

     

       55
       55
       +
                 "description": "Actor not found"

     

       56
       56
       +
               }

     

       57
       57
       +
             ]

     

       58
       58
       +
           }

     

       59
       59
       +
         }

     

       60
       60
       +
       }

internal/core/comments/comment.go

···

       79
       79
        
       	Neg *bool  `json:"neg,omitempty"`

     

       80
       80
        
       	Val string `json:"val"`

     

       81
       81
        
       }

     

       82
       82
       +
       

     

       83
       83
       +
       // ListByCommenterRequest defines the parameters for fetching a user's comments

     

       84
       84
       +
       // Used by social.coves.actor.getComments endpoint

     

       85
       85
       +
       type ListByCommenterRequest struct {

     

       86
       86
       +
       	CommenterDID string  // Required: DID of the commenter

     

       87
       87
       +
       	CommunityDID *string // Optional: filter to comments in a specific community

     

       88
       88
       +
       	Limit        int     // Max comments to return (1-100)

     

       89
       89
       +
       	Cursor       *string // Pagination cursor from previous response

     

       90
       90
       +
       }

+151

internal/db/postgres/comment_repo.go

···

       410
       410
        
       	return result, nil

     

       411
       411
        
       }

     

       412
       412
        
       

     

       413
       413
       +
       // ListByCommenterWithCursor retrieves comments by a user with cursor-based pagination

     

       414
       414
       +
       // Used for user profile comment history (social.coves.actor.getComments)

     

       415
       415
       +
       // Supports optional community filtering and returns next page cursor

     

       416
       416
       +
       // Uses chronological ordering (newest first) with composite key cursor for stable pagination

     

       417
       417
       +
       func (r *postgresCommentRepo) ListByCommenterWithCursor(ctx context.Context, req comments.ListByCommenterRequest) ([]*comments.Comment, *string, error) {

     

       418
       418
       +
       	// Parse cursor for pagination

     

       419
       419
       +
       	cursorFilter, cursorValues, err := r.parseCommenterCursor(req.Cursor)

     

       420
       420
       +
       	if err != nil {

     

       421
       421
       +
       		return nil, nil, fmt.Errorf("invalid cursor: %w", err)

     

       422
       422
       +
       	}

     

       423
       423
       +
       

     

       424
       424
       +
       	// Build community filter if provided

     

       425
       425
       +
       	// Parameter numbering: $1=commenterDID, $2=limit+1 (for pagination detection)

     

       426
       426
       +
       	// Cursor values (if present) use $3 and $4, community DID comes after

     

       427
       427
       +
       	var communityFilter string

     

       428
       428
       +
       	var communityValue []interface{}

     

       429
       429
       +
       	paramOffset := 2 + len(cursorValues) // Start after $1, $2, and any cursor params

     

       430
       430
       +
       	if req.CommunityDID != nil && *req.CommunityDID != "" {

     

       431
       431
       +
       		paramOffset++

     

       432
       432
       +
       		communityFilter = fmt.Sprintf("AND c.root_uri IN (SELECT uri FROM posts WHERE community_did = $%d)", paramOffset)

     

       433
       433
       +
       		communityValue = append(communityValue, *req.CommunityDID)

     

       434
       434
       +
       	}

     

       435
       435
       +
       

     

       436
       436
       +
       	// Build complete query with JOINs and filters

     

       437
       437
       +
       	// LEFT JOIN prevents data loss when user record hasn't been indexed yet

     

       438
       438
       +
       	query := fmt.Sprintf(`

     

       439
       439
       +
       		SELECT

     

       440
       440
       +
       			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       441
       441
       +
       			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       442
       442
       +
       			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

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

     

       444
       444
       +
       			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       445
       445
       +
       			COALESCE(u.handle, c.commenter_did) as author_handle

     

       446
       446
       +
       		FROM comments c

     

       447
       447
       +
       		LEFT JOIN users u ON c.commenter_did = u.did

     

       448
       448
       +
       		WHERE c.commenter_did = $1

     

       449
       449
       +
       			AND c.deleted_at IS NULL

     

       450
       450
       +
       			%s

     

       451
       451
       +
       			%s

     

       452
       452
       +
       		ORDER BY c.created_at DESC, c.uri DESC

     

       453
       453
       +
       		LIMIT $2

     

       454
       454
       +
       	`, communityFilter, cursorFilter)

     

       455
       455
       +
       

     

       456
       456
       +
       	// Prepare query arguments

     

       457
       457
       +
       	args := []interface{}{req.CommenterDID, req.Limit + 1} // +1 to detect next page

     

       458
       458
       +
       	args = append(args, cursorValues...)

     

       459
       459
       +
       	args = append(args, communityValue...)

     

       460
       460
       +
       

     

       461
       461
       +
       	// Execute query

     

       462
       462
       +
       	rows, err := r.db.QueryContext(ctx, query, args...)

     

       463
       463
       +
       	if err != nil {

     

       464
       464
       +
       		return nil, nil, fmt.Errorf("failed to query comments by commenter: %w", err)

     

       465
       465
       +
       	}

     

       466
       466
       +
       	defer func() {

     

       467
       467
       +
       		if err := rows.Close(); err != nil {

     

       468
       468
       +
       			log.Printf("Failed to close rows: %v", err)

     

       469
       469
       +
       		}

     

       470
       470
       +
       	}()

     

       471
       471
       +
       

     

       472
       472
       +
       	// Scan results

     

       473
       473
       +
       	var result []*comments.Comment

     

       474
       474
       +
       	for rows.Next() {

     

       475
       475
       +
       		var comment comments.Comment

     

       476
       476
       +
       		var langs pq.StringArray

     

       477
       477
       +
       		var authorHandle string

     

       478
       478
       +
       

     

       479
       479
       +
       		err := rows.Scan(

     

       480
       480
       +
       			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       481
       481
       +
       			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       482
       482
       +
       			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

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

     

       484
       484
       +
       			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       485
       485
       +
       			&authorHandle,

     

       486
       486
       +
       		)

     

       487
       487
       +
       		if err != nil {

     

       488
       488
       +
       			return nil, nil, fmt.Errorf("failed to scan comment: %w", err)

     

       489
       489
       +
       		}

     

       490
       490
       +
       

     

       491
       491
       +
       		comment.Langs = langs

     

       492
       492
       +
       		comment.CommenterHandle = authorHandle

     

       493
       493
       +
       		result = append(result, &comment)

     

       494
       494
       +
       	}

     

       495
       495
       +
       

     

       496
       496
       +
       	if err = rows.Err(); err != nil {

     

       497
       497
       +
       		return nil, nil, fmt.Errorf("error iterating comments: %w", err)

     

       498
       498
       +
       	}

     

       499
       499
       +
       

     

       500
       500
       +
       	// Handle pagination cursor

     

       501
       501
       +
       	var nextCursor *string

     

       502
       502
       +
       	if len(result) > req.Limit && req.Limit > 0 {

     

       503
       503
       +
       		result = result[:req.Limit]

     

       504
       504
       +
       		lastComment := result[len(result)-1]

     

       505
       505
       +
       		cursorStr := r.buildCommenterCursor(lastComment)

     

       506
       506
       +
       		nextCursor = &cursorStr

     

       507
       507
       +
       	}

     

       508
       508
       +
       

     

       509
       509
       +
       	return result, nextCursor, nil

     

       510
       510
       +
       }

     

       511
       511
       +
       

     

       512
       512
       +
       // parseCommenterCursor decodes pagination cursor for commenter comments

     

       513
       513
       +
       // Cursor format: createdAt|uri (same as "new" sort for other comment queries)

     

       514
       514
       +
       //

     

       515
       515
       +
       // IMPORTANT: This function returns a filter string with hardcoded parameter numbers ($3, $4).

     

       516
       516
       +
       // The caller (ListByCommenterWithCursor) must ensure parameters are ordered as:

     

       517
       517
       +
       // $1=commenterDID, $2=limit+1, $3=createdAt, $4=uri, then community DID if present.

     

       518
       518
       +
       // If you modify the parameter order in the caller, you must update the filter here.

     

       519
       519
       +
       func (r *postgresCommentRepo) parseCommenterCursor(cursor *string) (string, []interface{}, error) {

     

       520
       520
       +
       	if cursor == nil || *cursor == "" {

     

       521
       521
       +
       		return "", nil, nil

     

       522
       522
       +
       	}

     

       523
       523
       +
       

     

       524
       524
       +
       	// Validate cursor size to prevent DoS via massive base64 strings

     

       525
       525
       +
       	const maxCursorSize = 1024

     

       526
       526
       +
       	if len(*cursor) > maxCursorSize {

     

       527
       527
       +
       		return "", nil, fmt.Errorf("cursor too large: maximum %d bytes", maxCursorSize)

     

       528
       528
       +
       	}

     

       529
       529
       +
       

     

       530
       530
       +
       	// Decode base64 cursor

     

       531
       531
       +
       	decoded, err := base64.URLEncoding.DecodeString(*cursor)

     

       532
       532
       +
       	if err != nil {

     

       533
       533
       +
       		return "", nil, fmt.Errorf("invalid cursor encoding")

     

       534
       534
       +
       	}

     

       535
       535
       +
       

     

       536
       536
       +
       	// Parse cursor: createdAt|uri

     

       537
       537
       +
       	parts := strings.Split(string(decoded), "|")

     

       538
       538
       +
       	if len(parts) != 2 {

     

       539
       539
       +
       		return "", nil, fmt.Errorf("invalid cursor format")

     

       540
       540
       +
       	}

     

       541
       541
       +
       

     

       542
       542
       +
       	createdAt := parts[0]

     

       543
       543
       +
       	uri := parts[1]

     

       544
       544
       +
       

     

       545
       545
       +
       	// Validate AT-URI format

     

       546
       546
       +
       	if !strings.HasPrefix(uri, "at://") {

     

       547
       547
       +
       		return "", nil, fmt.Errorf("invalid cursor URI")

     

       548
       548
       +
       	}

     

       549
       549
       +
       

     

       550
       550
       +
       	filter := `AND (c.created_at < $3 OR (c.created_at = $3 AND c.uri < $4))`

     

       551
       551
       +
       	return filter, []interface{}{createdAt, uri}, nil

     

       552
       552
       +
       }

     

       553
       553
       +
       

     

       554
       554
       +
       // buildCommenterCursor creates pagination cursor from last comment

     

       555
       555
       +
       // Uses createdAt|uri format for stable pagination

     

       556
       556
       +
       func (r *postgresCommentRepo) buildCommenterCursor(comment *comments.Comment) string {

     

       557
       557
       +
       	cursorStr := fmt.Sprintf("%s|%s",

     

       558
       558
       +
       		comment.CreatedAt.Format("2006-01-02T15:04:05.999999999Z07:00"),

     

       559
       559
       +
       		comment.URI)

     

       560
       560
       +
       	return base64.URLEncoding.EncodeToString([]byte(cursorStr))

     

       561
       561
       +
       }

     

       562
       562
       +
       

     

       413
       563
        
       // ListByParentWithHotRank retrieves direct replies to a post or comment with sorting and pagination

     

       414
       564
        
       // Supports three sort modes: hot (Lemmy algorithm), top (by score + timeframe), and new (by created_at)

     

       415
       565
        
       // Uses cursor-based pagination with composite keys for consistent ordering

     
···

       964
       1114
        
       		// If votes table doesn't exist yet, return empty map instead of error

     

       965
       1115
        
       		// This allows the API to work before votes indexing is fully implemented

     

       966
       1116
        
       		if strings.Contains(err.Error(), "does not exist") {

     

       1117
       1117
       +
       			log.Printf("WARN: Votes table does not exist, returning empty vote state for %d comments", len(commentURIs))

     

       967
       1118
        
       			return make(map[string]interface{}), nil

     

       968
       1119
        
       		}

     

       969
       1120
        
       		return nil, fmt.Errorf("failed to get vote state for comments: %w", err)

+14 -56

internal/api/handlers/community/block.go

···

       47
       47
        
       		return

     

       48
       48
        
       	}

     

       49
       49
        
       

     

       50
       50
       -
       	// Extract authenticated user DID and access token from request context (injected by auth middleware)

     

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

     

       52
       52
       -
       	if userDID == "" {

     

       50
       50
       +
       	// Get OAuth session from context (injected by auth middleware)

     

       51
       51
       +
       	// The session contains the user's DID and credentials needed for DPoP authentication

     

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

     

       53
       53
       +
       	if session == nil {

     

       53
       54
        
       		writeError(w, http.StatusUnauthorized, "AuthRequired", "Authentication required")

     

       54
       55
        
       		return

     

       55
       56
        
       	}

     

       56
       57
        
       

     

       57
       57
       -
       	userAccessToken := middleware.GetUserAccessToken(r)

     

       58
       58
       -
       	if userAccessToken == "" {

     

       59
       59
       -
       		writeError(w, http.StatusUnauthorized, "AuthRequired", "Missing access token")

     

       60
       60
       -
       		return

     

       61
       61
       -
       	}

     

       62
       62
       -
       

     

       63
       63
       -
       	// Resolve community identifier (handle or DID) to DID

     

       64
       64
       -
       	// This allows users to block by handle: @gaming.community.coves.social or !gaming@coves.social

     

       65
       65
       -
       	communityDID, err := h.service.ResolveCommunityIdentifier(r.Context(), req.Community)

     

       66
       66
       -
       	if err != nil {

     

       67
       67
       -
       		if communities.IsNotFound(err) {

     

       68
       68
       -
       			writeError(w, http.StatusNotFound, "CommunityNotFound", "Community not found")

     

       69
       69
       -
       			return

     

       70
       70
       -
       		}

     

       71
       71
       -
       		if communities.IsValidationError(err) {

     

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

     

       73
       73
       -
       			return

     

       74
       74
       -
       		}

     

       75
       75
       -
       		log.Printf("Failed to resolve community identifier %s: %v", req.Community, err)

     

       76
       76
       -
       		writeError(w, http.StatusInternalServerError, "InternalError", "Failed to resolve community")

     

       77
       77
       -
       		return

     

       78
       78
       -
       	}

     

       79
       79
       -
       

     

       80
       80
       -
       	// Block via service (write-forward to PDS) using resolved DID

     

       81
       81
       -
       	block, err := h.service.BlockCommunity(r.Context(), userDID, userAccessToken, communityDID)

     

       58
       58
       +
       	// Block via service (write-forward to PDS with DPoP authentication)

     

       59
       59
       +
       	// Service handles identifier resolution (DIDs, handles, scoped identifiers)

     

       60
       60
       +
       	block, err := h.service.BlockCommunity(r.Context(), session, req.Community)

     

       82
       61
        
       	if err != nil {

     

       83
       62
        
       		handleServiceError(w, err)

     

       84
       63
        
       		return

     
···

       125
       104
        
       		return

     

       126
       105
        
       	}

     

       127
       106
        
       

     

       128
       128
       -
       	// Extract authenticated user DID and access token from request context (injected by auth middleware)

     

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

     

       130
       130
       -
       	if userDID == "" {

     

       107
       107
       +
       	// Get OAuth session from context (injected by auth middleware)

     

       108
       108
       +
       	// The session contains the user's DID and credentials needed for DPoP authentication

     

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

     

       110
       110
       +
       	if session == nil {

     

       131
       111
        
       		writeError(w, http.StatusUnauthorized, "AuthRequired", "Authentication required")

     

       132
       112
        
       		return

     

       133
       113
        
       	}

     

       134
       114
        
       

     

       135
       135
       -
       	userAccessToken := middleware.GetUserAccessToken(r)

     

       136
       136
       -
       	if userAccessToken == "" {

     

       137
       137
       -
       		writeError(w, http.StatusUnauthorized, "AuthRequired", "Missing access token")

     

       138
       138
       -
       		return

     

       139
       139
       -
       	}

     

       140
       140
       -
       

     

       141
       141
       -
       	// Resolve community identifier (handle or DID) to DID

     

       142
       142
       -
       	// This allows users to unblock by handle: @gaming.community.coves.social or !gaming@coves.social

     

       143
       143
       -
       	communityDID, err := h.service.ResolveCommunityIdentifier(r.Context(), req.Community)

     

       144
       144
       -
       	if err != nil {

     

       145
       145
       -
       		if communities.IsNotFound(err) {

     

       146
       146
       -
       			writeError(w, http.StatusNotFound, "CommunityNotFound", "Community not found")

     

       147
       147
       -
       			return

     

       148
       148
       -
       		}

     

       149
       149
       -
       		if communities.IsValidationError(err) {

     

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

     

       151
       151
       -
       			return

     

       152
       152
       -
       		}

     

       153
       153
       -
       		log.Printf("Failed to resolve community identifier %s: %v", req.Community, err)

     

       154
       154
       -
       		writeError(w, http.StatusInternalServerError, "InternalError", "Failed to resolve community")

     

       155
       155
       -
       		return

     

       156
       156
       -
       	}

     

       157
       157
       -
       

     

       158
       158
       -
       	// Unblock via service (delete record on PDS) using resolved DID

     

       159
       159
       -
       	err = h.service.UnblockCommunity(r.Context(), userDID, userAccessToken, communityDID)

     

       115
       115
       +
       	// Unblock via service (delete record on PDS with DPoP authentication)

     

       116
       116
       +
       	// Service handles identifier resolution (DIDs, handles, scoped identifiers)

     

       117
       117
       +
       	err := h.service.UnblockCommunity(r.Context(), session, req.Community)

     

       160
       118
        
       	if err != nil {

     

       161
       119
        
       		handleServiceError(w, err)

     

       162
       120
        
       		return

internal/atproto/pds/errors.go

···

       27
       27
        
       func IsAuthError(err error) bool {

     

       28
       28
        
       	return errors.Is(err, ErrUnauthorized) || errors.Is(err, ErrForbidden)

     

       29
       29
        
       }

     

       30
       30
       +
       

     

       31
       31
       +
       // IsConflictError returns true if the error indicates a conflict (e.g., duplicate record).

     

       32
       32
       +
       func IsConflictError(err error) bool {

     

       33
       33
       +
       	return errors.Is(err, ErrConflict)

     

       34
       34
       +
       }

+3 -5

tests/e2e/user_signup_test.go

···

       391
       391
        
       	}

     

       392
       392
        
       

     

       393
       393
        
       	var result struct {

     

       394
       394
       -
       		DID     string `json:"did"`

     

       395
       395
       -
       		Profile struct {

     

       396
       396
       -
       			Handle string `json:"handle"`

     

       397
       397
       -
       		} `json:"profile"`

     

       394
       394
       +
       		DID    string `json:"did"`

     

       395
       395
       +
       		Handle string `json:"handle"`

     

       398
       396
        
       	}

     

       399
       397
        
       

     

       400
       398
        
       	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {

     

       401
       399
        
       		return "", "", fmt.Errorf("failed to decode response: %w", err)

     

       402
       400
        
       	}

     

       403
       401
        
       

     

       404
       404
       -
       	return result.DID, result.Profile.Handle, nil

     

       402
       402
       +
       	return result.DID, result.Handle, nil

     

       405
       403
        
       }

+5 -5

tests/integration/author_posts_e2e_test.go

···

       71
       71
        
       	// Setup services

     

       72
       72
        
       	resolver := identity.NewResolver(db, identity.DefaultConfig())

     

       73
       73
        
       	userService := users.NewUserService(userRepo, resolver, pdsURL)

     

       74
       74
       -
       	communityService := communities.NewCommunityService(communityRepo, pdsURL, getTestInstanceDID(), "", nil)

     

       74
       74
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(communityRepo, pdsURL, getTestInstanceDID(), "", nil, nil)

     

       75
       75
        
       	postService := posts.NewPostService(postRepo, communityService, nil, nil, nil, nil, pdsURL)

     

       76
       76
        
       	voteService := votes.NewServiceWithPDSFactory(voteRepo, nil, nil, PasswordAuthPDSClientFactory())

     

       77
       77
        
       

     
···

       289
       289
        
       

     

       290
       290
        
       	resolver := identity.NewResolver(db, identity.DefaultConfig())

     

       291
       291
        
       	userService := users.NewUserService(userRepo, resolver, getTestPDSURL())

     

       292
       292
       -
       	communityService := communities.NewCommunityService(communityRepo, getTestPDSURL(), getTestInstanceDID(), "", nil)

     

       292
       292
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(communityRepo, getTestPDSURL(), getTestInstanceDID(), "", nil, nil)

     

       293
       293
        
       	postService := posts.NewPostService(postRepo, communityService, nil, nil, nil, nil, getTestPDSURL())

     

       294
       294
        
       	voteService := votes.NewServiceWithPDSFactory(voteRepo, nil, nil, PasswordAuthPDSClientFactory())

     

       295
       295
        
       

     
···

       428
       428
        
       

     

       429
       429
        
       	resolver := identity.NewResolver(db, identity.DefaultConfig())

     

       430
       430
        
       	userService := users.NewUserService(userRepo, resolver, getTestPDSURL())

     

       431
       431
       -
       	communityService := communities.NewCommunityService(communityRepo, getTestPDSURL(), getTestInstanceDID(), "", nil)

     

       431
       431
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(communityRepo, getTestPDSURL(), getTestInstanceDID(), "", nil, nil)

     

       432
       432
        
       	postService := posts.NewPostService(postRepo, communityService, nil, nil, nil, nil, getTestPDSURL())

     

       433
       433
        
       	voteService := votes.NewServiceWithPDSFactory(voteRepo, nil, nil, PasswordAuthPDSClientFactory())

     

       434
       434
        
       

     
···

       548
       548
        
       	// Setup services

     

       549
       549
        
       	resolver := identity.NewResolver(db, identity.DefaultConfig())

     

       550
       550
        
       	userService := users.NewUserService(userRepo, resolver, pdsURL)

     

       551
       551
       -
       	communityService := communities.NewCommunityService(communityRepo, pdsURL, getTestInstanceDID(), "", nil)

     

       551
       551
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(communityRepo, pdsURL, getTestInstanceDID(), "", nil, nil)

     

       552
       552
        
       	postService := posts.NewPostService(postRepo, communityService, nil, nil, nil, nil, pdsURL)

     

       553
       553
        
       	voteService := votes.NewServiceWithPDSFactory(voteRepo, nil, nil, PasswordAuthPDSClientFactory())

     

       554
       554
        
       

     
···

       658
       658
        
       

     

       659
       659
        
       	resolver := identity.NewResolver(db, identity.DefaultConfig())

     

       660
       660
        
       	userService := users.NewUserService(userRepo, resolver, getTestPDSURL())

     

       661
       661
       -
       	communityService := communities.NewCommunityService(communityRepo, getTestPDSURL(), getTestInstanceDID(), "", nil)

     

       661
       661
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(communityRepo, getTestPDSURL(), getTestInstanceDID(), "", nil, nil)

     

       662
       662
        
       	postService := posts.NewPostService(postRepo, communityService, nil, nil, nil, nil, getTestPDSURL())

     

       663
       663
        
       	voteService := votes.NewServiceWithPDSFactory(voteRepo, nil, nil, PasswordAuthPDSClientFactory())

     

       664
       664

+8 -4

tests/integration/community_identifier_resolution_test.go

···

       50
       50
        
       		instanceDID = "did:web:" + instanceDomain

     

       51
       51
        
       	}

     

       52
       52
        
       

     

       53
       53
       -
       	service := communities.NewCommunityService(

     

       53
       53
       +
       	service := communities.NewCommunityServiceWithPDSFactory(

     

       54
       54
        
       		repo,

     

       55
       55
        
       		pdsURL,

     

       56
       56
        
       		instanceDID,

     

       57
       57
        
       		instanceDomain,

     

       58
       58
        
       		provisioner,

     

       59
       59
       +
       		nil,

     

       59
       60
        
       	)

     

       60
       61
        
       

     

       61
       62
        
       	// Create a test community to resolve

     
···

       244
       245
        
       	}

     

       245
       246
        
       

     

       246
       247
        
       	provisioner := communities.NewPDSAccountProvisioner(instanceDomain, pdsURL)

     

       247
       247
       -
       	service := communities.NewCommunityService(

     

       248
       248
       +
       	service := communities.NewCommunityServiceWithPDSFactory(

     

       248
       249
        
       		repo,

     

       249
       250
        
       		pdsURL,

     

       250
       251
        
       		instanceDID,

     

       251
       252
        
       		instanceDomain,

     

       252
       253
        
       		provisioner,

     

       254
       254
       +
       		nil,

     

       253
       255
        
       	)

     

       254
       256
        
       

     

       255
       257
        
       	tests := []struct {

     
···

       421
       423
        
       	}

     

       422
       424
        
       

     

       423
       425
        
       	provisioner := communities.NewPDSAccountProvisioner(instanceDomain, pdsURL)

     

       424
       424
       -
       	service := communities.NewCommunityService(

     

       426
       426
       +
       	service := communities.NewCommunityServiceWithPDSFactory(

     

       425
       427
        
       		repo,

     

       426
       428
        
       		pdsURL,

     

       427
       429
        
       		instanceDID,

     

       428
       430
        
       		instanceDomain,

     

       429
       431
        
       		provisioner,

     

       432
       432
       +
       		nil,

     

       430
       433
        
       	)

     

       431
       434
        
       

     

       432
       435
        
       	t.Run("DID error includes identifier", func(t *testing.T) {

     
···

       486
       489
        
       	}

     

       487
       490
        
       

     

       488
       491
        
       	provisioner := communities.NewPDSAccountProvisioner(instanceDomain, pdsURL)

     

       489
       489
       -
       	service := communities.NewCommunityService(

     

       492
       492
       +
       	service := communities.NewCommunityServiceWithPDSFactory(

     

       490
       493
        
       		repo,

     

       491
       494
        
       		pdsURL,

     

       492
       495
        
       		instanceDID,

     

       493
       496
        
       		instanceDomain,

     

       494
       497
        
       		provisioner,

     

       498
       498
       +
       		nil,

     

       495
       499
        
       	)

     

       496
       500
        
       

     

       497
       501
        
       	// Create a test community

+17

tests/integration/helpers.go

···

       4
       4
        
       	"Coves/internal/api/middleware"

     

       5
       5
        
       	"Coves/internal/atproto/oauth"

     

       6
       6
        
       	"Coves/internal/atproto/pds"

     

       7
       7
       +
       	"Coves/internal/core/communities"

     

       7
       8
        
       	"Coves/internal/core/users"

     

       8
       9
        
       	"Coves/internal/core/votes"

     

       9
       10
        
       	"bytes"

     
···

       443
       444
        
       		return pds.NewFromAccessToken(session.HostURL, session.AccountDID.String(), session.AccessToken)

     

       444
       445
        
       	}

     

       445
       446
        
       }

     

       447
       447
       +
       

     

       448
       448
       +
       // CommunityPasswordAuthPDSClientFactory creates a PDSClientFactory for communities that uses password-based Bearer auth.

     

       449
       449
       +
       // This is for E2E tests that use createSession instead of OAuth.

     

       450
       450
       +
       // The factory extracts the access token and host URL from the session data.

     

       451
       451
       +
       func CommunityPasswordAuthPDSClientFactory() communities.PDSClientFactory {

     

       452
       452
       +
       	return func(ctx context.Context, session *oauthlib.ClientSessionData) (pds.Client, error) {

     

       453
       453
       +
       		if session.AccessToken == "" {

     

       454
       454
       +
       			return nil, fmt.Errorf("session has no access token")

     

       455
       455
       +
       		}

     

       456
       456
       +
       		if session.HostURL == "" {

     

       457
       457
       +
       			return nil, fmt.Errorf("session has no host URL")

     

       458
       458
       +
       		}

     

       459
       459
       +
       

     

       460
       460
       +
       		return pds.NewFromAccessToken(session.HostURL, session.AccountDID.String(), session.AccessToken)

     

       461
       461
       +
       	}

     

       462
       462
       +
       }

+2 -1

tests/integration/post_creation_test.go

···

       35
       35
        
       

     

       36
       36
        
       	communityRepo := postgres.NewCommunityRepository(db)

     

       37
       37
        
       	// Note: Provisioner not needed for this test (we're not actually creating communities)

     

       38
       38
       -
       	communityService := communities.NewCommunityService(

     

       38
       38
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(

     

       39
       39
        
       		communityRepo,

     

       40
       40
        
       		"http://localhost:3001",

     

       41
       41
        
       		"did:web:test.coves.social",

     

       42
       42
        
       		"test.coves.social",

     

       43
       43
        
       		nil, // provisioner

     

       44
       44
       +
       		nil, // pdsClientFactory

     

       44
       45
        
       	)

     

       45
       46
        
       

     

       46
       47
        
       	postRepo := postgres.NewPostRepository(db)

+6 -3

tests/integration/post_handler_test.go

···

       32
       32
        
       

     

       33
       33
        
       	// Setup services

     

       34
       34
        
       	communityRepo := postgres.NewCommunityRepository(db)

     

       35
       35
       -
       	communityService := communities.NewCommunityService(

     

       35
       35
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(

     

       36
       36
        
       		communityRepo,

     

       37
       37
        
       		"http://localhost:3001",

     

       38
       38
        
       		"did:web:test.coves.social",

     

       39
       39
        
       		"test.coves.social",

     

       40
       40
        
       		nil,

     

       41
       41
       +
       		nil,

     

       41
       42
        
       	)

     

       42
       43
        
       

     

       43
       44
        
       	postRepo := postgres.NewPostRepository(db)

     
···

       400
       401
        
       

     

       401
       402
        
       	// Setup services

     

       402
       403
        
       	communityRepo := postgres.NewCommunityRepository(db)

     

       403
       403
       -
       	communityService := communities.NewCommunityService(

     

       404
       404
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(

     

       404
       405
        
       		communityRepo,

     

       405
       406
        
       		"http://localhost:3001",

     

       406
       407
        
       		"did:web:test.coves.social",

     

       407
       408
        
       		"test.coves.social",

     

       408
       409
        
       		nil,

     

       410
       410
       +
       		nil,

     

       409
       411
        
       	)

     

       410
       412
        
       

     

       411
       413
        
       	postRepo := postgres.NewPostRepository(db)

     
···

       484
       486
        
       

     

       485
       487
        
       	// Setup services

     

       486
       488
        
       	communityRepo := postgres.NewCommunityRepository(db)

     

       487
       487
       -
       	communityService := communities.NewCommunityService(

     

       489
       489
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(

     

       488
       490
        
       		communityRepo,

     

       489
       491
        
       		"http://localhost:3001",

     

       490
       492
        
       		"did:web:test.coves.social",

     

       491
       493
        
       		"test.coves.social",

     

       492
       494
        
       		nil,

     

       495
       495
       +
       		nil,

     

       493
       496
        
       	)

     

       494
       497
        
       

     

       495
       498
        
       	postRepo := postgres.NewPostRepository(db)

+8 -4

tests/integration/post_unfurl_test.go

···

       51
       51
        
       		unfurl.WithCacheTTL(24*time.Hour),

     

       52
       52
        
       	)

     

       53
       53
        
       

     

       54
       54
       -
       	communityService := communities.NewCommunityService(

     

       54
       54
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(

     

       55
       55
        
       		communityRepo,

     

       56
       56
        
       		"http://localhost:3001",

     

       57
       57
        
       		"did:web:test.coves.social",

     

       58
       58
        
       		"test.coves.social",

     

       59
       59
        
       		nil,

     

       60
       60
       +
       		nil,

     

       60
       61
        
       	)

     

       61
       62
        
       

     

       62
       63
        
       	postService := posts.NewPostService(

     
···

       348
       349
        
       	identityResolver := identity.NewResolver(db, identityConfig)

     

       349
       350
        
       	userService := users.NewUserService(userRepo, identityResolver, "http://localhost:3001")

     

       350
       351
        
       

     

       351
       351
       -
       	communityService := communities.NewCommunityService(

     

       352
       352
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(

     

       352
       353
        
       		communityRepo,

     

       353
       354
        
       		"http://localhost:3001",

     

       354
       355
        
       		"did:web:test.coves.social",

     

       355
       356
        
       		"test.coves.social",

     

       356
       357
        
       		nil,

     

       358
       358
       +
       		nil,

     

       357
       359
        
       	)

     

       358
       360
        
       

     

       359
       361
        
       	// Create post service WITHOUT unfurl service

     
···

       456
       458
        
       		unfurl.WithCacheTTL(24*time.Hour),

     

       457
       459
        
       	)

     

       458
       460
        
       

     

       459
       459
       -
       	communityService := communities.NewCommunityService(

     

       461
       461
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(

     

       460
       462
        
       		communityRepo,

     

       461
       463
        
       		"http://localhost:3001",

     

       462
       464
        
       		"did:web:test.coves.social",

     

       463
       465
        
       		"test.coves.social",

     

       464
       466
        
       		nil,

     

       467
       467
       +
       		nil,

     

       465
       468
        
       	)

     

       466
       469
        
       

     

       467
       470
        
       	postService := posts.NewPostService(

     
···

       568
       571
        
       		unfurl.WithTimeout(30*time.Second),

     

       569
       572
        
       	)

     

       570
       573
        
       

     

       571
       571
       -
       	communityService := communities.NewCommunityService(

     

       574
       574
       +
       	communityService := communities.NewCommunityServiceWithPDSFactory(

     

       572
       575
        
       		communityRepo,

     

       573
       576
        
       		"http://localhost:3001",

     

       574
       577
        
       		"did:web:test.coves.social",

     

       575
       578
        
       		"test.coves.social",

     

       576
       579
        
       		nil,

     

       580
       580
       +
       		nil,

     

       577
       581
        
       	)

     

       578
       582
        
       

     

       579
       583
        
       	postService := posts.NewPostService(

+520

internal/api/handlers/community/block_test.go

···

       1
       1
       +
       package community

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

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

     

       5
       5
       +
       	"Coves/internal/core/communities"

     

       6
       6
       +
       	"bytes"

     

       7
       7
       +
       	"context"

     

       8
       8
       +
       	"encoding/json"

     

       9
       9
       +
       	"net/http"

     

       10
       10
       +
       	"net/http/httptest"

     

       11
       11
       +
       	"testing"

     

       12
       12
       +
       	"time"

     

       13
       13
       +
       

     

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

     

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

     

       16
       16
       +
       )

     

       17
       17
       +
       

     

       18
       18
       +
       // blockTestService implements communities.Service for block handler tests

     

       19
       19
       +
       type blockTestService struct {

     

       20
       20
       +
       	blockFunc   func(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) (*communities.CommunityBlock, error)

     

       21
       21
       +
       	unblockFunc func(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) error

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       func (m *blockTestService) CreateCommunity(ctx context.Context, req communities.CreateCommunityRequest) (*communities.Community, error) {

     

       25
       25
       +
       	return nil, nil

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       func (m *blockTestService) GetCommunity(ctx context.Context, identifier string) (*communities.Community, error) {

     

       29
       29
       +
       	return nil, nil

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       func (m *blockTestService) UpdateCommunity(ctx context.Context, req communities.UpdateCommunityRequest) (*communities.Community, error) {

     

       33
       33
       +
       	return nil, nil

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       func (m *blockTestService) ListCommunities(ctx context.Context, req communities.ListCommunitiesRequest) ([]*communities.Community, error) {

     

       37
       37
       +
       	return nil, nil

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       func (m *blockTestService) SearchCommunities(ctx context.Context, req communities.SearchCommunitiesRequest) ([]*communities.Community, int, error) {

     

       41
       41
       +
       	return nil, 0, nil

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       func (m *blockTestService) SubscribeToCommunity(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string, contentVisibility int) (*communities.Subscription, error) {

     

       45
       45
       +
       	return nil, nil

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       func (m *blockTestService) UnsubscribeFromCommunity(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) error {

     

       49
       49
       +
       	return nil

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       func (m *blockTestService) GetUserSubscriptions(ctx context.Context, userDID string, limit, offset int) ([]*communities.Subscription, error) {

     

       53
       53
       +
       	return nil, nil

     

       54
       54
       +
       }

     

       55
       55
       +
       

     

       56
       56
       +
       func (m *blockTestService) GetCommunitySubscribers(ctx context.Context, communityIdentifier string, limit, offset int) ([]*communities.Subscription, error) {

     

       57
       57
       +
       	return nil, nil

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       func (m *blockTestService) BlockCommunity(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) (*communities.CommunityBlock, error) {

     

       61
       61
       +
       	if m.blockFunc != nil {

     

       62
       62
       +
       		return m.blockFunc(ctx, session, communityIdentifier)

     

       63
       63
       +
       	}

     

       64
       64
       +
       	userDID := ""

     

       65
       65
       +
       	if session != nil {

     

       66
       66
       +
       		userDID = session.AccountDID.String()

     

       67
       67
       +
       	}

     

       68
       68
       +
       	return &communities.CommunityBlock{

     

       69
       69
       +
       		UserDID:      userDID,

     

       70
       70
       +
       		CommunityDID: "did:plc:community123",

     

       71
       71
       +
       		RecordURI:    "at://did:plc:user/social.coves.community.block/abc123",

     

       72
       72
       +
       		RecordCID:    "bafytest123",

     

       73
       73
       +
       		BlockedAt:    time.Now(),

     

       74
       74
       +
       	}, nil

     

       75
       75
       +
       }

     

       76
       76
       +
       

     

       77
       77
       +
       func (m *blockTestService) UnblockCommunity(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) error {

     

       78
       78
       +
       	if m.unblockFunc != nil {

     

       79
       79
       +
       		return m.unblockFunc(ctx, session, communityIdentifier)

     

       80
       80
       +
       	}

     

       81
       81
       +
       	return nil

     

       82
       82
       +
       }

     

       83
       83
       +
       

     

       84
       84
       +
       func (m *blockTestService) GetBlockedCommunities(ctx context.Context, userDID string, limit, offset int) ([]*communities.CommunityBlock, error) {

     

       85
       85
       +
       	return nil, nil

     

       86
       86
       +
       }

     

       87
       87
       +
       

     

       88
       88
       +
       func (m *blockTestService) IsBlocked(ctx context.Context, userDID, communityIdentifier string) (bool, error) {

     

       89
       89
       +
       	return false, nil

     

       90
       90
       +
       }

     

       91
       91
       +
       

     

       92
       92
       +
       func (m *blockTestService) GetMembership(ctx context.Context, userDID, communityIdentifier string) (*communities.Membership, error) {

     

       93
       93
       +
       	return nil, nil

     

       94
       94
       +
       }

     

       95
       95
       +
       

     

       96
       96
       +
       func (m *blockTestService) ListCommunityMembers(ctx context.Context, communityIdentifier string, limit, offset int) ([]*communities.Membership, error) {

     

       97
       97
       +
       	return nil, nil

     

       98
       98
       +
       }

     

       99
       99
       +
       

     

       100
       100
       +
       func (m *blockTestService) ValidateHandle(handle string) error {

     

       101
       101
       +
       	return nil

     

       102
       102
       +
       }

     

       103
       103
       +
       

     

       104
       104
       +
       func (m *blockTestService) ResolveCommunityIdentifier(ctx context.Context, identifier string) (string, error) {

     

       105
       105
       +
       	return identifier, nil

     

       106
       106
       +
       }

     

       107
       107
       +
       

     

       108
       108
       +
       func (m *blockTestService) EnsureFreshToken(ctx context.Context, community *communities.Community) (*communities.Community, error) {

     

       109
       109
       +
       	return community, nil

     

       110
       110
       +
       }

     

       111
       111
       +
       

     

       112
       112
       +
       func (m *blockTestService) GetByDID(ctx context.Context, did string) (*communities.Community, error) {

     

       113
       113
       +
       	return nil, nil

     

       114
       114
       +
       }

     

       115
       115
       +
       

     

       116
       116
       +
       // createBlockTestOAuthSession creates a mock OAuth session for block handler tests

     

       117
       117
       +
       func createBlockTestOAuthSession(did string) *oauth.ClientSessionData {

     

       118
       118
       +
       	parsedDID, _ := syntax.ParseDID(did)

     

       119
       119
       +
       	return &oauth.ClientSessionData{

     

       120
       120
       +
       		AccountDID:  parsedDID,

     

       121
       121
       +
       		SessionID:   "test-session",

     

       122
       122
       +
       		HostURL:     "http://localhost:3001",

     

       123
       123
       +
       		AccessToken: "test-access-token",

     

       124
       124
       +
       	}

     

       125
       125
       +
       }

     

       126
       126
       +
       

     

       127
       127
       +
       func TestBlockHandler_Block_Success(t *testing.T) {

     

       128
       128
       +
       	tests := []struct {

     

       129
       129
       +
       		name              string

     

       130
       130
       +
       		community         string

     

       131
       131
       +
       		expectedCommunity string

     

       132
       132
       +
       	}{

     

       133
       133
       +
       		{

     

       134
       134
       +
       			name:              "block with DID",

     

       135
       135
       +
       			community:         "did:plc:community123",

     

       136
       136
       +
       			expectedCommunity: "did:plc:community123",

     

       137
       137
       +
       		},

     

       138
       138
       +
       		{

     

       139
       139
       +
       			name:              "block with canonical handle",

     

       140
       140
       +
       			community:         "c-worldnews.coves.social",

     

       141
       141
       +
       			expectedCommunity: "c-worldnews.coves.social",

     

       142
       142
       +
       		},

     

       143
       143
       +
       		{

     

       144
       144
       +
       			name:              "block with scoped identifier",

     

       145
       145
       +
       			community:         "!worldnews@coves.social",

     

       146
       146
       +
       			expectedCommunity: "!worldnews@coves.social",

     

       147
       147
       +
       		},

     

       148
       148
       +
       		{

     

       149
       149
       +
       			name:              "block with at-identifier",

     

       150
       150
       +
       			community:         "@c-tech.coves.social",

     

       151
       151
       +
       			expectedCommunity: "@c-tech.coves.social",

     

       152
       152
       +
       		},

     

       153
       153
       +
       	}

     

       154
       154
       +
       

     

       155
       155
       +
       	for _, tc := range tests {

     

       156
       156
       +
       		t.Run(tc.name, func(t *testing.T) {

     

       157
       157
       +
       			var receivedIdentifier string

     

       158
       158
       +
       			mockService := &blockTestService{

     

       159
       159
       +
       				blockFunc: func(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) (*communities.CommunityBlock, error) {

     

       160
       160
       +
       					receivedIdentifier = communityIdentifier

     

       161
       161
       +
       					userDID := ""

     

       162
       162
       +
       					if session != nil {

     

       163
       163
       +
       						userDID = session.AccountDID.String()

     

       164
       164
       +
       					}

     

       165
       165
       +
       					return &communities.CommunityBlock{

     

       166
       166
       +
       						UserDID:      userDID,

     

       167
       167
       +
       						CommunityDID: "did:plc:resolved",

     

       168
       168
       +
       						RecordURI:    "at://did:plc:user/social.coves.community.block/abc123",

     

       169
       169
       +
       						RecordCID:    "bafytest123",

     

       170
       170
       +
       						BlockedAt:    time.Now(),

     

       171
       171
       +
       					}, nil

     

       172
       172
       +
       				},

     

       173
       173
       +
       			}

     

       174
       174
       +
       

     

       175
       175
       +
       			handler := NewBlockHandler(mockService)

     

       176
       176
       +
       

     

       177
       177
       +
       			reqBody := map[string]interface{}{

     

       178
       178
       +
       				"community": tc.community,

     

       179
       179
       +
       			}

     

       180
       180
       +
       			bodyBytes, _ := json.Marshal(reqBody)

     

       181
       181
       +
       

     

       182
       182
       +
       			req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.community.blockCommunity", bytes.NewBuffer(bodyBytes))

     

       183
       183
       +
       			req.Header.Set("Content-Type", "application/json")

     

       184
       184
       +
       

     

       185
       185
       +
       			// Inject OAuth session into context

     

       186
       186
       +
       			session := createBlockTestOAuthSession("did:plc:testuser")

     

       187
       187
       +
       			ctx := context.WithValue(req.Context(), middleware.OAuthSessionKey, session)

     

       188
       188
       +
       			req = req.WithContext(ctx)

     

       189
       189
       +
       

     

       190
       190
       +
       			w := httptest.NewRecorder()

     

       191
       191
       +
       			handler.HandleBlock(w, req)

     

       192
       192
       +
       

     

       193
       193
       +
       			if w.Code != http.StatusOK {

     

       194
       194
       +
       				t.Errorf("Expected status 200, got %d. Body: %s", w.Code, w.Body.String())

     

       195
       195
       +
       			}

     

       196
       196
       +
       

     

       197
       197
       +
       			// Verify the community identifier was passed through correctly

     

       198
       198
       +
       			if receivedIdentifier != tc.expectedCommunity {

     

       199
       199
       +
       				t.Errorf("Expected community %q to be passed to service, got %q", tc.expectedCommunity, receivedIdentifier)

     

       200
       200
       +
       			}

     

       201
       201
       +
       

     

       202
       202
       +
       			// Verify response structure

     

       203
       203
       +
       			var resp struct {

     

       204
       204
       +
       				Block struct {

     

       205
       205
       +
       					RecordURI string `json:"recordUri"`

     

       206
       206
       +
       					RecordCID string `json:"recordCid"`

     

       207
       207
       +
       				} `json:"block"`

     

       208
       208
       +
       			}

     

       209
       209
       +
       			if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {

     

       210
       210
       +
       				t.Fatalf("Failed to decode response: %v", err)

     

       211
       211
       +
       			}

     

       212
       212
       +
       			if resp.Block.RecordURI == "" || resp.Block.RecordCID == "" {

     

       213
       213
       +
       				t.Errorf("Expected recordUri and recordCid in response, got %+v", resp)

     

       214
       214
       +
       			}

     

       215
       215
       +
       		})

     

       216
       216
       +
       	}

     

       217
       217
       +
       }

     

       218
       218
       +
       

     

       219
       219
       +
       func TestBlockHandler_Block_RequiresOAuthSession(t *testing.T) {

     

       220
       220
       +
       	mockService := &blockTestService{}

     

       221
       221
       +
       	handler := NewBlockHandler(mockService)

     

       222
       222
       +
       

     

       223
       223
       +
       	reqBody := map[string]interface{}{

     

       224
       224
       +
       		"community": "did:plc:test",

     

       225
       225
       +
       	}

     

       226
       226
       +
       	bodyBytes, _ := json.Marshal(reqBody)

     

       227
       227
       +
       

     

       228
       228
       +
       	req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.community.blockCommunity", bytes.NewBuffer(bodyBytes))

     

       229
       229
       +
       	req.Header.Set("Content-Type", "application/json")

     

       230
       230
       +
       

     

       231
       231
       +
       	// No OAuth session in context

     

       232
       232
       +
       

     

       233
       233
       +
       	w := httptest.NewRecorder()

     

       234
       234
       +
       	handler.HandleBlock(w, req)

     

       235
       235
       +
       

     

       236
       236
       +
       	if w.Code != http.StatusUnauthorized {

     

       237
       237
       +
       		t.Errorf("Expected status 401, got %d", w.Code)

     

       238
       238
       +
       	}

     

       239
       239
       +
       

     

       240
       240
       +
       	var errResp struct {

     

       241
       241
       +
       		Error string `json:"error"`

     

       242
       242
       +
       	}

     

       243
       243
       +
       	if err := json.NewDecoder(w.Body).Decode(&errResp); err != nil {

     

       244
       244
       +
       		t.Fatalf("Failed to decode error response: %v", err)

     

       245
       245
       +
       	}

     

       246
       246
       +
       	if errResp.Error != "AuthRequired" {

     

       247
       247
       +
       		t.Errorf("Expected error AuthRequired, got %s", errResp.Error)

     

       248
       248
       +
       	}

     

       249
       249
       +
       }

     

       250
       250
       +
       

     

       251
       251
       +
       func TestBlockHandler_Block_RequiresCommunity(t *testing.T) {

     

       252
       252
       +
       	mockService := &blockTestService{}

     

       253
       253
       +
       	handler := NewBlockHandler(mockService)

     

       254
       254
       +
       

     

       255
       255
       +
       	reqBody := map[string]interface{}{}

     

       256
       256
       +
       	bodyBytes, _ := json.Marshal(reqBody)

     

       257
       257
       +
       

     

       258
       258
       +
       	req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.community.blockCommunity", bytes.NewBuffer(bodyBytes))

     

       259
       259
       +
       	req.Header.Set("Content-Type", "application/json")

     

       260
       260
       +
       

     

       261
       261
       +
       	session := createBlockTestOAuthSession("did:plc:testuser")

     

       262
       262
       +
       	ctx := context.WithValue(req.Context(), middleware.OAuthSessionKey, session)

     

       263
       263
       +
       	req = req.WithContext(ctx)

     

       264
       264
       +
       

     

       265
       265
       +
       	w := httptest.NewRecorder()

     

       266
       266
       +
       	handler.HandleBlock(w, req)

     

       267
       267
       +
       

     

       268
       268
       +
       	if w.Code != http.StatusBadRequest {

     

       269
       269
       +
       		t.Errorf("Expected status 400, got %d", w.Code)

     

       270
       270
       +
       	}

     

       271
       271
       +
       }

     

       272
       272
       +
       

     

       273
       273
       +
       func TestBlockHandler_Block_ServiceErrors(t *testing.T) {

     

       274
       274
       +
       	tests := []struct {

     

       275
       275
       +
       		name           string

     

       276
       276
       +
       		serviceErr     error

     

       277
       277
       +
       		expectedStatus int

     

       278
       278
       +
       		expectedError  string

     

       279
       279
       +
       	}{

     

       280
       280
       +
       		{

     

       281
       281
       +
       			name:           "community not found",

     

       282
       282
       +
       			serviceErr:     communities.ErrCommunityNotFound,

     

       283
       283
       +
       			expectedStatus: http.StatusNotFound,

     

       284
       284
       +
       			expectedError:  "NotFound",

     

       285
       285
       +
       		},

     

       286
       286
       +
       		{

     

       287
       287
       +
       			name:           "validation error",

     

       288
       288
       +
       			serviceErr:     communities.NewValidationError("community", "invalid format"),

     

       289
       289
       +
       			expectedStatus: http.StatusBadRequest,

     

       290
       290
       +
       			expectedError:  "InvalidRequest",

     

       291
       291
       +
       		},

     

       292
       292
       +
       		{

     

       293
       293
       +
       			name:           "already blocked",

     

       294
       294
       +
       			serviceErr:     communities.ErrBlockAlreadyExists,

     

       295
       295
       +
       			expectedStatus: http.StatusConflict,

     

       296
       296
       +
       			expectedError:  "AlreadyExists",

     

       297
       297
       +
       		},

     

       298
       298
       +
       		{

     

       299
       299
       +
       			name:           "unauthorized",

     

       300
       300
       +
       			serviceErr:     communities.ErrUnauthorized,

     

       301
       301
       +
       			expectedStatus: http.StatusForbidden,

     

       302
       302
       +
       			expectedError:  "Forbidden",

     

       303
       303
       +
       		},

     

       304
       304
       +
       	}

     

       305
       305
       +
       

     

       306
       306
       +
       	for _, tc := range tests {

     

       307
       307
       +
       		t.Run(tc.name, func(t *testing.T) {

     

       308
       308
       +
       			mockService := &blockTestService{

     

       309
       309
       +
       				blockFunc: func(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) (*communities.CommunityBlock, error) {

     

       310
       310
       +
       					return nil, tc.serviceErr

     

       311
       311
       +
       				},

     

       312
       312
       +
       			}

     

       313
       313
       +
       

     

       314
       314
       +
       			handler := NewBlockHandler(mockService)

     

       315
       315
       +
       

     

       316
       316
       +
       			reqBody := map[string]interface{}{

     

       317
       317
       +
       				"community": "did:plc:test",

     

       318
       318
       +
       			}

     

       319
       319
       +
       			bodyBytes, _ := json.Marshal(reqBody)

     

       320
       320
       +
       

     

       321
       321
       +
       			req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.community.blockCommunity", bytes.NewBuffer(bodyBytes))

     

       322
       322
       +
       			req.Header.Set("Content-Type", "application/json")

     

       323
       323
       +
       

     

       324
       324
       +
       			session := createBlockTestOAuthSession("did:plc:testuser")

     

       325
       325
       +
       			ctx := context.WithValue(req.Context(), middleware.OAuthSessionKey, session)

     

       326
       326
       +
       			req = req.WithContext(ctx)

     

       327
       327
       +
       

     

       328
       328
       +
       			w := httptest.NewRecorder()

     

       329
       329
       +
       			handler.HandleBlock(w, req)

     

       330
       330
       +
       

     

       331
       331
       +
       			if w.Code != tc.expectedStatus {

     

       332
       332
       +
       				t.Errorf("Expected status %d, got %d. Body: %s", tc.expectedStatus, w.Code, w.Body.String())

     

       333
       333
       +
       			}

     

       334
       334
       +
       

     

       335
       335
       +
       			var errResp struct {

     

       336
       336
       +
       				Error string `json:"error"`

     

       337
       337
       +
       			}

     

       338
       338
       +
       			if err := json.NewDecoder(w.Body).Decode(&errResp); err != nil {

     

       339
       339
       +
       				t.Fatalf("Failed to decode error response: %v", err)

     

       340
       340
       +
       			}

     

       341
       341
       +
       			if errResp.Error != tc.expectedError {

     

       342
       342
       +
       				t.Errorf("Expected error %s, got %s", tc.expectedError, errResp.Error)

     

       343
       343
       +
       			}

     

       344
       344
       +
       		})

     

       345
       345
       +
       	}

     

       346
       346
       +
       }

     

       347
       347
       +
       

     

       348
       348
       +
       func TestBlockHandler_Unblock_Success(t *testing.T) {

     

       349
       349
       +
       	tests := []struct {

     

       350
       350
       +
       		name              string

     

       351
       351
       +
       		community         string

     

       352
       352
       +
       		expectedCommunity string

     

       353
       353
       +
       	}{

     

       354
       354
       +
       		{

     

       355
       355
       +
       			name:              "unblock with DID",

     

       356
       356
       +
       			community:         "did:plc:community123",

     

       357
       357
       +
       			expectedCommunity: "did:plc:community123",

     

       358
       358
       +
       		},

     

       359
       359
       +
       		{

     

       360
       360
       +
       			name:              "unblock with canonical handle",

     

       361
       361
       +
       			community:         "c-worldnews.coves.social",

     

       362
       362
       +
       			expectedCommunity: "c-worldnews.coves.social",

     

       363
       363
       +
       		},

     

       364
       364
       +
       		{

     

       365
       365
       +
       			name:              "unblock with scoped identifier",

     

       366
       366
       +
       			community:         "!worldnews@coves.social",

     

       367
       367
       +
       			expectedCommunity: "!worldnews@coves.social",

     

       368
       368
       +
       		},

     

       369
       369
       +
       	}

     

       370
       370
       +
       

     

       371
       371
       +
       	for _, tc := range tests {

     

       372
       372
       +
       		t.Run(tc.name, func(t *testing.T) {

     

       373
       373
       +
       			var receivedIdentifier string

     

       374
       374
       +
       			mockService := &blockTestService{

     

       375
       375
       +
       				unblockFunc: func(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) error {

     

       376
       376
       +
       					receivedIdentifier = communityIdentifier

     

       377
       377
       +
       					return nil

     

       378
       378
       +
       				},

     

       379
       379
       +
       			}

     

       380
       380
       +
       

     

       381
       381
       +
       			handler := NewBlockHandler(mockService)

     

       382
       382
       +
       

     

       383
       383
       +
       			reqBody := map[string]interface{}{

     

       384
       384
       +
       				"community": tc.community,

     

       385
       385
       +
       			}

     

       386
       386
       +
       			bodyBytes, _ := json.Marshal(reqBody)

     

       387
       387
       +
       

     

       388
       388
       +
       			req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.community.unblockCommunity", bytes.NewBuffer(bodyBytes))

     

       389
       389
       +
       			req.Header.Set("Content-Type", "application/json")

     

       390
       390
       +
       

     

       391
       391
       +
       			session := createBlockTestOAuthSession("did:plc:testuser")

     

       392
       392
       +
       			ctx := context.WithValue(req.Context(), middleware.OAuthSessionKey, session)

     

       393
       393
       +
       			req = req.WithContext(ctx)

     

       394
       394
       +
       

     

       395
       395
       +
       			w := httptest.NewRecorder()

     

       396
       396
       +
       			handler.HandleUnblock(w, req)

     

       397
       397
       +
       

     

       398
       398
       +
       			if w.Code != http.StatusOK {

     

       399
       399
       +
       				t.Errorf("Expected status 200, got %d. Body: %s", w.Code, w.Body.String())

     

       400
       400
       +
       			}

     

       401
       401
       +
       

     

       402
       402
       +
       			if receivedIdentifier != tc.expectedCommunity {

     

       403
       403
       +
       				t.Errorf("Expected community %q to be passed to service, got %q", tc.expectedCommunity, receivedIdentifier)

     

       404
       404
       +
       			}

     

       405
       405
       +
       

     

       406
       406
       +
       			var resp struct {

     

       407
       407
       +
       				Success bool `json:"success"`

     

       408
       408
       +
       			}

     

       409
       409
       +
       			if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {

     

       410
       410
       +
       				t.Fatalf("Failed to decode response: %v", err)

     

       411
       411
       +
       			}

     

       412
       412
       +
       			if !resp.Success {

     

       413
       413
       +
       				t.Errorf("Expected success: true in response")

     

       414
       414
       +
       			}

     

       415
       415
       +
       		})

     

       416
       416
       +
       	}

     

       417
       417
       +
       }

     

       418
       418
       +
       

     

       419
       419
       +
       func TestBlockHandler_Unblock_RequiresOAuthSession(t *testing.T) {

     

       420
       420
       +
       	mockService := &blockTestService{}

     

       421
       421
       +
       	handler := NewBlockHandler(mockService)

     

       422
       422
       +
       

     

       423
       423
       +
       	reqBody := map[string]interface{}{

     

       424
       424
       +
       		"community": "did:plc:test",

     

       425
       425
       +
       	}

     

       426
       426
       +
       	bodyBytes, _ := json.Marshal(reqBody)

     

       427
       427
       +
       

     

       428
       428
       +
       	req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.community.unblockCommunity", bytes.NewBuffer(bodyBytes))

     

       429
       429
       +
       	req.Header.Set("Content-Type", "application/json")

     

       430
       430
       +
       

     

       431
       431
       +
       	// No OAuth session in context

     

       432
       432
       +
       

     

       433
       433
       +
       	w := httptest.NewRecorder()

     

       434
       434
       +
       	handler.HandleUnblock(w, req)

     

       435
       435
       +
       

     

       436
       436
       +
       	if w.Code != http.StatusUnauthorized {

     

       437
       437
       +
       		t.Errorf("Expected status 401, got %d", w.Code)

     

       438
       438
       +
       	}

     

       439
       439
       +
       

     

       440
       440
       +
       	var errResp struct {

     

       441
       441
       +
       		Error string `json:"error"`

     

       442
       442
       +
       	}

     

       443
       443
       +
       	if err := json.NewDecoder(w.Body).Decode(&errResp); err != nil {

     

       444
       444
       +
       		t.Fatalf("Failed to decode error response: %v", err)

     

       445
       445
       +
       	}

     

       446
       446
       +
       	if errResp.Error != "AuthRequired" {

     

       447
       447
       +
       		t.Errorf("Expected error AuthRequired, got %s", errResp.Error)

     

       448
       448
       +
       	}

     

       449
       449
       +
       }

     

       450
       450
       +
       

     

       451
       451
       +
       func TestBlockHandler_Unblock_BlockNotFound(t *testing.T) {

     

       452
       452
       +
       	mockService := &blockTestService{

     

       453
       453
       +
       		unblockFunc: func(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) error {

     

       454
       454
       +
       			return communities.ErrBlockNotFound

     

       455
       455
       +
       		},

     

       456
       456
       +
       	}

     

       457
       457
       +
       

     

       458
       458
       +
       	handler := NewBlockHandler(mockService)

     

       459
       459
       +
       

     

       460
       460
       +
       	reqBody := map[string]interface{}{

     

       461
       461
       +
       		"community": "did:plc:test",

     

       462
       462
       +
       	}

     

       463
       463
       +
       	bodyBytes, _ := json.Marshal(reqBody)

     

       464
       464
       +
       

     

       465
       465
       +
       	req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.community.unblockCommunity", bytes.NewBuffer(bodyBytes))

     

       466
       466
       +
       	req.Header.Set("Content-Type", "application/json")

     

       467
       467
       +
       

     

       468
       468
       +
       	session := createBlockTestOAuthSession("did:plc:testuser")

     

       469
       469
       +
       	ctx := context.WithValue(req.Context(), middleware.OAuthSessionKey, session)

     

       470
       470
       +
       	req = req.WithContext(ctx)

     

       471
       471
       +
       

     

       472
       472
       +
       	w := httptest.NewRecorder()

     

       473
       473
       +
       	handler.HandleUnblock(w, req)

     

       474
       474
       +
       

     

       475
       475
       +
       	if w.Code != http.StatusNotFound {

     

       476
       476
       +
       		t.Errorf("Expected status 404, got %d. Body: %s", w.Code, w.Body.String())

     

       477
       477
       +
       	}

     

       478
       478
       +
       }

     

       479
       479
       +
       

     

       480
       480
       +
       func TestBlockHandler_MethodNotAllowed(t *testing.T) {

     

       481
       481
       +
       	mockService := &blockTestService{}

     

       482
       482
       +
       	handler := NewBlockHandler(mockService)

     

       483
       483
       +
       

     

       484
       484
       +
       	// Test GET on block endpoint

     

       485
       485
       +
       	req := httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.community.blockCommunity", nil)

     

       486
       486
       +
       	w := httptest.NewRecorder()

     

       487
       487
       +
       	handler.HandleBlock(w, req)

     

       488
       488
       +
       

     

       489
       489
       +
       	if w.Code != http.StatusMethodNotAllowed {

     

       490
       490
       +
       		t.Errorf("Expected status 405, got %d", w.Code)

     

       491
       491
       +
       	}

     

       492
       492
       +
       

     

       493
       493
       +
       	// Test GET on unblock endpoint

     

       494
       494
       +
       	req = httptest.NewRequest(http.MethodGet, "/xrpc/social.coves.community.unblockCommunity", nil)

     

       495
       495
       +
       	w = httptest.NewRecorder()

     

       496
       496
       +
       	handler.HandleUnblock(w, req)

     

       497
       497
       +
       

     

       498
       498
       +
       	if w.Code != http.StatusMethodNotAllowed {

     

       499
       499
       +
       		t.Errorf("Expected status 405, got %d", w.Code)

     

       500
       500
       +
       	}

     

       501
       501
       +
       }

     

       502
       502
       +
       

     

       503
       503
       +
       func TestBlockHandler_InvalidJSON(t *testing.T) {

     

       504
       504
       +
       	mockService := &blockTestService{}

     

       505
       505
       +
       	handler := NewBlockHandler(mockService)

     

       506
       506
       +
       

     

       507
       507
       +
       	req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.community.blockCommunity", bytes.NewBufferString("invalid json"))

     

       508
       508
       +
       	req.Header.Set("Content-Type", "application/json")

     

       509
       509
       +
       

     

       510
       510
       +
       	session := createBlockTestOAuthSession("did:plc:testuser")

     

       511
       511
       +
       	ctx := context.WithValue(req.Context(), middleware.OAuthSessionKey, session)

     

       512
       512
       +
       	req = req.WithContext(ctx)

     

       513
       513
       +
       

     

       514
       514
       +
       	w := httptest.NewRecorder()

     

       515
       515
       +
       	handler.HandleBlock(w, req)

     

       516
       516
       +
       

     

       517
       517
       +
       	if w.Code != http.StatusBadRequest {

     

       518
       518
       +
       		t.Errorf("Expected status 400, got %d", w.Code)

     

       519
       519
       +
       	}

     

       520
       520
       +
       }

+12 -1

internal/api/handlers/community/errors.go

···

       1
       1
        
       package community

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/pds"

     

       4
       5
        
       	"Coves/internal/core/communities"

     

       5
       6
        
       	"encoding/json"

     

       7
       7
       +
       	"errors"

     

       6
       8
        
       	"log"

     

       7
       9
        
       	"net/http"

     

       8
       10
        
       )

     
···

       42
       44
        
       		writeError(w, http.StatusForbidden, "Forbidden", "You do not have permission to perform this action")

     

       43
       45
        
       	case err == communities.ErrMemberBanned:

     

       44
       46
        
       		writeError(w, http.StatusForbidden, "Blocked", "You are blocked from this community")

     

       47
       47
       +
       	// PDS-specific errors (from DPoP authentication or PDS API calls)

     

       48
       48
       +
       	case errors.Is(err, pds.ErrBadRequest):

     

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

     

       50
       50
       +
       	case errors.Is(err, pds.ErrNotFound):

     

       51
       51
       +
       		writeError(w, http.StatusNotFound, "NotFound", "Record not found on PDS")

     

       52
       52
       +
       	case errors.Is(err, pds.ErrConflict):

     

       53
       53
       +
       		writeError(w, http.StatusConflict, "Conflict", "Record was modified by another operation")

     

       54
       54
       +
       	case errors.Is(err, pds.ErrUnauthorized), errors.Is(err, pds.ErrForbidden):

     

       55
       55
       +
       		// PDS auth errors should prompt re-authentication

     

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

     

       45
       57
        
       	default:

     

       46
       58
        
       		// Internal server error - log the actual error for debugging

     

       47
       47
       -
       		// TODO: Use proper logger instead of log package

     

       48
       59
        
       		log.Printf("XRPC handler error: %v", err)

     

       49
       60
        
       		writeError(w, http.StatusInternalServerError, "InternalServerError", "An internal error occurred")

     

       50
       61
        
       	}

+32

internal/api/handlers/community/subscribe_test.go

···

       512
       512
        
       	}

     

       513
       513
        
       }

     

       514
       514
        
       

     

       515
       515
       +
       func TestUnsubscribeHandler_RequiresOAuthSession(t *testing.T) {

     

       516
       516
       +
       	mockService := &subscribeTestService{}

     

       517
       517
       +
       	handler := NewSubscribeHandler(mockService)

     

       518
       518
       +
       

     

       519
       519
       +
       	reqBody := map[string]interface{}{

     

       520
       520
       +
       		"community": "did:plc:test",

     

       521
       521
       +
       	}

     

       522
       522
       +
       	bodyBytes, _ := json.Marshal(reqBody)

     

       523
       523
       +
       

     

       524
       524
       +
       	req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.community.unsubscribe", bytes.NewBuffer(bodyBytes))

     

       525
       525
       +
       	req.Header.Set("Content-Type", "application/json")

     

       526
       526
       +
       

     

       527
       527
       +
       	// No OAuth session in context

     

       528
       528
       +
       

     

       529
       529
       +
       	w := httptest.NewRecorder()

     

       530
       530
       +
       	handler.HandleUnsubscribe(w, req)

     

       531
       531
       +
       

     

       532
       532
       +
       	if w.Code != http.StatusUnauthorized {

     

       533
       533
       +
       		t.Errorf("Expected status 401, got %d", w.Code)

     

       534
       534
       +
       	}

     

       535
       535
       +
       

     

       536
       536
       +
       	var errResp struct {

     

       537
       537
       +
       		Error string `json:"error"`

     

       538
       538
       +
       	}

     

       539
       539
       +
       	if err := json.NewDecoder(w.Body).Decode(&errResp); err != nil {

     

       540
       540
       +
       		t.Fatalf("Failed to decode error response: %v", err)

     

       541
       541
       +
       	}

     

       542
       542
       +
       	if errResp.Error != "AuthRequired" {

     

       543
       543
       +
       		t.Errorf("Expected error AuthRequired, got %s", errResp.Error)

     

       544
       544
       +
       	}

     

       545
       545
       +
       }

     

       546
       546
       +
       

     

       515
       547
        
       // Ensure unused import is used

     

       516
       548
        
       var _ = errors.New

+7 -23

internal/core/communities/service.go

···

       40
       40
        
       	repo        Repository

     

       41
       41
        
       	provisioner *PDSAccountProvisioner

     

       42
       42
        
       

     

       43
       43
       -
       	// OAuth client/store for user PDS authentication (DPoP-based)

     

       43
       43
       +
       	// OAuth client for user PDS authentication (DPoP-based)

     

       44
       44
        
       	oauthClient      *oauthclient.OAuthClient

     

       45
       45
       -
       	oauthStore       oauth.ClientAuthStore

     

       46
       45
        
       	pdsClientFactory PDSClientFactory // Optional, for testing. If nil, uses OAuth.

     

       47
       46
        
       

     

       48
       47
        
       	// Token refresh concurrency control

     
···

       72
       71
        
       	pdsURL, instanceDID, instanceDomain string,

     

       73
       72
        
       	provisioner *PDSAccountProvisioner,

     

       74
       73
        
       	oauthClient *oauthclient.OAuthClient,

     

       75
       75
       -
       	oauthStore oauth.ClientAuthStore,

     

       76
       74
        
       ) Service {

     

       77
       75
        
       	// SECURITY: Basic validation that did:web domain matches configured instanceDomain

     

       78
       76
        
       	// This catches honest configuration mistakes but NOT malicious code modifications

     
···

       95
       93
        
       		instanceDomain: instanceDomain,

     

       96
       94
        
       		provisioner:    provisioner,

     

       97
       95
        
       		oauthClient:    oauthClient,

     

       98
       98
       -
       		oauthStore:     oauthStore,

     

       99
       96
        
       		refreshMutexes: make(map[string]*sync.Mutex),

     

       100
       97
        
       	}

     

       101
       98
        
       }

     
···

       136
       133
        
       

     

       137
       134
        
       	// Production path: use OAuth with DPoP

     

       138
       135
        
       	if s.oauthClient == nil || s.oauthClient.ClientApp == nil {

     

       136
       136
       +
       		log.Printf("[OAUTH_ERROR] getPDSClient called but OAuth client is not configured - check server initialization")

     

       139
       137
        
       		return nil, fmt.Errorf("OAuth client not configured")

     

       140
       138
        
       	}

     

       141
       139
        
       

     
···

       664
       662
        
       	// Resolve community identifier to DID

     

       665
       663
        
       	communityDID, err := s.ResolveCommunityIdentifier(ctx, communityIdentifier)

     

       666
       664
        
       	if err != nil {

     

       667
       667
       -
       		return nil, err

     

       665
       665
       +
       		return nil, fmt.Errorf("subscribe: %w", err)

     

       668
       666
        
       	}

     

       669
       667
        
       

     

       670
       668
        
       	// Verify community exists

     
···

       732
       730
        
       	// Resolve community identifier

     

       733
       731
        
       	communityDID, err := s.ResolveCommunityIdentifier(ctx, communityIdentifier)

     

       734
       732
        
       	if err != nil {

     

       735
       735
       -
       		return err

     

       733
       733
       +
       		return fmt.Errorf("unsubscribe: %w", err)

     

       736
       734
        
       	}

     

       737
       735
        
       

     

       738
       736
        
       	// Get the subscription from AppView to find the record key

     
···

       824
       822
        
       	// Resolve community identifier (also verifies community exists)

     

       825
       823
        
       	communityDID, err := s.ResolveCommunityIdentifier(ctx, communityIdentifier)

     

       826
       824
        
       	if err != nil {

     

       827
       827
       -
       		return nil, err

     

       825
       825
       +
       		return nil, fmt.Errorf("block: %w", err)

     

       828
       826
        
       	}

     

       829
       827
        
       

     

       830
       828
        
       	// Create PDS client for this session (DPoP authentication)

     

       831
       829
        
       	pdsClient, err := s.getPDSClient(ctx, session)

     

       832
       830
        
       	if err != nil {

     

       833
       833
       -
       		return nil, fmt.Errorf("failed to create PDS client: %w", err)

     

       831
       831
       +
       		return nil, fmt.Errorf("block: failed to create PDS client: %w", err)

     

       834
       832
        
       	}

     

       835
       833
        
       

     

       836
       834
        
       	// Generate TID for record key

     
···

       904
       902
        
       	// Resolve community identifier

     

       905
       903
        
       	communityDID, err := s.ResolveCommunityIdentifier(ctx, communityIdentifier)

     

       906
       904
        
       	if err != nil {

     

       907
       907
       -
       		return err

     

       905
       905
       +
       		return fmt.Errorf("unblock: %w", err)

     

       908
       906
        
       	}

     

       909
       907
        
       

     

       910
       908
        
       	// Get the block from AppView to find the record key

     
···

       1180
       1178
        
       	return s.callPDSWithAuth(ctx, "POST", endpoint, payload, accessToken)

     

       1181
       1179
        
       }

     

       1182
       1180
        
       

     

       1183
       1183
       -
       // deleteRecordOnPDSAs deletes a record with a specific access token (for user-scoped deletions)

     

       1184
       1184
       -
       func (s *communityService) deleteRecordOnPDSAs(ctx context.Context, repoDID, collection, rkey, accessToken string) error {

     

       1185
       1185
       -
       	endpoint := fmt.Sprintf("%s/xrpc/com.atproto.repo.deleteRecord", strings.TrimSuffix(s.pdsURL, "/"))

     

       1186
       1186
       -
       

     

       1187
       1187
       -
       	payload := map[string]interface{}{

     

       1188
       1188
       -
       		"repo":       repoDID,

     

       1189
       1189
       -
       		"collection": collection,

     

       1190
       1190
       -
       		"rkey":       rkey,

     

       1191
       1191
       -
       	}

     

       1192
       1192
       -
       

     

       1193
       1193
       -
       	_, _, err := s.callPDSWithAuth(ctx, "POST", endpoint, payload, accessToken)

     

       1194
       1194
       -
       	return err

     

       1195
       1195
       -
       }

     

       1196
       1196
       -
       

     

       1197
       1181
        
       // callPDSWithAuth makes a PDS call with a specific access token (V2: for community authentication)

     

       1198
       1182
        
       func (s *communityService) callPDSWithAuth(ctx context.Context, method, endpoint string, payload map[string]interface{}, accessToken string) (string, string, error) {

     

       1199
       1183
        
       	jsonData, err := json.Marshal(payload)

+1 -1

cmd/server/main.go

···

       606
       606
        
       

     

       607
       607
        
       	// Register XRPC routes

     

       608
       608
        
       	routes.RegisterUserRoutes(r, userService)

     

       609
       609
       -
       	routes.RegisterCommunityRoutes(r, communityService, authMiddleware, allowedCommunityCreators)

     

       609
       609
       +
       	routes.RegisterCommunityRoutes(r, communityService, communityRepo, authMiddleware, allowedCommunityCreators)

     

       610
       610
        
       	log.Println("Community XRPC endpoints registered with OAuth authentication")

     

       611
       611
        
       

     

       612
       612
        
       	routes.RegisterPostRoutes(r, postService, dualAuth)

+7 -1

internal/api/handlers/community/list.go

···

       1
       1
        
       package community

     

       2
       2
        
       

     

       3
       3
        
       import (

     

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

     

       4
       5
        
       	"Coves/internal/core/communities"

     

       5
       6
        
       	"encoding/json"

     

       6
       7
        
       	"net/http"

     
···

       10
       11
        
       // ListHandler handles listing communities

     

       11
       12
        
       type ListHandler struct {

     

       12
       13
        
       	service communities.Service

     

       14
       14
       +
       	repo    communities.Repository

     

       13
       15
        
       }

     

       14
       16
        
       

     

       15
       17
        
       // NewListHandler creates a new list handler

     

       16
       16
       -
       func NewListHandler(service communities.Service) *ListHandler {

     

       18
       18
       +
       func NewListHandler(service communities.Service, repo communities.Repository) *ListHandler {

     

       17
       19
        
       	return &ListHandler{

     

       18
       20
        
       		service: service,

     

       21
       21
       +
       		repo:    repo,

     

       19
       22
        
       	}

     

       20
       23
        
       }

     

       21
       24
        
       

     
···

       100
       103
        
       		return

     

       101
       104
        
       	}

     

       102
       105
        
       

     

       106
       106
       +
       	// Populate viewer state if authenticated

     

       107
       107
       +
       	common.PopulateCommunityViewerState(r.Context(), r, h.repo, results)

     

       108
       108
       +
       

     

       103
       109
        
       	// Build response

     

       104
       110
        
       	var cursor string

     

       105
       111
        
       	if len(results) == limit {

internal/core/comments/comment_service_test.go

···

       315
       315
        
       	return nil, nil

     

       316
       316
        
       }

     

       317
       317
        
       

     

       318
       318
       +
       func (m *mockCommunityRepo) GetSubscribedCommunityDIDs(ctx context.Context, userDID string, communityDIDs []string) (map[string]bool, error) {

     

       319
       319
       +
       	return map[string]bool{}, nil

     

       320
       320
       +
       }

     

       321
       321
       +
       

     

       318
       322
        
       func (m *mockCommunityRepo) BlockCommunity(ctx context.Context, block *communities.CommunityBlock) (*communities.CommunityBlock, error) {

     

       319
       323
        
       	return nil, nil

     

       320
       324
        
       }

+48

internal/db/postgres/community_repo_subscriptions.go

···

       344
       344
        
       

     

       345
       345
        
       	return result, nil

     

       346
       346
        
       }

     

       347
       347
       +
       

     

       348
       348
       +
       // GetSubscribedCommunityDIDs returns a map of community DIDs that the user is subscribed to

     

       349
       349
       +
       // This is optimized for batch lookups when populating viewer state

     

       350
       350
       +
       func (r *postgresCommunityRepo) GetSubscribedCommunityDIDs(ctx context.Context, userDID string, communityDIDs []string) (map[string]bool, error) {

     

       351
       351
       +
       	if len(communityDIDs) == 0 {

     

       352
       352
       +
       		return map[string]bool{}, nil

     

       353
       353
       +
       	}

     

       354
       354
       +
       

     

       355
       355
       +
       	// Build query with placeholders for IN clause

     

       356
       356
       +
       	placeholders := make([]string, len(communityDIDs))

     

       357
       357
       +
       	args := make([]interface{}, len(communityDIDs)+1)

     

       358
       358
       +
       	args[0] = userDID

     

       359
       359
       +
       	for i, did := range communityDIDs {

     

       360
       360
       +
       		placeholders[i] = fmt.Sprintf("$%d", i+2)

     

       361
       361
       +
       		args[i+1] = did

     

       362
       362
       +
       	}

     

       363
       363
       +
       

     

       364
       364
       +
       	query := fmt.Sprintf(`

     

       365
       365
       +
       		SELECT community_did

     

       366
       366
       +
       		FROM community_subscriptions

     

       367
       367
       +
       		WHERE user_did = $1 AND community_did IN (%s)`,

     

       368
       368
       +
       		strings.Join(placeholders, ", "))

     

       369
       369
       +
       

     

       370
       370
       +
       	rows, err := r.db.QueryContext(ctx, query, args...)

     

       371
       371
       +
       	if err != nil {

     

       372
       372
       +
       		return nil, fmt.Errorf("failed to get subscribed communities: %w", err)

     

       373
       373
       +
       	}

     

       374
       374
       +
       	defer func() {

     

       375
       375
       +
       		if closeErr := rows.Close(); closeErr != nil {

     

       376
       376
       +
       			log.Printf("Failed to close rows: %v", closeErr)

     

       377
       377
       +
       		}

     

       378
       378
       +
       	}()

     

       379
       379
       +
       

     

       380
       380
       +
       	result := make(map[string]bool)

     

       381
       381
       +
       	for rows.Next() {

     

       382
       382
       +
       		var communityDID string

     

       383
       383
       +
       		if err := rows.Scan(&communityDID); err != nil {

     

       384
       384
       +
       			return nil, fmt.Errorf("failed to scan community DID: %w", err)

     

       385
       385
       +
       		}

     

       386
       386
       +
       		result[communityDID] = true

     

       387
       387
       +
       	}

     

       388
       388
       +
       

     

       389
       389
       +
       	if err = rows.Err(); err != nil {

     

       390
       390
       +
       		return nil, fmt.Errorf("error iterating subscribed communities: %w", err)

     

       391
       391
       +
       	}

     

       392
       392
       +
       

     

       393
       393
       +
       	return result, nil

     

       394
       394
       +
       }

+268

tests/integration/community_list_viewer_state_test.go

···

       1
       1
       +
       package integration

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

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

     

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

     

       6
       6
       +
       	"Coves/internal/core/communities"

     

       7
       7
       +
       	"Coves/internal/db/postgres"

     

       8
       8
       +
       	"context"

     

       9
       9
       +
       	"encoding/json"

     

       10
       10
       +
       	"fmt"

     

       11
       11
       +
       	"net/http"

     

       12
       12
       +
       	"net/http/httptest"

     

       13
       13
       +
       	"testing"

     

       14
       14
       +
       	"time"

     

       15
       15
       +
       

     

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

     

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

     

       18
       18
       +
       )

     

       19
       19
       +
       

     

       20
       20
       +
       // TestCommunityList_ViewerState tests that the list communities endpoint

     

       21
       21
       +
       // correctly populates viewer.subscribed field for authenticated users

     

       22
       22
       +
       func TestCommunityList_ViewerState(t *testing.T) {

     

       23
       23
       +
       	db := setupTestDB(t)

     

       24
       24
       +
       	defer func() {

     

       25
       25
       +
       		if err := db.Close(); err != nil {

     

       26
       26
       +
       			t.Logf("Failed to close database: %v", err)

     

       27
       27
       +
       		}

     

       28
       28
       +
       	}()

     

       29
       29
       +
       

     

       30
       30
       +
       	repo := postgres.NewCommunityRepository(db)

     

       31
       31
       +
       	ctx := context.Background()

     

       32
       32
       +
       

     

       33
       33
       +
       	// Create test communities

     

       34
       34
       +
       	baseSuffix := time.Now().UnixNano()

     

       35
       35
       +
       	communityDIDs := make([]string, 3)

     

       36
       36
       +
       	for i := 0; i < 3; i++ {

     

       37
       37
       +
       		uniqueSuffix := fmt.Sprintf("%d%d", baseSuffix, i)

     

       38
       38
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       39
       39
       +
       		communityDIDs[i] = communityDID

     

       40
       40
       +
       		comm := &communities.Community{

     

       41
       41
       +
       			DID:          communityDID,

     

       42
       42
       +
       			Handle:       fmt.Sprintf("c-viewer-test-%d-%d.coves.local", baseSuffix, i),

     

       43
       43
       +
       			Name:         fmt.Sprintf("viewer-test-%d", i),

     

       44
       44
       +
       			DisplayName:  fmt.Sprintf("Viewer Test Community %d", i),

     

       45
       45
       +
       			OwnerDID:     "did:web:coves.local",

     

       46
       46
       +
       			CreatedByDID: "did:plc:testcreator",

     

       47
       47
       +
       			HostedByDID:  "did:web:coves.local",

     

       48
       48
       +
       			Visibility:   "public",

     

       49
       49
       +
       			CreatedAt:    time.Now(),

     

       50
       50
       +
       			UpdatedAt:    time.Now(),

     

       51
       51
       +
       		}

     

       52
       52
       +
       		if _, err := repo.Create(ctx, comm); err != nil {

     

       53
       53
       +
       			t.Fatalf("Failed to create community %d: %v", i, err)

     

       54
       54
       +
       		}

     

       55
       55
       +
       	}

     

       56
       56
       +
       

     

       57
       57
       +
       	// Create a test user and subscribe them to community 0 and 2

     

       58
       58
       +
       	testUserDID := fmt.Sprintf("did:plc:viewertestuser%d", baseSuffix)

     

       59
       59
       +
       

     

       60
       60
       +
       	sub1 := &communities.Subscription{

     

       61
       61
       +
       		UserDID:           testUserDID,

     

       62
       62
       +
       		CommunityDID:      communityDIDs[0],

     

       63
       63
       +
       		ContentVisibility: 3,

     

       64
       64
       +
       		SubscribedAt:      time.Now(),

     

       65
       65
       +
       	}

     

       66
       66
       +
       	if _, err := repo.Subscribe(ctx, sub1); err != nil {

     

       67
       67
       +
       		t.Fatalf("Failed to subscribe to community 0: %v", err)

     

       68
       68
       +
       	}

     

       69
       69
       +
       

     

       70
       70
       +
       	sub2 := &communities.Subscription{

     

       71
       71
       +
       		UserDID:           testUserDID,

     

       72
       72
       +
       		CommunityDID:      communityDIDs[2],

     

       73
       73
       +
       		ContentVisibility: 3,

     

       74
       74
       +
       		SubscribedAt:      time.Now(),

     

       75
       75
       +
       	}

     

       76
       76
       +
       	if _, err := repo.Subscribe(ctx, sub2); err != nil {

     

       77
       77
       +
       		t.Fatalf("Failed to subscribe to community 2: %v", err)

     

       78
       78
       +
       	}

     

       79
       79
       +
       

     

       80
       80
       +
       	// Create mock service that returns our communities

     

       81
       81
       +
       	mockService := &mockCommunityService{

     

       82
       82
       +
       		repo: repo,

     

       83
       83
       +
       	}

     

       84
       84
       +
       

     

       85
       85
       +
       	// Create handler with real repo for viewer state population

     

       86
       86
       +
       	listHandler := community.NewListHandler(mockService, repo)

     

       87
       87
       +
       

     

       88
       88
       +
       	t.Run("authenticated user sees viewer.subscribed correctly", func(t *testing.T) {

     

       89
       89
       +
       		// Setup router with middleware that injects user DID

     

       90
       90
       +
       		r := chi.NewRouter()

     

       91
       91
       +
       

     

       92
       92
       +
       		// Use test middleware that sets user DID in context

     

       93
       93
       +
       		r.Use(func(next http.Handler) http.Handler {

     

       94
       94
       +
       			return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {

     

       95
       95
       +
       				ctx := middleware.SetTestUserDID(req.Context(), testUserDID)

     

       96
       96
       +
       				next.ServeHTTP(w, req.WithContext(ctx))

     

       97
       97
       +
       			})

     

       98
       98
       +
       		})

     

       99
       99
       +
       		r.Get("/xrpc/social.coves.community.list", listHandler.HandleList)

     

       100
       100
       +
       

     

       101
       101
       +
       		req := httptest.NewRequest("GET", "/xrpc/social.coves.community.list?limit=50", nil)

     

       102
       102
       +
       		rec := httptest.NewRecorder()

     

       103
       103
       +
       

     

       104
       104
       +
       		r.ServeHTTP(rec, req)

     

       105
       105
       +
       

     

       106
       106
       +
       		if rec.Code != http.StatusOK {

     

       107
       107
       +
       			t.Fatalf("Expected status 200, got %d: %s", rec.Code, rec.Body.String())

     

       108
       108
       +
       		}

     

       109
       109
       +
       

     

       110
       110
       +
       		var response struct {

     

       111
       111
       +
       			Communities []struct {

     

       112
       112
       +
       				DID    string `json:"did"`

     

       113
       113
       +
       				Viewer *struct {

     

       114
       114
       +
       					Subscribed *bool `json:"subscribed"`

     

       115
       115
       +
       				} `json:"viewer"`

     

       116
       116
       +
       			} `json:"communities"`

     

       117
       117
       +
       		}

     

       118
       118
       +
       

     

       119
       119
       +
       		if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {

     

       120
       120
       +
       			t.Fatalf("Failed to decode response: %v", err)

     

       121
       121
       +
       		}

     

       122
       122
       +
       

     

       123
       123
       +
       		// Check that viewer state is populated correctly

     

       124
       124
       +
       		subscriptionMap := map[string]bool{

     

       125
       125
       +
       			communityDIDs[0]: true,

     

       126
       126
       +
       			communityDIDs[1]: false,

     

       127
       127
       +
       			communityDIDs[2]: true,

     

       128
       128
       +
       		}

     

       129
       129
       +
       

     

       130
       130
       +
       		for _, comm := range response.Communities {

     

       131
       131
       +
       			expectedSubscribed, inTestSet := subscriptionMap[comm.DID]

     

       132
       132
       +
       			if !inTestSet {

     

       133
       133
       +
       				continue // Skip communities not in our test set

     

       134
       134
       +
       			}

     

       135
       135
       +
       

     

       136
       136
       +
       			if comm.Viewer == nil {

     

       137
       137
       +
       				t.Errorf("Community %s has nil Viewer, expected populated", comm.DID)

     

       138
       138
       +
       				continue

     

       139
       139
       +
       			}

     

       140
       140
       +
       

     

       141
       141
       +
       			if comm.Viewer.Subscribed == nil {

     

       142
       142
       +
       				t.Errorf("Community %s has nil Viewer.Subscribed, expected populated", comm.DID)

     

       143
       143
       +
       				continue

     

       144
       144
       +
       			}

     

       145
       145
       +
       

     

       146
       146
       +
       			if *comm.Viewer.Subscribed != expectedSubscribed {

     

       147
       147
       +
       				t.Errorf("Community %s: expected subscribed=%v, got %v",

     

       148
       148
       +
       					comm.DID, expectedSubscribed, *comm.Viewer.Subscribed)

     

       149
       149
       +
       			}

     

       150
       150
       +
       		}

     

       151
       151
       +
       	})

     

       152
       152
       +
       

     

       153
       153
       +
       	t.Run("unauthenticated request has nil viewer state", func(t *testing.T) {

     

       154
       154
       +
       		// Setup router WITHOUT middleware that sets user DID

     

       155
       155
       +
       		r := chi.NewRouter()

     

       156
       156
       +
       		r.Get("/xrpc/social.coves.community.list", listHandler.HandleList)

     

       157
       157
       +
       

     

       158
       158
       +
       		req := httptest.NewRequest("GET", "/xrpc/social.coves.community.list?limit=50", nil)

     

       159
       159
       +
       		rec := httptest.NewRecorder()

     

       160
       160
       +
       

     

       161
       161
       +
       		r.ServeHTTP(rec, req)

     

       162
       162
       +
       

     

       163
       163
       +
       		if rec.Code != http.StatusOK {

     

       164
       164
       +
       			t.Fatalf("Expected status 200, got %d: %s", rec.Code, rec.Body.String())

     

       165
       165
       +
       		}

     

       166
       166
       +
       

     

       167
       167
       +
       		var response struct {

     

       168
       168
       +
       			Communities []struct {

     

       169
       169
       +
       				DID    string `json:"did"`

     

       170
       170
       +
       				Viewer *struct {

     

       171
       171
       +
       					Subscribed *bool `json:"subscribed"`

     

       172
       172
       +
       				} `json:"viewer"`

     

       173
       173
       +
       			} `json:"communities"`

     

       174
       174
       +
       		}

     

       175
       175
       +
       

     

       176
       176
       +
       		if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {

     

       177
       177
       +
       			t.Fatalf("Failed to decode response: %v", err)

     

       178
       178
       +
       		}

     

       179
       179
       +
       

     

       180
       180
       +
       		// For unauthenticated requests, viewer should be nil for all communities

     

       181
       181
       +
       		for _, comm := range response.Communities {

     

       182
       182
       +
       			if comm.Viewer != nil {

     

       183
       183
       +
       				t.Errorf("Community %s has non-nil Viewer for unauthenticated request", comm.DID)

     

       184
       184
       +
       			}

     

       185
       185
       +
       		}

     

       186
       186
       +
       	})

     

       187
       187
       +
       }

     

       188
       188
       +
       

     

       189
       189
       +
       // mockCommunityService implements communities.Service for testing

     

       190
       190
       +
       type mockCommunityService struct {

     

       191
       191
       +
       	repo communities.Repository

     

       192
       192
       +
       }

     

       193
       193
       +
       

     

       194
       194
       +
       func (m *mockCommunityService) CreateCommunity(ctx context.Context, req communities.CreateCommunityRequest) (*communities.Community, error) {

     

       195
       195
       +
       	return nil, fmt.Errorf("not implemented")

     

       196
       196
       +
       }

     

       197
       197
       +
       

     

       198
       198
       +
       func (m *mockCommunityService) GetCommunity(ctx context.Context, identifier string) (*communities.Community, error) {

     

       199
       199
       +
       	return nil, fmt.Errorf("not implemented")

     

       200
       200
       +
       }

     

       201
       201
       +
       

     

       202
       202
       +
       func (m *mockCommunityService) UpdateCommunity(ctx context.Context, req communities.UpdateCommunityRequest) (*communities.Community, error) {

     

       203
       203
       +
       	return nil, fmt.Errorf("not implemented")

     

       204
       204
       +
       }

     

       205
       205
       +
       

     

       206
       206
       +
       func (m *mockCommunityService) ListCommunities(ctx context.Context, req communities.ListCommunitiesRequest) ([]*communities.Community, error) {

     

       207
       207
       +
       	return m.repo.List(ctx, req)

     

       208
       208
       +
       }

     

       209
       209
       +
       

     

       210
       210
       +
       func (m *mockCommunityService) SearchCommunities(ctx context.Context, req communities.SearchCommunitiesRequest) ([]*communities.Community, int, error) {

     

       211
       211
       +
       	return nil, 0, fmt.Errorf("not implemented")

     

       212
       212
       +
       }

     

       213
       213
       +
       

     

       214
       214
       +
       func (m *mockCommunityService) SubscribeToCommunity(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string, contentVisibility int) (*communities.Subscription, error) {

     

       215
       215
       +
       	return nil, fmt.Errorf("not implemented")

     

       216
       216
       +
       }

     

       217
       217
       +
       

     

       218
       218
       +
       func (m *mockCommunityService) UnsubscribeFromCommunity(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) error {

     

       219
       219
       +
       	return fmt.Errorf("not implemented")

     

       220
       220
       +
       }

     

       221
       221
       +
       

     

       222
       222
       +
       func (m *mockCommunityService) GetUserSubscriptions(ctx context.Context, userDID string, limit, offset int) ([]*communities.Subscription, error) {

     

       223
       223
       +
       	return nil, fmt.Errorf("not implemented")

     

       224
       224
       +
       }

     

       225
       225
       +
       

     

       226
       226
       +
       func (m *mockCommunityService) GetCommunitySubscribers(ctx context.Context, communityIdentifier string, limit, offset int) ([]*communities.Subscription, error) {

     

       227
       227
       +
       	return nil, fmt.Errorf("not implemented")

     

       228
       228
       +
       }

     

       229
       229
       +
       

     

       230
       230
       +
       func (m *mockCommunityService) BlockCommunity(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) (*communities.CommunityBlock, error) {

     

       231
       231
       +
       	return nil, fmt.Errorf("not implemented")

     

       232
       232
       +
       }

     

       233
       233
       +
       

     

       234
       234
       +
       func (m *mockCommunityService) UnblockCommunity(ctx context.Context, session *oauth.ClientSessionData, communityIdentifier string) error {

     

       235
       235
       +
       	return fmt.Errorf("not implemented")

     

       236
       236
       +
       }

     

       237
       237
       +
       

     

       238
       238
       +
       func (m *mockCommunityService) GetBlockedCommunities(ctx context.Context, userDID string, limit, offset int) ([]*communities.CommunityBlock, error) {

     

       239
       239
       +
       	return nil, fmt.Errorf("not implemented")

     

       240
       240
       +
       }

     

       241
       241
       +
       

     

       242
       242
       +
       func (m *mockCommunityService) IsBlocked(ctx context.Context, userDID, communityIdentifier string) (bool, error) {

     

       243
       243
       +
       	return false, fmt.Errorf("not implemented")

     

       244
       244
       +
       }

     

       245
       245
       +
       

     

       246
       246
       +
       func (m *mockCommunityService) GetMembership(ctx context.Context, userDID, communityIdentifier string) (*communities.Membership, error) {

     

       247
       247
       +
       	return nil, fmt.Errorf("not implemented")

     

       248
       248
       +
       }

     

       249
       249
       +
       

     

       250
       250
       +
       func (m *mockCommunityService) ListCommunityMembers(ctx context.Context, communityIdentifier string, limit, offset int) ([]*communities.Membership, error) {

     

       251
       251
       +
       	return nil, fmt.Errorf("not implemented")

     

       252
       252
       +
       }

     

       253
       253
       +
       

     

       254
       254
       +
       func (m *mockCommunityService) ValidateHandle(handle string) error {

     

       255
       255
       +
       	return nil

     

       256
       256
       +
       }

     

       257
       257
       +
       

     

       258
       258
       +
       func (m *mockCommunityService) ResolveCommunityIdentifier(ctx context.Context, identifier string) (string, error) {

     

       259
       259
       +
       	return identifier, nil

     

       260
       260
       +
       }

     

       261
       261
       +
       

     

       262
       262
       +
       func (m *mockCommunityService) EnsureFreshToken(ctx context.Context, community *communities.Community) (*communities.Community, error) {

     

       263
       263
       +
       	return community, nil

     

       264
       264
       +
       }

     

       265
       265
       +
       

     

       266
       266
       +
       func (m *mockCommunityService) GetByDID(ctx context.Context, did string) (*communities.Community, error) {

     

       267
       267
       +
       	return m.repo.GetByDID(ctx, did)

     

       268
       268
       +
       }

+117

tests/integration/community_repo_test.go

···

       409
       409
        
       	})

     

       410
       410
        
       }

     

       411
       411
        
       

     

       412
       412
       +
       func TestCommunityRepository_GetSubscribedCommunityDIDs(t *testing.T) {

     

       413
       413
       +
       	db := setupTestDB(t)

     

       414
       414
       +
       	defer func() {

     

       415
       415
       +
       		if err := db.Close(); err != nil {

     

       416
       416
       +
       			t.Logf("Failed to close database: %v", err)

     

       417
       417
       +
       		}

     

       418
       418
       +
       	}()

     

       419
       419
       +
       

     

       420
       420
       +
       	repo := postgres.NewCommunityRepository(db)

     

       421
       421
       +
       	ctx := context.Background()

     

       422
       422
       +
       

     

       423
       423
       +
       	// Create test communities

     

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

     

       425
       425
       +
       	communityDIDs := make([]string, 3)

     

       426
       426
       +
       	for i := 0; i < 3; i++ {

     

       427
       427
       +
       		uniqueSuffix := fmt.Sprintf("%d%d", baseSuffix, i)

     

       428
       428
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       429
       429
       +
       		communityDIDs[i] = communityDID

     

       430
       430
       +
       		community := &communities.Community{

     

       431
       431
       +
       			DID:          communityDID,

     

       432
       432
       +
       			Handle:       fmt.Sprintf("!batch-sub-test-%d-%d@coves.local", baseSuffix, i),

     

       433
       433
       +
       			Name:         fmt.Sprintf("batch-sub-test-%d", i),

     

       434
       434
       +
       			OwnerDID:     "did:web:coves.local",

     

       435
       435
       +
       			CreatedByDID: "did:plc:user123",

     

       436
       436
       +
       			HostedByDID:  "did:web:coves.local",

     

       437
       437
       +
       			Visibility:   "public",

     

       438
       438
       +
       			CreatedAt:    time.Now(),

     

       439
       439
       +
       			UpdatedAt:    time.Now(),

     

       440
       440
       +
       		}

     

       441
       441
       +
       		if _, err := repo.Create(ctx, community); err != nil {

     

       442
       442
       +
       			t.Fatalf("Failed to create community %d: %v", i, err)

     

       443
       443
       +
       		}

     

       444
       444
       +
       	}

     

       445
       445
       +
       

     

       446
       446
       +
       	userDID := fmt.Sprintf("did:plc:batchsubuser%d", baseSuffix)

     

       447
       447
       +
       

     

       448
       448
       +
       	t.Run("returns empty map when user has no subscriptions", func(t *testing.T) {

     

       449
       449
       +
       		result, err := repo.GetSubscribedCommunityDIDs(ctx, userDID, communityDIDs)

     

       450
       450
       +
       		if err != nil {

     

       451
       451
       +
       			t.Fatalf("Failed to get subscribed community DIDs: %v", err)

     

       452
       452
       +
       		}

     

       453
       453
       +
       

     

       454
       454
       +
       		if len(result) != 0 {

     

       455
       455
       +
       			t.Errorf("Expected empty map, got %d entries", len(result))

     

       456
       456
       +
       		}

     

       457
       457
       +
       	})

     

       458
       458
       +
       

     

       459
       459
       +
       	t.Run("returns subscribed communities only", func(t *testing.T) {

     

       460
       460
       +
       		// Subscribe to first and third community

     

       461
       461
       +
       		sub1 := &communities.Subscription{

     

       462
       462
       +
       			UserDID:           userDID,

     

       463
       463
       +
       			CommunityDID:      communityDIDs[0],

     

       464
       464
       +
       			ContentVisibility: 3,

     

       465
       465
       +
       			SubscribedAt:      time.Now(),

     

       466
       466
       +
       		}

     

       467
       467
       +
       		if _, err := repo.Subscribe(ctx, sub1); err != nil {

     

       468
       468
       +
       			t.Fatalf("Failed to subscribe to community 0: %v", err)

     

       469
       469
       +
       		}

     

       470
       470
       +
       

     

       471
       471
       +
       		sub3 := &communities.Subscription{

     

       472
       472
       +
       			UserDID:           userDID,

     

       473
       473
       +
       			CommunityDID:      communityDIDs[2],

     

       474
       474
       +
       			ContentVisibility: 3,

     

       475
       475
       +
       			SubscribedAt:      time.Now(),

     

       476
       476
       +
       		}

     

       477
       477
       +
       		if _, err := repo.Subscribe(ctx, sub3); err != nil {

     

       478
       478
       +
       			t.Fatalf("Failed to subscribe to community 2: %v", err)

     

       479
       479
       +
       		}

     

       480
       480
       +
       

     

       481
       481
       +
       		result, err := repo.GetSubscribedCommunityDIDs(ctx, userDID, communityDIDs)

     

       482
       482
       +
       		if err != nil {

     

       483
       483
       +
       			t.Fatalf("Failed to get subscribed community DIDs: %v", err)

     

       484
       484
       +
       		}

     

       485
       485
       +
       

     

       486
       486
       +
       		if len(result) != 2 {

     

       487
       487
       +
       			t.Errorf("Expected 2 subscribed communities, got %d", len(result))

     

       488
       488
       +
       		}

     

       489
       489
       +
       

     

       490
       490
       +
       		if !result[communityDIDs[0]] {

     

       491
       491
       +
       			t.Errorf("Expected community 0 to be subscribed")

     

       492
       492
       +
       		}

     

       493
       493
       +
       		if result[communityDIDs[1]] {

     

       494
       494
       +
       			t.Errorf("Expected community 1 to NOT be subscribed")

     

       495
       495
       +
       		}

     

       496
       496
       +
       		if !result[communityDIDs[2]] {

     

       497
       497
       +
       			t.Errorf("Expected community 2 to be subscribed")

     

       498
       498
       +
       		}

     

       499
       499
       +
       	})

     

       500
       500
       +
       

     

       501
       501
       +
       	t.Run("returns empty map for empty community DIDs slice", func(t *testing.T) {

     

       502
       502
       +
       		result, err := repo.GetSubscribedCommunityDIDs(ctx, userDID, []string{})

     

       503
       503
       +
       		if err != nil {

     

       504
       504
       +
       			t.Fatalf("Failed to get subscribed community DIDs: %v", err)

     

       505
       505
       +
       		}

     

       506
       506
       +
       

     

       507
       507
       +
       		if len(result) != 0 {

     

       508
       508
       +
       			t.Errorf("Expected empty map for empty input, got %d entries", len(result))

     

       509
       509
       +
       		}

     

       510
       510
       +
       	})

     

       511
       511
       +
       

     

       512
       512
       +
       	t.Run("handles non-existent community DIDs gracefully", func(t *testing.T) {

     

       513
       513
       +
       		nonExistentDIDs := []string{

     

       514
       514
       +
       			"did:plc:nonexistent1",

     

       515
       515
       +
       			"did:plc:nonexistent2",

     

       516
       516
       +
       		}

     

       517
       517
       +
       

     

       518
       518
       +
       		result, err := repo.GetSubscribedCommunityDIDs(ctx, userDID, nonExistentDIDs)

     

       519
       519
       +
       		if err != nil {

     

       520
       520
       +
       			t.Fatalf("Failed to get subscribed community DIDs: %v", err)

     

       521
       521
       +
       		}

     

       522
       522
       +
       

     

       523
       523
       +
       		if len(result) != 0 {

     

       524
       524
       +
       			t.Errorf("Expected empty map for non-existent DIDs, got %d entries", len(result))

     

       525
       525
       +
       		}

     

       526
       526
       +
       	})

     

       527
       527
       +
       }

     

       528
       528
       +
       

     

       412
       529
        
       // TODO: Implement search functionality before re-enabling this test

     

       413
       530
        
       // func TestCommunityRepository_Search(t *testing.T) {

     

       414
       531
        
       // 	db := setupTestDB(t)

+2 -1

internal/api/routes/oauth.go

···

       27
       27
        
       	logoutLimiter := middleware.NewRateLimiter(10, 1*time.Minute)

     

       28
       28
        
       

     

       29
       29
        
       	// OAuth metadata endpoints - public, no extra rate limiting (use global limit)

     

       30
       30
       -
       	r.Get("/oauth/client-metadata.json", handler.HandleClientMetadata)

     

       30
       30
       +
       	// Serve at root /oauth-client-metadata.json so OAuth screens show clean brand domain

     

       31
       31
       +
       	r.Get("/oauth-client-metadata.json", handler.HandleClientMetadata)

     

       31
       32
        
       	r.Get("/.well-known/oauth-protected-resource", handler.HandleProtectedResourceMetadata)

     

       32
       33
        
       

     

       33
       34
        
       	// OAuth flow endpoints - stricter rate limiting for authentication attempts

+1 -1

internal/atproto/oauth/handlers.go

···

       210
       210
        
       }

     

       211
       211
        
       

     

       212
       212
        
       // HandleClientMetadata serves the OAuth client metadata document

     

       213
       213
       -
       // GET /oauth/client-metadata.json

     

       213
       213
       +
       // GET /oauth-client-metadata.json

     

       214
       214
        
       func (h *OAuthHandler) HandleClientMetadata(w http.ResponseWriter, r *http.Request) {

     

       215
       215
        
       	metadata := h.client.ClientMetadata()

     

       216
       216

Compare changes