commit a0da24445eb5bd61dc86326cca8633347b62c93b · bretton.dev/coves

+5 -2

internal/api/handlers/community/block.go

···

       10
       10
        
       	"strings"

     

       11
       11
        
       )

     

       12
       12
        
       

     

       13
       13
       +
       // Package-level compiled regex for DID validation (compiled once at startup)

     

       14
       14
       +
       var (

     

       15
       15
       +
       	didRegex = regexp.MustCompile(`^did:(plc|web):[a-zA-Z0-9._:%-]+$`)

     

       16
       16
       +
       )

     

       17
       17
       +
       

     

       13
       18
        
       // BlockHandler handles community blocking operations

     

       14
       19
        
       type BlockHandler struct {

     

       15
       20
        
       	service communities.Service

     
···

       57
       62
        
       	}

     

       58
       63
        
       

     

       59
       64
        
       	// Validate DID format with regex: did:method:identifier

     

       60
       60
       -
       	didRegex := regexp.MustCompile(`^did:(plc|web):[a-zA-Z0-9._:%-]+$`)

     

       61
       65
        
       	if !didRegex.MatchString(req.Community) {

     

       62
       66
        
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "invalid DID format")

     

       63
       67
        
       		return

     
···

       132
       136
        
       	}

     

       133
       137
        
       

     

       134
       138
        
       	// Validate DID format with regex: did:method:identifier

     

       135
       135
       -
       	didRegex := regexp.MustCompile(`^did:(plc|web):[a-zA-Z0-9._:%-]+$`)

     

       136
       139
        
       	if !didRegex.MatchString(req.Community) {

     

       137
       140
        
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "invalid DID format")

     

       138
       141
        
       		return

+5 -1

internal/core/communities/errors.go

···

       34
       34
        
       	// ErrBlockNotFound is returned when block doesn't exist

     

       35
       35
        
       	ErrBlockNotFound = errors.New("block not found")

     

       36
       36
        
       

     

       37
       37
       +
       	// ErrBlockAlreadyExists is returned when user has already blocked the community

     

       38
       38
       +
       	ErrBlockAlreadyExists = errors.New("community already blocked")

     

       39
       39
       +
       

     

       37
       40
        
       	// ErrMembershipNotFound is returned when membership doesn't exist

     

       38
       41
        
       	ErrMembershipNotFound = errors.New("membership not found")

     

       39
       42
        
       

     
···

       74
       77
        
       func IsConflict(err error) bool {

     

       75
       78
        
       	return errors.Is(err, ErrCommunityAlreadyExists) ||

     

       76
       79
        
       		errors.Is(err, ErrHandleTaken) ||

     

       77
       77
       -
       		errors.Is(err, ErrSubscriptionAlreadyExists)

     

       80
       80
       +
       		errors.Is(err, ErrSubscriptionAlreadyExists) ||

     

       81
       81
       +
       		errors.Is(err, ErrBlockAlreadyExists)

     

       78
       82
        
       }

     

       79
       83
        
       

     

       80
       84
        
       // IsValidationError checks if error is a validation error

+9 -18

internal/core/communities/service.go

···

       1
       1
        
       package communities

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/utils"

     

       4
       5
        
       	"bytes"

     

       5
       6
        
       	"context"

     

       6
       7
        
       	"encoding/json"

     
···

       455
       456
        
       	}

     

       456
       457
        
       

     

       457
       458
        
       	// Extract rkey from record URI (at://did/collection/rkey)

     

       458
       458
       -
       	rkey := extractRKeyFromURI(subscription.RecordURI)

     

       459
       459
       +
       	rkey := utils.ExtractRKeyFromURI(subscription.RecordURI)

     

       459
       460
        
       	if rkey == "" {

     

       460
       461
        
       		return fmt.Errorf("invalid subscription record URI")

     

       461
       462
        
       	}

     
···

       525
       526
        
       		return nil, NewValidationError("userAccessToken", "required")

     

       526
       527
        
       	}

     

       527
       528
        
       

     

       528
       528
       -
       	// Resolve community identifier

     

       529
       529
       +
       	// Resolve community identifier (also verifies community exists)

     

       529
       530
        
       	communityDID, err := s.ResolveCommunityIdentifier(ctx, communityIdentifier)

     

       530
       531
        
       	if err != nil {

     

       531
       532
        
       		return nil, err

     

       532
       533
        
       	}

     

       533
       534
        
       

     

       534
       534
       -
       	// Verify community exists

     

       535
       535
       -
       	_, err = s.repo.GetByDID(ctx, communityDID)

     

       536
       536
       -
       	if err != nil {

     

       537
       537
       -
       		return nil, err

     

       538
       538
       -
       	}

     

       539
       539
       -
       

     

       540
       535
        
       	// Build block record

     

       541
       536
        
       	// CRITICAL: Collection is social.coves.community.block (RECORD TYPE)

     

       542
       537
        
       	// This record will be created in the USER's repository: at://user_did/social.coves.community.block/{tid}

     
···

       567
       562
        
       			// Fetch and return existing block from our indexed view

     

       568
       563
        
       			existingBlock, getErr := s.repo.GetBlock(ctx, userDID, communityDID)

     

       569
       564
        
       			if getErr == nil {

     

       565
       565
       +
       				// Block exists in our index - return it

     

       570
       566
        
       				return existingBlock, nil

     

       571
       567
        
       			}

     

       572
       572
       -
       			// If we can't find it in our index, return the original PDS error

     

       568
       568
       +
       			// Race condition: PDS has the block but Jetstream hasn't indexed it yet

     

       569
       569
       +
       			// Return typed conflict error so handler can return 409 instead of 500

     

       570
       570
       +
       			// This is normal in eventually-consistent systems

     

       571
       571
       +
       			return nil, ErrBlockAlreadyExists

     

       573
       572
        
       		}

     

       574
       573
        
       		return nil, fmt.Errorf("failed to create block on PDS: %w", err)

     

       575
       574
        
       	}

     
···

       608
       607
        
       	}

     

       609
       608
        
       

     

       610
       609
        
       	// Extract rkey from record URI (at://did/collection/rkey)

     

       611
       611
       -
       	rkey := extractRKeyFromURI(block.RecordURI)

     

       610
       610
       +
       	rkey := utils.ExtractRKeyFromURI(block.RecordURI)

     

       612
       611
        
       	if rkey == "" {

     

       613
       612
        
       		return fmt.Errorf("invalid block record URI")

     

       614
       613
        
       	}

     
···

       872
       871
        
       

     

       873
       872
        
       // Helper functions

     

       874
       873
        
       

     

       875
       875
       -
       func extractRKeyFromURI(uri string) string {

     

       876
       876
       -
       	// at://did/collection/rkey -> rkey

     

       877
       877
       -
       	parts := strings.Split(uri, "/")

     

       878
       878
       -
       	if len(parts) >= 4 {

     

       879
       879
       -
       		return parts[len(parts)-1]

     

       880
       880
       -
       	}

     

       881
       881
       -
       	return ""

     

       882
       882
       -
       }

+7 -14

tests/integration/community_e2e_test.go

···

       5
       5
        
       	"Coves/internal/api/routes"

     

       6
       6
        
       	"Coves/internal/atproto/identity"

     

       7
       7
        
       	"Coves/internal/atproto/jetstream"

     

       8
       8
       +
       	"Coves/internal/atproto/utils"

     

       8
       9
        
       	"Coves/internal/core/communities"

     

       9
       10
        
       	"Coves/internal/core/users"

     

       10
       11
        
       	"Coves/internal/db/postgres"

     
···

       213
       214
        
       		t.Logf("\n📡 V2: Querying PDS for record in community's repository...")

     

       214
       215
        
       

     

       215
       216
        
       		collection := "social.coves.community.profile"

     

       216
       216
       -
       		rkey := extractRKeyFromURI(community.RecordURI)

     

       217
       217
       +
       		rkey := utils.ExtractRKeyFromURI(community.RecordURI)

     

       217
       218
        
       

     

       218
       219
        
       		// V2: Query community's repository (not instance repository!)

     

       219
       220
        
       		getRecordURL := fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",

     
···

       423
       424
        
       			// NOTE: Using synthetic event for speed. Real Jetstream WebSocket testing

     

       424
       425
        
       			// happens in "Part 2: Real Jetstream Firehose Consumption" above.

     

       425
       426
        
       			t.Logf("🔄 Simulating Jetstream consumer indexing...")

     

       426
       426
       -
       			rkey := extractRKeyFromURI(createResp.URI)

     

       427
       427
       +
       			rkey := utils.ExtractRKeyFromURI(createResp.URI)

     

       427
       428
        
       			// V2: Event comes from community's DID (community owns the repo)

     

       428
       429
        
       			event := jetstream.JetstreamEvent{

     

       429
       430
        
       				Did:    createResp.DID,

     
···

       626
       627
        
       				pdsURL = "http://localhost:3001"

     

       627
       628
        
       			}

     

       628
       629
        
       

     

       629
       629
       -
       			rkey := extractRKeyFromURI(subscribeResp.URI)

     

       630
       630
       +
       			rkey := utils.ExtractRKeyFromURI(subscribeResp.URI)

     

       630
       631
        
       			// CRITICAL: Use correct collection name (record type, not XRPC endpoint)

     

       631
       632
        
       			collection := "social.coves.community.subscription"

     

       632
       633
        
       

     
···

       757
       758
        
       			}

     

       758
       759
        
       

     

       759
       760
        
       			// Index the subscription in AppView (simulate firehose event)

     

       760
       760
       -
       			rkey := extractRKeyFromURI(subscription.RecordURI)

     

       761
       761
       +
       			rkey := utils.ExtractRKeyFromURI(subscription.RecordURI)

     

       761
       762
        
       			subEvent := jetstream.JetstreamEvent{

     

       762
       763
        
       				Did:    instanceDID,

     

       763
       764
        
       				TimeUS: time.Now().UnixMicro(),

     
···

       1331
       1332
        
       

     

       1332
       1333
        
       			// Simulate Jetstream consumer picking up the update event

     

       1333
       1334
        
       			t.Logf("🔄 Simulating Jetstream consumer indexing update...")

     

       1334
       1334
       -
       			rkey := extractRKeyFromURI(updateResp.URI)

     

       1335
       1335
       +
       			rkey := utils.ExtractRKeyFromURI(updateResp.URI)

     

       1335
       1336
        
       

     

       1336
       1337
        
       			// Fetch updated record from PDS

     

       1337
       1338
        
       			pdsURL := os.Getenv("PDS_URL")

     
···

       1458
       1459
        
       	// Fetch from PDS to get full record

     

       1459
       1460
        
       	// V2: Record lives in community's own repository (at://community.DID/...)

     

       1460
       1461
        
       	collection := "social.coves.community.profile"

     

       1461
       1461
       -
       	rkey := extractRKeyFromURI(community.RecordURI)

     

       1462
       1462
       +
       	rkey := utils.ExtractRKeyFromURI(community.RecordURI)

     

       1462
       1463
        
       

     

       1463
       1464
        
       	pdsResp, pdsErr := http.Get(fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",

     

       1464
       1465
        
       		pdsURL, community.DID, collection, rkey))

     
···

       1504
       1505
        
       	return community

     

       1505
       1506
        
       }

     

       1506
       1507
        
       

     

       1507
       1507
       -
       func extractRKeyFromURI(uri string) string {

     

       1508
       1508
       -
       	// at://did/collection/rkey -> rkey

     

       1509
       1509
       -
       	parts := strings.Split(uri, "/")

     

       1510
       1510
       -
       	if len(parts) >= 4 {

     

       1511
       1511
       -
       		return parts[len(parts)-1]

     

       1512
       1512
       -
       	}

     

       1513
       1513
       -
       	return ""

     

       1514
       1514
       -
       }

     

       1515
       1508
        
       

     

       1516
       1509
        
       // authenticateWithPDS authenticates with the PDS and returns access token and DID

     

       1517
       1510
        
       func authenticateWithPDS(pdsURL, handle, password string) (string, string, error) {