commit e2826acfa65504b336495683235852b9e86c2fc4 · bretton.dev/coves

+30 -4

cmd/server/main.go

···

       389
       389
        
       	voteRepo := postgresRepo.NewVoteRepository(db)

     

       390
       390
        
       	log.Println("✅ Vote repository initialized (Jetstream indexing only)")

     

       391
       391
        
       

     

       392
       392
       -
       	// Initialize vote service (for XRPC API endpoints)

     

       393
       393
       -
       	voteService := votes.NewService(voteRepo, oauthClient, oauthStore, nil)

     

       394
       394
       -
       	log.Println("✅ Vote service initialized (with OAuth authentication)")

     

       395
       395
       -
       

     

       396
       392
        
       	// Initialize comment repository (used by Jetstream consumer for indexing)

     

       397
       393
        
       	commentRepo := postgresRepo.NewCommentRepository(db)

     

       398
       394
        
       	log.Println("✅ Comment repository initialized (Jetstream indexing only)")

     

       395
       395
       +
       

     

       396
       396
       +
       	// Initialize subject validator for votes (checks posts and comments exist)

     

       397
       397
       +
       	subjectValidator := votes.NewCompositeSubjectValidator(

     

       398
       398
       +
       		// Post existence checker

     

       399
       399
       +
       		func(ctx context.Context, uri string) (bool, error) {

     

       400
       400
       +
       			_, err := postRepo.GetByURI(ctx, uri)

     

       401
       401
       +
       			if err != nil {

     

       402
       402
       +
       				if err == posts.ErrNotFound {

     

       403
       403
       +
       					return false, nil

     

       404
       404
       +
       				}

     

       405
       405
       +
       				return false, err

     

       406
       406
       +
       			}

     

       407
       407
       +
       			return true, nil

     

       408
       408
       +
       		},

     

       409
       409
       +
       		// Comment existence checker

     

       410
       410
       +
       		func(ctx context.Context, uri string) (bool, error) {

     

       411
       411
       +
       			_, err := commentRepo.GetByURI(ctx, uri)

     

       412
       412
       +
       			if err != nil {

     

       413
       413
       +
       				if err == comments.ErrCommentNotFound {

     

       414
       414
       +
       					return false, nil

     

       415
       415
       +
       				}

     

       416
       416
       +
       				return false, err

     

       417
       417
       +
       			}

     

       418
       418
       +
       			return true, nil

     

       419
       419
       +
       		},

     

       420
       420
       +
       	)

     

       421
       421
       +
       

     

       422
       422
       +
       	// Initialize vote service (for XRPC API endpoints)

     

       423
       423
       +
       	voteService := votes.NewService(voteRepo, subjectValidator, oauthClient, oauthStore, nil)

     

       424
       424
       +
       	log.Println("✅ Vote service initialized (with OAuth authentication and subject validation)")

     

       399
       425
        
       

     

       400
       426
        
       	// Initialize comment service (for query API)

     

       401
       427
        
       	// Requires user and community repos for proper author/community hydration per lexicon

+10 -8

internal/api/handlers/vote/errors.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"Coves/internal/core/votes"

     

       5
       5
        
       	"encoding/json"

     

       6
       6
       +
       	"errors"

     

       6
       7
        
       	"log"

     

       7
       8
        
       	"net/http"

     

       8
       9
        
       )

     
···

       27
       28
        
       

     

       28
       29
        
       // handleServiceError converts service errors to appropriate HTTP responses

     

       29
       30
        
       // Error names MUST match lexicon definitions exactly (UpperCamelCase)

     

       31
       31
       +
       // Uses errors.Is() to handle wrapped errors correctly

     

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

     

       31
       31
       -
       	switch err {

     

       32
       32
       -
       	case votes.ErrVoteNotFound:

     

       33
       33
       +
       	switch {

     

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

     

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

     

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

     

       35
       35
       -
       	case votes.ErrSubjectNotFound:

     

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

     

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

     

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

     

       38
       38
       -
       	case votes.ErrInvalidDirection:

     

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

     

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

     

       40
       40
       -
       	case votes.ErrInvalidSubject:

     

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

     

       41
       43
        
       		// Matches: social.coves.feed.vote.create#InvalidSubject

     

       42
       44
        
       		writeError(w, http.StatusBadRequest, "InvalidSubject", "The subject reference is invalid or malformed")

     

       43
       43
       -
       	case votes.ErrVoteAlreadyExists:

     

       45
       45
       +
       	case errors.Is(err, votes.ErrVoteAlreadyExists):

     

       44
       46
        
       		writeError(w, http.StatusConflict, "AlreadyExists", "Vote already exists")

     

       45
       45
       -
       	case votes.ErrNotAuthorized:

     

       47
       47
       +
       	case errors.Is(err, votes.ErrNotAuthorized):

     

       46
       48
        
       		// Matches: social.coves.feed.vote.create#NotAuthorized, social.coves.feed.vote.delete#NotAuthorized

     

       47
       49
        
       		writeError(w, http.StatusForbidden, "NotAuthorized", "User is not authorized to vote on this content")

     

       48
       48
       -
       	case votes.ErrBanned:

     

       50
       50
       +
       	case errors.Is(err, votes.ErrBanned):

     

       49
       51
        
       		writeError(w, http.StatusForbidden, "NotAuthorized", "User is not authorized to vote on this content")

     

       50
       52
        
       	default:

     

       51
       53
        
       		// Internal server error - log the actual error for debugging

+27 -9

internal/core/votes/service_impl.go

···

       19
       19
        
       

     

       20
       20
        
       // voteService implements the Service interface for vote operations

     

       21
       21
        
       type voteService struct {

     

       22
       22
       -
       	repo        Repository

     

       23
       23
       -
       	oauthClient *oauthclient.OAuthClient

     

       24
       24
       -
       	oauthStore  oauth.ClientAuthStore

     

       25
       25
       -
       	logger      *slog.Logger

     

       22
       22
       +
       	repo             Repository

     

       23
       23
       +
       	subjectValidator SubjectValidator

     

       24
       24
       +
       	oauthClient      *oauthclient.OAuthClient

     

       25
       25
       +
       	oauthStore       oauth.ClientAuthStore

     

       26
       26
       +
       	logger           *slog.Logger

     

       26
       27
        
       }

     

       27
       28
        
       

     

       28
       29
        
       // NewService creates a new vote service instance

     

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

     

       30
       30
       +
       // subjectValidator can be nil to skip subject existence checks (not recommended for production)

     

       31
       31
       +
       func NewService(repo Repository, subjectValidator SubjectValidator, oauthClient *oauthclient.OAuthClient, oauthStore oauth.ClientAuthStore, logger *slog.Logger) Service {

     

       30
       32
        
       	if logger == nil {

     

       31
       33
        
       		logger = slog.Default()

     

       32
       34
        
       	}

     

       33
       35
        
       	return &voteService{

     

       34
       34
       -
       		repo:        repo,

     

       35
       35
       -
       		oauthClient: oauthClient,

     

       36
       36
       -
       		oauthStore:  oauthStore,

     

       37
       37
       -
       		logger:      logger,

     

       36
       36
       +
       		repo:             repo,

     

       37
       37
       +
       		subjectValidator: subjectValidator,

     

       38
       38
       +
       		oauthClient:      oauthClient,

     

       39
       39
       +
       		oauthStore:       oauthStore,

     

       40
       40
       +
       		logger:           logger,

     

       38
       41
        
       	}

     

       39
       42
        
       }

     

       40
       43
        
       

     
···

       60
       63
        
       	// Validate subject CID is provided

     

       61
       64
        
       	if req.Subject.CID == "" {

     

       62
       65
        
       		return nil, ErrInvalidSubject

     

       66
       66
       +
       	}

     

       67
       67
       +
       

     

       68
       68
       +
       	// Validate subject exists in AppView (post or comment)

     

       69
       69
       +
       	// This prevents creating votes on non-existent content

     

       70
       70
       +
       	if s.subjectValidator != nil {

     

       71
       71
       +
       		exists, err := s.subjectValidator.SubjectExists(ctx, req.Subject.URI)

     

       72
       72
       +
       		if err != nil {

     

       73
       73
       +
       			s.logger.Error("failed to validate subject existence",

     

       74
       74
       +
       				"error", err,

     

       75
       75
       +
       				"subject", req.Subject.URI)

     

       76
       76
       +
       			return nil, fmt.Errorf("failed to validate subject: %w", err)

     

       77
       77
       +
       		}

     

       78
       78
       +
       		if !exists {

     

       79
       79
       +
       			return nil, ErrSubjectNotFound

     

       80
       80
       +
       		}

     

       63
       81
        
       	}

     

       64
       82
        
       

     

       65
       83
        
       	// Check for existing vote by querying PDS directly (source of truth)

+50

internal/core/votes/subject_validator.go

···

       1
       1
       +
       package votes

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"strings"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       // SubjectExistsFunc is a function type that checks if a subject exists

     

       9
       9
       +
       type SubjectExistsFunc func(ctx context.Context, uri string) (bool, error)

     

       10
       10
       +
       

     

       11
       11
       +
       // CompositeSubjectValidator validates subjects by checking both posts and comments

     

       12
       12
       +
       type CompositeSubjectValidator struct {

     

       13
       13
       +
       	postExists    SubjectExistsFunc

     

       14
       14
       +
       	commentExists SubjectExistsFunc

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       // NewCompositeSubjectValidator creates a validator that checks both posts and comments

     

       18
       18
       +
       // Pass nil for either function to skip validation for that type

     

       19
       19
       +
       func NewCompositeSubjectValidator(postExists, commentExists SubjectExistsFunc) *CompositeSubjectValidator {

     

       20
       20
       +
       	return &CompositeSubjectValidator{

     

       21
       21
       +
       		postExists:    postExists,

     

       22
       22
       +
       		commentExists: commentExists,

     

       23
       23
       +
       	}

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       // SubjectExists checks if a post or comment exists at the given URI

     

       27
       27
       +
       // Determines type from the collection in the URI (e.g., social.coves.feed.post vs social.coves.feed.comment)

     

       28
       28
       +
       func (v *CompositeSubjectValidator) SubjectExists(ctx context.Context, uri string) (bool, error) {

     

       29
       29
       +
       	// Parse collection from AT-URI: at://did/collection/rkey

     

       30
       30
       +
       	// Example: at://did:plc:xxx/social.coves.feed.post/abc123

     

       31
       31
       +
       	if strings.Contains(uri, "/social.coves.feed.post/") {

     

       32
       32
       +
       		if v.postExists != nil {

     

       33
       33
       +
       			return v.postExists(ctx, uri)

     

       34
       34
       +
       		}

     

       35
       35
       +
       		// If no post checker, assume exists (for testing)

     

       36
       36
       +
       		return true, nil

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	if strings.Contains(uri, "/social.coves.feed.comment/") {

     

       40
       40
       +
       		if v.commentExists != nil {

     

       41
       41
       +
       			return v.commentExists(ctx, uri)

     

       42
       42
       +
       		}

     

       43
       43
       +
       		// If no comment checker, assume exists (for testing)

     

       44
       44
       +
       		return true, nil

     

       45
       45
       +
       	}

     

       46
       46
       +
       

     

       47
       47
       +
       	// Unknown collection type - could be from another app

     

       48
       48
       +
       	// For now, allow voting on unknown types (future-proofing)

     

       49
       49
       +
       	return true, nil

     

       50
       50
       +
       }

internal/core/votes/vote.go

···

       1
       1
        
       package votes

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"context"

     

       4
       5
        
       	"time"

     

       5
       6
        
       )

     

       7
       7
       +
       

     

       8
       8
       +
       // SubjectValidator validates that vote subjects (posts/comments) exist

     

       9
       9
       +
       // This prevents creating votes on non-existent content

     

       10
       10
       +
       type SubjectValidator interface {

     

       11
       11
       +
       	// SubjectExists checks if a post or comment exists at the given URI

     

       12
       12
       +
       	// Returns true if found, false if not found

     

       13
       13
       +
       	SubjectExists(ctx context.Context, uri string) (bool, error)

     

       14
       14
       +
       }

     

       6
       15
        
       

     

       7
       16
        
       // Vote represents a vote in the AppView database

     

       8
       17
        
       // Votes are indexed from the firehose after being written to user repositories

+4 -4

tests/integration/vote_e2e_test.go

···

       85
       85
        
       	oauthClient := SetupOAuthTestClient(t, oauthStore)

     

       86
       86
        
       

     

       87
       87
        
       	// Setup services

     

       88
       88
       -
       	voteService := votes.NewService(voteRepo, oauthClient, oauthStore, nil)

     

       88
       88
       +
       	voteService := votes.NewService(voteRepo, nil, oauthClient, oauthStore, nil)

     

       89
       89
        
       

     

       90
       90
        
       	// Create test user on PDS

     

       91
       91
        
       	testUserHandle := fmt.Sprintf("voter-%d.local.coves.dev", time.Now().Unix())

     
···

       310
       310
        
       

     

       311
       311
        
       	oauthStore := SetupOAuthTestStore(t, db)

     

       312
       312
        
       	oauthClient := SetupOAuthTestClient(t, oauthStore)

     

       313
       313
       -
       	voteService := votes.NewService(voteRepo, oauthClient, oauthStore, nil)

     

       313
       313
       +
       	voteService := votes.NewService(voteRepo, nil, oauthClient, oauthStore, nil)

     

       314
       314
        
       

     

       315
       315
        
       	// Create test user

     

       316
       316
        
       	testUserHandle := fmt.Sprintf("toggle-%d.local.coves.dev", time.Now().Unix())

     
···

       469
       469
        
       

     

       470
       470
        
       	oauthStore := SetupOAuthTestStore(t, db)

     

       471
       471
        
       	oauthClient := SetupOAuthTestClient(t, oauthStore)

     

       472
       472
       -
       	voteService := votes.NewService(voteRepo, oauthClient, oauthStore, nil)

     

       472
       472
       +
       	voteService := votes.NewService(voteRepo, nil, oauthClient, oauthStore, nil)

     

       473
       473
        
       

     

       474
       474
        
       	// Create test user

     

       475
       475
        
       	testUserHandle := fmt.Sprintf("flip-%d.local.coves.dev", time.Now().Unix())

     
···

       648
       648
        
       

     

       649
       649
        
       	oauthStore := SetupOAuthTestStore(t, db)

     

       650
       650
        
       	oauthClient := SetupOAuthTestClient(t, oauthStore)

     

       651
       651
       -
       	voteService := votes.NewService(voteRepo, oauthClient, oauthStore, nil)

     

       651
       651
       +
       	voteService := votes.NewService(voteRepo, nil, oauthClient, oauthStore, nil)

     

       652
       652
        
       

     

       653
       653
        
       	// Create test user

     

       654
       654
        
       	testUserHandle := fmt.Sprintf("delete-%d.local.coves.dev", time.Now().Unix())