commit 040b23e72ca055c1f80f0bdfcdadd9975d7e60e8 · bretton.dev/coves

.env.dev

···

       137
        
       # Always true for local development (use PLC_DIRECTORY_URL to control registration)

     

       138
        
       IS_DEV_ENV=true

     

       139
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       140
        
       # Logging

     

       141
        
       LOG_LEVEL=debug

     

       142
        
       LOG_ENABLED=true

···

       137
        
       # Always true for local development (use PLC_DIRECTORY_URL to control registration)

     

       138
        
       IS_DEV_ENV=true

     

       139
        
       

     

       140
       +
       # Security: Skip did:web domain verification for local development

     

       141
       +
       # IMPORTANT: Set to false in production to prevent domain spoofing attacks

     

       142
       +
       # When true, communities can claim any hostedByDID without verification

     

       143
       +
       # When false, hostedByDID must match the community handle domain

     

       144
       +
       SKIP_DID_WEB_VERIFICATION=true

     

       145
       +
       

     

       146
        
       # Logging

     

       147
        
       LOG_LEVEL=debug

     

       148
        
       LOG_ENABLED=true

+11 -7

cmd/server/main.go

···

       148
        
       	// We cannot allow arbitrary domains to prevent impersonation attacks

     

       149
        
       	// Example attack: !leagueoflegends@riotgames.com on a non-Riot instance

     

       150
        
       	//

     

       151
       -
       	// TODO (Security - V2.1): Implement did:web domain verification

     

       152
       -
       	// Currently, any self-hoster can set INSTANCE_DID=did:web:nintendo.com without

     

       153
       -
       	// actually owning nintendo.com. This allows domain impersonation attacks.

     

       154
       -
       	// Solution: Verify domain ownership by fetching https://domain/.well-known/did.json

     

       155
       -
       	// and ensuring it matches the claimed DID. See: https://atproto.com/specs/did-web

     

       156
       -
       	// Alternatively, switch to did:plc for instance DIDs (cryptographically unique).

     

       157
        
       	var instanceDomain string

     

       158
        
       	if strings.HasPrefix(instanceDID, "did:web:") {

     

       159
        
       		// Extract domain from did:web (this is the authoritative source)

     
···

       229
        
       		communityJetstreamURL = "ws://localhost:6008/subscribe?wantedCollections=social.coves.community.profile&wantedCollections=social.coves.community.subscription"

     

       230
        
       	}

     

       231
        
       

     

       232
       -
       	communityEventConsumer := jetstream.NewCommunityEventConsumer(communityRepo)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       233
        
       	communityJetstreamConnector := jetstream.NewCommunityJetstreamConnector(communityEventConsumer, communityJetstreamURL)

     

       234
        
       

     

       235
        
       	go func() {

···

       148
        
       	// We cannot allow arbitrary domains to prevent impersonation attacks

     

       149
        
       	// Example attack: !leagueoflegends@riotgames.com on a non-Riot instance

     

       150
        
       	//

     

       151
       +
       	// SECURITY: did:web domain verification is implemented in the Jetstream consumer

     

       152
       +
       	// See: internal/atproto/jetstream/community_consumer.go - verifyHostedByClaim()

     

       153
       +
       	// Communities with mismatched hostedBy domains are rejected during indexing

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       154
        
       	var instanceDomain string

     

       155
        
       	if strings.HasPrefix(instanceDID, "did:web:") {

     

       156
        
       		// Extract domain from did:web (this is the authoritative source)

     
···

       226
        
       		communityJetstreamURL = "ws://localhost:6008/subscribe?wantedCollections=social.coves.community.profile&wantedCollections=social.coves.community.subscription"

     

       227
        
       	}

     

       228
        
       

     

       229
       +
       	// Initialize community event consumer with did:web verification

     

       230
       +
       	skipDIDWebVerification := os.Getenv("SKIP_DID_WEB_VERIFICATION") == "true"

     

       231
       +
       	if skipDIDWebVerification {

     

       232
       +
       		log.Println("⚠️  WARNING: did:web domain verification is DISABLED (dev mode)")

     

       233
       +
       		log.Println("   Set SKIP_DID_WEB_VERIFICATION=false for production")

     

       234
       +
       	}

     

       235
       +
       

     

       236
       +
       	communityEventConsumer := jetstream.NewCommunityEventConsumer(communityRepo, instanceDID, skipDIDWebVerification)

     

       237
        
       	communityJetstreamConnector := jetstream.NewCommunityJetstreamConnector(communityEventConsumer, communityJetstreamURL)

     

       238
        
       

     

       239
        
       	go func() {

+7 -8

go.mod

···

       1
        
       module Coves

     

       2
        
       

     

       3
       -
       go 1.24

     

       4
        
       

     

       5
        
       require (

     

       6
        
       	github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe

     

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

     

       8
       -
       	github.com/gorilla/sessions v1.4.0

     

       9
        
       	github.com/gorilla/websocket v1.5.3

     

       0
        
       
     

       10
        
       	github.com/lestrrat-go/jwx/v2 v2.0.12

     

       11
        
       	github.com/lib/pq v1.10.9

     

       12
        
       	github.com/pressly/goose/v3 v3.22.1

     

       13
       -
       	golang.org/x/crypto v0.31.0

     

       0
        
       
     

       14
        
       )

     

       15
        
       

     

       16
        
       require (

     
···

       23
        
       	github.com/go-logr/stdr v1.2.2 // indirect

     

       24
        
       	github.com/goccy/go-json v0.10.2 // indirect

     

       25
        
       	github.com/gogo/protobuf v1.3.2 // indirect

     

       26
       -
       	github.com/golang-jwt/jwt/v5 v5.3.0 // indirect

     

       27
        
       	github.com/google/uuid v1.6.0 // indirect

     

       28
       -
       	github.com/gorilla/securecookie v1.1.2 // indirect

     

       29
        
       	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect

     

       30
        
       	github.com/hashicorp/go-retryablehttp v0.7.5 // indirect

     

       31
        
       	github.com/hashicorp/golang-lru v1.0.2 // indirect

     

       32
       -
       	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect

     

       33
        
       	github.com/ipfs/bbloom v0.0.4 // indirect

     

       34
        
       	github.com/ipfs/go-block-format v0.2.0 // indirect

     

       35
        
       	github.com/ipfs/go-cid v0.4.1 // indirect

     
···

       79
        
       	go.uber.org/atomic v1.11.0 // indirect

     

       80
        
       	go.uber.org/multierr v1.11.0 // indirect

     

       81
        
       	go.uber.org/zap v1.26.0 // indirect

     

       0
        
       
     

       82
        
       	golang.org/x/sync v0.10.0 // indirect

     

       83
       -
       	golang.org/x/sys v0.28.0 // indirect

     

       84
       -
       	golang.org/x/time v0.3.0 // indirect

     

       85
        
       	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect

     

       86
        
       	google.golang.org/protobuf v1.33.0 // indirect

     

       87
        
       	lukechampine.com/blake3 v1.2.1 // indirect

···

       1
        
       module Coves

     

       2
        
       

     

       3
       +
       go 1.24.0

     

       4
        
       

     

       5
        
       require (

     

       6
        
       	github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe

     

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

     

       8
       +
       	github.com/golang-jwt/jwt/v5 v5.3.0

     

       9
        
       	github.com/gorilla/websocket v1.5.3

     

       10
       +
       	github.com/hashicorp/golang-lru/v2 v2.0.7

     

       11
        
       	github.com/lestrrat-go/jwx/v2 v2.0.12

     

       12
        
       	github.com/lib/pq v1.10.9

     

       13
        
       	github.com/pressly/goose/v3 v3.22.1

     

       14
       +
       	golang.org/x/net v0.46.0

     

       15
       +
       	golang.org/x/time v0.3.0

     

       16
        
       )

     

       17
        
       

     

       18
        
       require (

     
···

       25
        
       	github.com/go-logr/stdr v1.2.2 // indirect

     

       26
        
       	github.com/goccy/go-json v0.10.2 // indirect

     

       27
        
       	github.com/gogo/protobuf v1.3.2 // indirect

     

       0
        
       
     

       28
        
       	github.com/google/uuid v1.6.0 // indirect

     

       0
        
       
     

       29
        
       	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect

     

       30
        
       	github.com/hashicorp/go-retryablehttp v0.7.5 // indirect

     

       31
        
       	github.com/hashicorp/golang-lru v1.0.2 // indirect

     

       0
        
       
     

       32
        
       	github.com/ipfs/bbloom v0.0.4 // indirect

     

       33
        
       	github.com/ipfs/go-block-format v0.2.0 // indirect

     

       34
        
       	github.com/ipfs/go-cid v0.4.1 // indirect

     
···

       78
        
       	go.uber.org/atomic v1.11.0 // indirect

     

       79
        
       	go.uber.org/multierr v1.11.0 // indirect

     

       80
        
       	go.uber.org/zap v1.26.0 // indirect

     

       81
       +
       	golang.org/x/crypto v0.43.0 // indirect

     

       82
        
       	golang.org/x/sync v0.10.0 // indirect

     

       83
       +
       	golang.org/x/sys v0.37.0 // indirect

     

       0
        
       
     

       84
        
       	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect

     

       85
        
       	google.golang.org/protobuf v1.33.0 // indirect

     

       86
        
       	lukechampine.com/blake3 v1.2.1 // indirect

+6 -11

go.sum

···

       31
        
       github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=

     

       32
        
       github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=

     

       33
        
       github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=

     

       34
       -
       github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY=

     

       35
        
       github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=

     

       36
        
       github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=

     

       37
        
       github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=

     

       38
        
       github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=

     

       39
       -
       github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=

     

       40
       -
       github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=

     

       41
        
       github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=

     

       42
        
       github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=

     

       43
        
       github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=

     

       44
        
       github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=

     

       45
        
       github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=

     

       46
       -
       github.com/gorilla/securecookie v1.1.2 h1:YCIWL56dvtr73r6715mJs5ZvhtnY73hBvEF8kXD8ePA=

     

       47
       -
       github.com/gorilla/securecookie v1.1.2/go.mod h1:NfCASbcHqRSY+3a8tlWJwsQap2VX5pwzwo4h3eOamfo=

     

       48
       -
       github.com/gorilla/sessions v1.4.0 h1:kpIYOp/oi6MG/p5PgxApU8srsSw9tuFbt46Lt7auzqQ=

     

       49
       -
       github.com/gorilla/sessions v1.4.0/go.mod h1:FLWm50oby91+hl7p/wRxDth9bWSuk0qVL2emc7lT5ik=

     

       50
        
       github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=

     

       51
        
       github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=

     

       52
        
       github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=

     
···

       232
        
       golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=

     

       233
        
       golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=

     

       234
        
       golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=

     

       235
       -
       golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=

     

       236
       -
       golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=

     

       237
        
       golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=

     

       238
        
       golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=

     

       239
        
       golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=

     
···

       251
        
       golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=

     

       252
        
       golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=

     

       253
        
       golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=

     

       0
        
       
     

       0
        
       
     

       254
        
       golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       255
        
       golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       256
        
       golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     
···

       274
        
       golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       275
        
       golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       276
        
       golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       277
       -
       golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=

     

       278
       -
       golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

     

       279
        
       golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=

     

       280
        
       golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=

     

       281
        
       golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=

···

       31
        
       github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=

     

       32
        
       github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=

     

       33
        
       github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=

     

       0
        
       
     

       34
        
       github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=

     

       35
        
       github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=

     

       36
        
       github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=

     

       37
        
       github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=

     

       0
        
       
     

       0
        
       
     

       38
        
       github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=

     

       39
        
       github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=

     

       40
        
       github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=

     

       41
        
       github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=

     

       42
        
       github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       43
        
       github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=

     

       44
        
       github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=

     

       45
        
       github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=

     
···

       225
        
       golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=

     

       226
        
       golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=

     

       227
        
       golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=

     

       228
       +
       golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04=

     

       229
       +
       golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=

     

       230
        
       golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=

     

       231
        
       golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=

     

       232
        
       golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=

     
···

       244
        
       golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=

     

       245
        
       golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=

     

       246
        
       golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=

     

       247
       +
       golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=

     

       248
       +
       golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=

     

       249
        
       golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       250
        
       golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       251
        
       golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     
···

       269
        
       golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       270
        
       golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       271
        
       golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       272
       +
       golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=

     

       273
       +
       golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=

     

       274
        
       golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=

     

       275
        
       golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=

     

       276
        
       golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=

+243 -3

internal/atproto/jetstream/community_consumer.go

···

       7
        
       	"encoding/json"

     

       8
        
       	"fmt"

     

       9
        
       	"log"

     

       0
        
       
     

       0
        
       
     

       10
        
       	"time"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       11
        
       )

     

       12
        
       

     

       13
        
       // CommunityEventConsumer consumes community-related events from Jetstream

     

       14
        
       type CommunityEventConsumer struct {

     

       15
       -
       	repo communities.Repository

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       16
        
       }

     

       17
        
       

     

       18
        
       // NewCommunityEventConsumer creates a new Jetstream consumer for community events

     

       19
       -
       func NewCommunityEventConsumer(repo communities.Repository) *CommunityEventConsumer {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       20
        
       	return &CommunityEventConsumer{

     

       21
       -
       		repo: repo,

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       22
        
       	}

     

       23
        
       }

     

       24
        
       

     
···

       80
        
       	profile, err := parseCommunityProfile(commit.Record)

     

       81
        
       	if err != nil {

     

       82
        
       		return fmt.Errorf("failed to parse community profile: %w", err)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       83
        
       	}

     

       84
        
       

     

       85
        
       	// Build AT-URI for this record

     
···

       232
        
       

     

       233
        
       	log.Printf("Deleted community: %s", did)

     

       234
        
       	return nil

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       235
        
       }

     

       236
        
       

     

       237
        
       // handleSubscription processes subscription create/delete events

···

       7
        
       	"encoding/json"

     

       8
        
       	"fmt"

     

       9
        
       	"log"

     

       10
       +
       	"net/http"

     

       11
       +
       	"strings"

     

       12
        
       	"time"

     

       13
       +
       

     

       14
       +
       	lru "github.com/hashicorp/golang-lru/v2"

     

       15
       +
       	"golang.org/x/net/publicsuffix"

     

       16
       +
       	"golang.org/x/time/rate"

     

       17
        
       )

     

       18
        
       

     

       19
        
       // CommunityEventConsumer consumes community-related events from Jetstream

     

       20
        
       type CommunityEventConsumer struct {

     

       21
       +
       	repo             communities.Repository           // Repository for community operations

     

       22
       +
       	httpClient       *http.Client                     // Shared HTTP client with connection pooling

     

       23
       +
       	didCache         *lru.Cache[string, cachedDIDDoc] // Bounded LRU cache for .well-known verification results

     

       24
       +
       	wellKnownLimiter *rate.Limiter                    // Rate limiter for .well-known fetches

     

       25
       +
       	instanceDID      string                           // DID of this Coves instance

     

       26
       +
       	skipVerification bool                             // Skip did:web verification (for dev mode)

     

       27
       +
       }

     

       28
       +
       

     

       29
       +
       // cachedDIDDoc represents a cached verification result with expiration

     

       30
       +
       type cachedDIDDoc struct {

     

       31
       +
       	expiresAt time.Time // When this cache entry expires

     

       32
       +
       	valid     bool      // Whether verification passed

     

       33
        
       }

     

       34
        
       

     

       35
        
       // NewCommunityEventConsumer creates a new Jetstream consumer for community events

     

       36
       +
       // instanceDID: The DID of this Coves instance (for hostedBy verification)

     

       37
       +
       // skipVerification: Skip did:web verification (for dev mode)

     

       38
       +
       func NewCommunityEventConsumer(repo communities.Repository, instanceDID string, skipVerification bool) *CommunityEventConsumer {

     

       39
       +
       	// Create bounded LRU cache for DID document verification results

     

       40
       +
       	// Max 1000 entries to prevent unbounded memory growth (PR review feedback)

     

       41
       +
       	// Each entry ~100 bytes → max ~100KB memory overhead

     

       42
       +
       	cache, err := lru.New[string, cachedDIDDoc](1000)

     

       43
       +
       	if err != nil {

     

       44
       +
       		// This should never happen with a valid size, but handle gracefully

     

       45
       +
       		log.Printf("WARNING: Failed to create DID cache, verification will be slower: %v", err)

     

       46
       +
       		// Create minimal cache to avoid nil pointer

     

       47
       +
       		cache, _ = lru.New[string, cachedDIDDoc](1)

     

       48
       +
       	}

     

       49
       +
       

     

       50
        
       	return &CommunityEventConsumer{

     

       51
       +
       		repo:             repo,

     

       52
       +
       		instanceDID:      instanceDID,

     

       53
       +
       		skipVerification: skipVerification,

     

       54
       +
       		// Shared HTTP client with connection pooling for .well-known fetches

     

       55
       +
       		httpClient: &http.Client{

     

       56
       +
       			Timeout: 10 * time.Second,

     

       57
       +
       			Transport: &http.Transport{

     

       58
       +
       				MaxIdleConns:        100,

     

       59
       +
       				MaxIdleConnsPerHost: 10,

     

       60
       +
       				IdleConnTimeout:     90 * time.Second,

     

       61
       +
       			},

     

       62
       +
       		},

     

       63
       +
       		// Bounded LRU cache for .well-known verification results (max 1000 entries)

     

       64
       +
       		// Automatically evicts least-recently-used entries when full

     

       65
       +
       		didCache: cache,

     

       66
       +
       		// Rate limiter: 10 requests per second, burst of 20

     

       67
       +
       		// Prevents DoS via excessive .well-known fetches

     

       68
       +
       		wellKnownLimiter: rate.NewLimiter(10, 20),

     

       69
        
       	}

     

       70
        
       }

     

       71
        
       

     
···

       127
        
       	profile, err := parseCommunityProfile(commit.Record)

     

       128
        
       	if err != nil {

     

       129
        
       		return fmt.Errorf("failed to parse community profile: %w", err)

     

       130
       +
       	}

     

       131
       +
       

     

       132
       +
       	// SECURITY: Verify hostedBy claim matches handle domain

     

       133
       +
       	// This prevents malicious instances from claiming to host communities for domains they don't own

     

       134
       +
       	if err := c.verifyHostedByClaim(ctx, profile.Handle, profile.HostedBy); err != nil {

     

       135
       +
       		log.Printf("🚨 SECURITY: Rejecting community %s - hostedBy verification failed: %v", did, err)

     

       136
       +
       		log.Printf("    Handle: %s, HostedBy: %s", profile.Handle, profile.HostedBy)

     

       137
       +
       		return fmt.Errorf("hostedBy verification failed: %w", err)

     

       138
        
       	}

     

       139
        
       

     

       140
        
       	// Build AT-URI for this record

     
···

       287
        
       

     

       288
        
       	log.Printf("Deleted community: %s", did)

     

       289
        
       	return nil

     

       290
       +
       }

     

       291
       +
       

     

       292
       +
       // verifyHostedByClaim verifies that the community's hostedBy claim matches the handle domain

     

       293
       +
       // This prevents malicious instances from claiming to host communities for domains they don't own

     

       294
       +
       func (c *CommunityEventConsumer) verifyHostedByClaim(ctx context.Context, handle, hostedByDID string) error {

     

       295
       +
       	// Skip verification in dev mode

     

       296
       +
       	if c.skipVerification {

     

       297
       +
       		return nil

     

       298
       +
       	}

     

       299
       +
       

     

       300
       +
       	// Add 15 second overall timeout to prevent slow verification from blocking consumer (PR review feedback)

     

       301
       +
       	ctx, cancel := context.WithTimeout(ctx, 15*time.Second)

     

       302
       +
       	defer cancel()

     

       303
       +
       

     

       304
       +
       	// Verify hostedByDID is did:web format

     

       305
       +
       	if !strings.HasPrefix(hostedByDID, "did:web:") {

     

       306
       +
       		return fmt.Errorf("hostedByDID must use did:web method, got: %s", hostedByDID)

     

       307
       +
       	}

     

       308
       +
       

     

       309
       +
       	// Extract domain from did:web DID

     

       310
       +
       	hostedByDomain := strings.TrimPrefix(hostedByDID, "did:web:")

     

       311
       +
       

     

       312
       +
       	// Extract domain from community handle

     

       313
       +
       	// Handle format examples:

     

       314
       +
       	//   - "!gaming@coves.social" → domain: "coves.social"

     

       315
       +
       	//   - "gaming.communities.coves.social" → domain: "coves.social"

     

       316
       +
       	handleDomain := extractDomainFromHandle(handle)

     

       317
       +
       	if handleDomain == "" {

     

       318
       +
       		return fmt.Errorf("failed to extract domain from handle: %s", handle)

     

       319
       +
       	}

     

       320
       +
       

     

       321
       +
       	// Verify handle domain matches hostedBy domain

     

       322
       +
       	if handleDomain != hostedByDomain {

     

       323
       +
       		return fmt.Errorf("handle domain (%s) doesn't match hostedBy domain (%s)", handleDomain, hostedByDomain)

     

       324
       +
       	}

     

       325
       +
       

     

       326
       +
       	// Optional: Verify DID document exists and is valid

     

       327
       +
       	// This provides cryptographic proof of domain ownership

     

       328
       +
       	if err := c.verifyDIDDocument(ctx, hostedByDID, hostedByDomain); err != nil {

     

       329
       +
       		// Soft-fail: Log warning but don't reject the community

     

       330
       +
       		// This allows operation during network issues or .well-known misconfiguration

     

       331
       +
       		log.Printf("⚠️  WARNING: DID document verification failed for %s: %v", hostedByDomain, err)

     

       332
       +
       		log.Printf("    Community will be indexed, but hostedBy claim cannot be cryptographically verified")

     

       333
       +
       	}

     

       334
       +
       

     

       335
       +
       	return nil

     

       336
       +
       }

     

       337
       +
       

     

       338
       +
       // verifyDIDDocument fetches and validates the DID document from .well-known/did.json

     

       339
       +
       // This provides cryptographic proof that the instance controls the domain

     

       340
       +
       // Results are cached with TTL and rate-limited to prevent DoS attacks

     

       341
       +
       func (c *CommunityEventConsumer) verifyDIDDocument(ctx context.Context, did, domain string) error {

     

       342
       +
       	// Skip verification in dev mode

     

       343
       +
       	if c.skipVerification {

     

       344
       +
       		return nil

     

       345
       +
       	}

     

       346
       +
       

     

       347
       +
       	// Check bounded LRU cache first (thread-safe, no locks needed)

     

       348
       +
       	if cached, ok := c.didCache.Get(did); ok {

     

       349
       +
       		// Check if cache entry is still valid (not expired)

     

       350
       +
       		if time.Now().Before(cached.expiresAt) {

     

       351
       +
       			if !cached.valid {

     

       352
       +
       				return fmt.Errorf("cached verification failure for %s", did)

     

       353
       +
       			}

     

       354
       +
       			log.Printf("✓ DID document verification (cached): %s", domain)

     

       355
       +
       			return nil

     

       356
       +
       		}

     

       357
       +
       		// Cache entry expired - remove it to free up space for fresh entries

     

       358
       +
       		c.didCache.Remove(did)

     

       359
       +
       	}

     

       360
       +
       

     

       361
       +
       	// Rate limit .well-known fetches to prevent DoS

     

       362
       +
       	if err := c.wellKnownLimiter.Wait(ctx); err != nil {

     

       363
       +
       		return fmt.Errorf("rate limit exceeded for .well-known fetch: %w", err)

     

       364
       +
       	}

     

       365
       +
       

     

       366
       +
       	// Construct .well-known URL

     

       367
       +
       	didDocURL := fmt.Sprintf("https://%s/.well-known/did.json", domain)

     

       368
       +
       

     

       369
       +
       	// Create HTTP request with timeout

     

       370
       +
       	req, err := http.NewRequestWithContext(ctx, "GET", didDocURL, nil)

     

       371
       +
       	if err != nil {

     

       372
       +
       		// Cache the failure

     

       373
       +
       		c.cacheVerificationResult(did, false, 5*time.Minute)

     

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

     

       375
       +
       	}

     

       376
       +
       

     

       377
       +
       	// Fetch DID document using shared HTTP client

     

       378
       +
       	resp, err := c.httpClient.Do(req)

     

       379
       +
       	if err != nil {

     

       380
       +
       		// Cache the failure (shorter TTL for network errors)

     

       381
       +
       		c.cacheVerificationResult(did, false, 5*time.Minute)

     

       382
       +
       		return fmt.Errorf("failed to fetch DID document from %s: %w", didDocURL, err)

     

       383
       +
       	}

     

       384
       +
       	defer func() {

     

       385
       +
       		if closeErr := resp.Body.Close(); closeErr != nil {

     

       386
       +
       			log.Printf("Failed to close response body: %v", closeErr)

     

       387
       +
       		}

     

       388
       +
       	}()

     

       389
       +
       

     

       390
       +
       	// Verify HTTP status

     

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

     

       392
       +
       		// Cache the failure

     

       393
       +
       		c.cacheVerificationResult(did, false, 5*time.Minute)

     

       394
       +
       		return fmt.Errorf("DID document returned HTTP %d from %s", resp.StatusCode, didDocURL)

     

       395
       +
       	}

     

       396
       +
       

     

       397
       +
       	// Parse DID document

     

       398
       +
       	var didDoc struct {

     

       399
       +
       		ID string `json:"id"`

     

       400
       +
       	}

     

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

     

       402
       +
       		// Cache the failure

     

       403
       +
       		c.cacheVerificationResult(did, false, 5*time.Minute)

     

       404
       +
       		return fmt.Errorf("failed to parse DID document JSON: %w", err)

     

       405
       +
       	}

     

       406
       +
       

     

       407
       +
       	// Verify DID document ID matches claimed DID

     

       408
       +
       	if didDoc.ID != did {

     

       409
       +
       		// Cache the failure

     

       410
       +
       		c.cacheVerificationResult(did, false, 5*time.Minute)

     

       411
       +
       		return fmt.Errorf("DID document ID (%s) doesn't match claimed DID (%s)", didDoc.ID, did)

     

       412
       +
       	}

     

       413
       +
       

     

       414
       +
       	// Cache the success (1 hour TTL)

     

       415
       +
       	c.cacheVerificationResult(did, true, 1*time.Hour)

     

       416
       +
       

     

       417
       +
       	log.Printf("✓ DID document verified: %s", domain)

     

       418
       +
       	return nil

     

       419
       +
       }

     

       420
       +
       

     

       421
       +
       // cacheVerificationResult stores a verification result in the bounded LRU cache with the given TTL

     

       422
       +
       // The LRU cache is thread-safe and automatically evicts least-recently-used entries when full

     

       423
       +
       func (c *CommunityEventConsumer) cacheVerificationResult(did string, valid bool, ttl time.Duration) {

     

       424
       +
       	c.didCache.Add(did, cachedDIDDoc{

     

       425
       +
       		valid:     valid,

     

       426
       +
       		expiresAt: time.Now().Add(ttl),

     

       427
       +
       	})

     

       428
       +
       }

     

       429
       +
       

     

       430
       +
       // extractDomainFromHandle extracts the registrable domain from a community handle

     

       431
       +
       // Handles both formats:

     

       432
       +
       //   - Bluesky-style: "!gaming@coves.social" → "coves.social"

     

       433
       +
       //   - DNS-style: "gaming.communities.coves.social" → "coves.social"

     

       434
       +
       //

     

       435
       +
       // Uses golang.org/x/net/publicsuffix to correctly handle multi-part TLDs:

     

       436
       +
       //   - "gaming.communities.coves.co.uk" → "coves.co.uk" (not "co.uk")

     

       437
       +
       //   - "gaming.communities.example.com.au" → "example.com.au" (not "com.au")

     

       438
       +
       func extractDomainFromHandle(handle string) string {

     

       439
       +
       	// Remove leading ! if present

     

       440
       +
       	handle = strings.TrimPrefix(handle, "!")

     

       441
       +
       

     

       442
       +
       	// Check for @-separated format (e.g., "gaming@coves.social")

     

       443
       +
       	if strings.Contains(handle, "@") {

     

       444
       +
       		parts := strings.Split(handle, "@")

     

       445
       +
       		if len(parts) == 2 {

     

       446
       +
       			domain := parts[1]

     

       447
       +
       			// Validate and extract eTLD+1 from the @-domain part

     

       448
       +
       			registrable, err := publicsuffix.EffectiveTLDPlusOne(domain)

     

       449
       +
       			if err != nil {

     

       450
       +
       				// If publicsuffix fails, fall back to returning the full domain part

     

       451
       +
       				// This handles edge cases like localhost, IP addresses, etc.

     

       452
       +
       				return domain

     

       453
       +
       			}

     

       454
       +
       			return registrable

     

       455
       +
       		}

     

       456
       +
       		return ""

     

       457
       +
       	}

     

       458
       +
       

     

       459
       +
       	// For DNS-style handles (e.g., "gaming.communities.coves.social")

     

       460
       +
       	// Extract the registrable domain (eTLD+1) using publicsuffix

     

       461
       +
       	// This correctly handles multi-part TLDs like .co.uk, .com.au, etc.

     

       462
       +
       	registrable, err := publicsuffix.EffectiveTLDPlusOne(handle)

     

       463
       +
       	if err != nil {

     

       464
       +
       		// If publicsuffix fails (e.g., invalid TLD, localhost, IP address)

     

       465
       +
       		// fall back to naive extraction (last 2 parts)

     

       466
       +
       		// This maintains backward compatibility for edge cases

     

       467
       +
       		parts := strings.Split(handle, ".")

     

       468
       +
       		if len(parts) < 2 {

     

       469
       +
       			return "" // Invalid handle

     

       470
       +
       		}

     

       471
       +
       		return strings.Join(parts[len(parts)-2:], ".")

     

       472
       +
       	}

     

       473
       +
       

     

       474
       +
       	return registrable

     

       475
        
       }

     

       476
        
       

     

       477
        
       // handleSubscription processes subscription create/delete events

+2 -1

tests/integration/community_blocking_test.go

···

       22
        
       	defer cleanupBlockingTestDB(t, db)

     

       23
        
       

     

       24
        
       	repo := createBlockingTestCommunityRepo(t, db)

     

       25
       -
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       0
        
       
     

       26
        
       

     

       27
        
       	// Create test community

     

       28
        
       	testDID := fmt.Sprintf("did:plc:test-community-%d", time.Now().UnixNano())

···

       22
        
       	defer cleanupBlockingTestDB(t, db)

     

       23
        
       

     

       24
        
       	repo := createBlockingTestCommunityRepo(t, db)

     

       25
       +
       	// Skip verification in tests

     

       26
       +
       	consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.local", true)

     

       27
        
       

     

       28
        
       	// Create test community

     

       29
        
       	testDID := fmt.Sprintf("did:plc:test-community-%d", time.Now().UnixNano())

+6 -3

tests/integration/community_consumer_test.go

···

       19
        
       	}()

     

       20
        
       

     

       21
        
       	repo := postgres.NewCommunityRepository(db)

     

       22
       -
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       0
        
       
     

       23
        
       	ctx := context.Background()

     

       24
        
       

     

       25
        
       	t.Run("creates community from firehose event", func(t *testing.T) {

     
···

       215
        
       	}()

     

       216
        
       

     

       217
        
       	repo := postgres.NewCommunityRepository(db)

     

       218
       -
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       0
        
       
     

       219
        
       	ctx := context.Background()

     

       220
        
       

     

       221
        
       	t.Run("creates subscription from event", func(t *testing.T) {

     
···

       299
        
       	}()

     

       300
        
       

     

       301
        
       	repo := postgres.NewCommunityRepository(db)

     

       302
       -
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       0
        
       
     

       303
        
       	ctx := context.Background()

     

       304
        
       

     

       305
        
       	t.Run("ignores identity events", func(t *testing.T) {

···

       19
        
       	}()

     

       20
        
       

     

       21
        
       	repo := postgres.NewCommunityRepository(db)

     

       22
       +
       	// Skip verification in tests

     

       23
       +
       	consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.local", true)

     

       24
        
       	ctx := context.Background()

     

       25
        
       

     

       26
        
       	t.Run("creates community from firehose event", func(t *testing.T) {

     
···

       216
        
       	}()

     

       217
        
       

     

       218
        
       	repo := postgres.NewCommunityRepository(db)

     

       219
       +
       	// Skip verification in tests

     

       220
       +
       	consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.local", true)

     

       221
        
       	ctx := context.Background()

     

       222
        
       

     

       223
        
       	t.Run("creates subscription from event", func(t *testing.T) {

     
···

       301
        
       	}()

     

       302
        
       

     

       303
        
       	repo := postgres.NewCommunityRepository(db)

     

       304
       +
       	// Skip verification in tests

     

       305
       +
       	consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.local", true)

     

       306
        
       	ctx := context.Background()

     

       307
        
       

     

       308
        
       	t.Run("ignores identity events", func(t *testing.T) {

+2 -1

tests/integration/community_e2e_test.go

···

       142
        
       		svc.SetPDSAccessToken(accessToken)

     

       143
        
       	}

     

       144
        
       

     

       145
       -
       	consumer := jetstream.NewCommunityEventConsumer(communityRepo)

     

       0
        
       
     

       146
        
       

     

       147
        
       	// Setup HTTP server with XRPC routes

     

       148
        
       	r := chi.NewRouter()

···

       142
        
       		svc.SetPDSAccessToken(accessToken)

     

       143
        
       	}

     

       144
        
       

     

       145
       +
       	// Skip verification in tests

     

       146
       +
       	consumer := jetstream.NewCommunityEventConsumer(communityRepo, "did:web:coves.local", true)

     

       147
        
       

     

       148
        
       	// Setup HTTP server with XRPC routes

     

       149
        
       	r := chi.NewRouter()

+346

tests/integration/community_hostedby_security_test.go

···

       1
       +
       package integration

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"Coves/internal/atproto/jetstream"

     

       5
       +
       	"Coves/internal/db/postgres"

     

       6
       +
       	"context"

     

       7
       +
       	"fmt"

     

       8
       +
       	"testing"

     

       9
       +
       	"time"

     

       10
       +
       )

     

       11
       +
       

     

       12
       +
       // TestHostedByVerification_DomainMatching tests that hostedBy domain must match handle domain

     

       13
       +
       func TestHostedByVerification_DomainMatching(t *testing.T) {

     

       14
       +
       	db := setupTestDB(t)

     

       15
       +
       	defer func() {

     

       16
       +
       		if err := db.Close(); err != nil {

     

       17
       +
       			t.Logf("Failed to close database: %v", err)

     

       18
       +
       		}

     

       19
       +
       	}()

     

       20
       +
       

     

       21
       +
       	repo := postgres.NewCommunityRepository(db)

     

       22
       +
       	ctx := context.Background()

     

       23
       +
       

     

       24
       +
       	t.Run("rejects community with mismatched hostedBy domain", func(t *testing.T) {

     

       25
       +
       		// Create consumer with verification enabled

     

       26
       +
       		consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.social", false)

     

       27
       +
       

     

       28
       +
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       29
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       30
       +
       

     

       31
       +
       		// Attempt to create community claiming to be hosted by nintendo.com

     

       32
       +
       		// but with a coves.social handle (ATTACK!)

     

       33
       +
       		event := &jetstream.JetstreamEvent{

     

       34
       +
       			Did:    communityDID,

     

       35
       +
       			TimeUS: time.Now().UnixMicro(),

     

       36
       +
       			Kind:   "commit",

     

       37
       +
       			Commit: &jetstream.CommitEvent{

     

       38
       +
       				Rev:        "rev123",

     

       39
       +
       				Operation:  "create",

     

       40
       +
       				Collection: "social.coves.community.profile",

     

       41
       +
       				RKey:       "self",

     

       42
       +
       				CID:        "bafy123abc",

     

       43
       +
       				Record: map[string]interface{}{

     

       44
       +
       					"handle":      "gaming.communities.coves.social", // coves.social handle

     

       45
       +
       					"name":        "gaming",

     

       46
       +
       					"displayName": "Nintendo Gaming",

     

       47
       +
       					"description": "Fake Nintendo community",

     

       48
       +
       					"createdBy":   "did:plc:attacker123",

     

       49
       +
       					"hostedBy":    "did:web:nintendo.com", // ← SPOOFED! Claiming Nintendo hosting

     

       50
       +
       					"visibility":  "public",

     

       51
       +
       					"federation": map[string]interface{}{

     

       52
       +
       						"allowExternalDiscovery": true,

     

       53
       +
       					},

     

       54
       +
       					"memberCount":     0,

     

       55
       +
       					"subscriberCount": 0,

     

       56
       +
       					"createdAt":       time.Now().Format(time.RFC3339),

     

       57
       +
       				},

     

       58
       +
       			},

     

       59
       +
       		}

     

       60
       +
       

     

       61
       +
       		// This should fail verification

     

       62
       +
       		err := consumer.HandleEvent(ctx, event)

     

       63
       +
       		if err == nil {

     

       64
       +
       			t.Fatal("Expected verification error for mismatched hostedBy domain, got nil")

     

       65
       +
       		}

     

       66
       +
       

     

       67
       +
       		// Verify error message mentions domain mismatch

     

       68
       +
       		errMsg := err.Error()

     

       69
       +
       		if errMsg == "" {

     

       70
       +
       			t.Fatal("Expected error message, got empty string")

     

       71
       +
       		}

     

       72
       +
       		t.Logf("Got expected error: %v", err)

     

       73
       +
       

     

       74
       +
       		// Verify community was NOT indexed

     

       75
       +
       		_, getErr := repo.GetByDID(ctx, communityDID)

     

       76
       +
       		if getErr == nil {

     

       77
       +
       			t.Fatal("Community should not have been indexed, but was found in database")

     

       78
       +
       		}

     

       79
       +
       	})

     

       80
       +
       

     

       81
       +
       	t.Run("accepts community with matching hostedBy domain", func(t *testing.T) {

     

       82
       +
       		// Create consumer with verification enabled

     

       83
       +
       		consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.social", false)

     

       84
       +
       

     

       85
       +
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       86
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       87
       +
       

     

       88
       +
       		// Create community with matching hostedBy and handle domains

     

       89
       +
       		event := &jetstream.JetstreamEvent{

     

       90
       +
       			Did:    communityDID,

     

       91
       +
       			TimeUS: time.Now().UnixMicro(),

     

       92
       +
       			Kind:   "commit",

     

       93
       +
       			Commit: &jetstream.CommitEvent{

     

       94
       +
       				Rev:        "rev123",

     

       95
       +
       				Operation:  "create",

     

       96
       +
       				Collection: "social.coves.community.profile",

     

       97
       +
       				RKey:       "self",

     

       98
       +
       				CID:        "bafy123abc",

     

       99
       +
       				Record: map[string]interface{}{

     

       100
       +
       					"handle":      "gaming.communities.coves.social", // coves.social handle

     

       101
       +
       					"name":        "gaming",

     

       102
       +
       					"displayName": "Gaming Community",

     

       103
       +
       					"description": "Legitimate coves.social community",

     

       104
       +
       					"createdBy":   "did:plc:user123",

     

       105
       +
       					"hostedBy":    "did:web:coves.social", // ✅ Matches handle domain

     

       106
       +
       					"visibility":  "public",

     

       107
       +
       					"federation": map[string]interface{}{

     

       108
       +
       						"allowExternalDiscovery": true,

     

       109
       +
       					},

     

       110
       +
       					"memberCount":     0,

     

       111
       +
       					"subscriberCount": 0,

     

       112
       +
       					"createdAt":       time.Now().Format(time.RFC3339),

     

       113
       +
       				},

     

       114
       +
       			},

     

       115
       +
       		}

     

       116
       +
       

     

       117
       +
       		// This should succeed

     

       118
       +
       		err := consumer.HandleEvent(ctx, event)

     

       119
       +
       		if err != nil {

     

       120
       +
       			t.Fatalf("Expected verification to succeed, got error: %v", err)

     

       121
       +
       		}

     

       122
       +
       

     

       123
       +
       		// Verify community was indexed

     

       124
       +
       		community, getErr := repo.GetByDID(ctx, communityDID)

     

       125
       +
       		if getErr != nil {

     

       126
       +
       			t.Fatalf("Community should have been indexed: %v", getErr)

     

       127
       +
       		}

     

       128
       +
       		if community.HostedByDID != "did:web:coves.social" {

     

       129
       +
       			t.Errorf("Expected hostedByDID 'did:web:coves.social', got '%s'", community.HostedByDID)

     

       130
       +
       		}

     

       131
       +
       	})

     

       132
       +
       

     

       133
       +
       	t.Run("rejects hostedBy with non-did:web format", func(t *testing.T) {

     

       134
       +
       		// Create consumer with verification enabled

     

       135
       +
       		consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.social", false)

     

       136
       +
       

     

       137
       +
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       138
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       139
       +
       

     

       140
       +
       		// Attempt to use did:plc for hostedBy (not allowed)

     

       141
       +
       		event := &jetstream.JetstreamEvent{

     

       142
       +
       			Did:    communityDID,

     

       143
       +
       			TimeUS: time.Now().UnixMicro(),

     

       144
       +
       			Kind:   "commit",

     

       145
       +
       			Commit: &jetstream.CommitEvent{

     

       146
       +
       				Rev:        "rev123",

     

       147
       +
       				Operation:  "create",

     

       148
       +
       				Collection: "social.coves.community.profile",

     

       149
       +
       				RKey:       "self",

     

       150
       +
       				CID:        "bafy123abc",

     

       151
       +
       				Record: map[string]interface{}{

     

       152
       +
       					"handle":      "gaming.communities.coves.social",

     

       153
       +
       					"name":        "gaming",

     

       154
       +
       					"displayName": "Test Community",

     

       155
       +
       					"description": "Test",

     

       156
       +
       					"createdBy":   "did:plc:user123",

     

       157
       +
       					"hostedBy":    "did:plc:xyz123", // ← Invalid: must be did:web

     

       158
       +
       					"visibility":  "public",

     

       159
       +
       					"federation": map[string]interface{}{

     

       160
       +
       						"allowExternalDiscovery": true,

     

       161
       +
       					},

     

       162
       +
       					"memberCount":     0,

     

       163
       +
       					"subscriberCount": 0,

     

       164
       +
       					"createdAt":       time.Now().Format(time.RFC3339),

     

       165
       +
       				},

     

       166
       +
       			},

     

       167
       +
       		}

     

       168
       +
       

     

       169
       +
       		// This should fail verification

     

       170
       +
       		err := consumer.HandleEvent(ctx, event)

     

       171
       +
       		if err == nil {

     

       172
       +
       			t.Fatal("Expected verification error for non-did:web hostedBy, got nil")

     

       173
       +
       		}

     

       174
       +
       		t.Logf("Got expected error: %v", err)

     

       175
       +
       	})

     

       176
       +
       

     

       177
       +
       	t.Run("skip verification flag bypasses all checks", func(t *testing.T) {

     

       178
       +
       		// Create consumer with verification DISABLED

     

       179
       +
       		consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.social", true)

     

       180
       +
       

     

       181
       +
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       182
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       183
       +
       

     

       184
       +
       		// Even with mismatched domain, this should succeed with skipVerification=true

     

       185
       +
       		event := &jetstream.JetstreamEvent{

     

       186
       +
       			Did:    communityDID,

     

       187
       +
       			TimeUS: time.Now().UnixMicro(),

     

       188
       +
       			Kind:   "commit",

     

       189
       +
       			Commit: &jetstream.CommitEvent{

     

       190
       +
       				Rev:        "rev123",

     

       191
       +
       				Operation:  "create",

     

       192
       +
       				Collection: "social.coves.community.profile",

     

       193
       +
       				RKey:       "self",

     

       194
       +
       				CID:        "bafy123abc",

     

       195
       +
       				Record: map[string]interface{}{

     

       196
       +
       					"handle":      "gaming.communities.example.com",

     

       197
       +
       					"name":        "gaming",

     

       198
       +
       					"displayName": "Test",

     

       199
       +
       					"description": "Test",

     

       200
       +
       					"createdBy":   "did:plc:user123",

     

       201
       +
       					"hostedBy":    "did:web:nintendo.com", // Mismatched, but verification skipped

     

       202
       +
       					"visibility":  "public",

     

       203
       +
       					"federation": map[string]interface{}{

     

       204
       +
       						"allowExternalDiscovery": true,

     

       205
       +
       					},

     

       206
       +
       					"memberCount":     0,

     

       207
       +
       					"subscriberCount": 0,

     

       208
       +
       					"createdAt":       time.Now().Format(time.RFC3339),

     

       209
       +
       				},

     

       210
       +
       			},

     

       211
       +
       		}

     

       212
       +
       

     

       213
       +
       		// Should succeed because verification is skipped

     

       214
       +
       		err := consumer.HandleEvent(ctx, event)

     

       215
       +
       		if err != nil {

     

       216
       +
       			t.Fatalf("Expected success with skipVerification=true, got error: %v", err)

     

       217
       +
       		}

     

       218
       +
       

     

       219
       +
       		// Verify community was indexed

     

       220
       +
       		_, getErr := repo.GetByDID(ctx, communityDID)

     

       221
       +
       		if getErr != nil {

     

       222
       +
       			t.Fatalf("Community should have been indexed: %v", getErr)

     

       223
       +
       		}

     

       224
       +
       	})

     

       225
       +
       }

     

       226
       +
       

     

       227
       +
       // TestExtractDomainFromHandle tests the domain extraction logic for various handle formats

     

       228
       +
       func TestExtractDomainFromHandle(t *testing.T) {

     

       229
       +
       	// This is an internal function test - we'll test it through the consumer

     

       230
       +
       	db := setupTestDB(t)

     

       231
       +
       	defer func() {

     

       232
       +
       		if err := db.Close(); err != nil {

     

       233
       +
       			t.Logf("Failed to close database: %v", err)

     

       234
       +
       		}

     

       235
       +
       	}()

     

       236
       +
       

     

       237
       +
       	repo := postgres.NewCommunityRepository(db)

     

       238
       +
       	ctx := context.Background()

     

       239
       +
       

     

       240
       +
       	testCases := []struct {

     

       241
       +
       		name          string

     

       242
       +
       		handle        string

     

       243
       +
       		hostedByDID   string

     

       244
       +
       		shouldSucceed bool

     

       245
       +
       	}{

     

       246
       +
       		{

     

       247
       +
       			name:          "DNS-style handle with subdomain",

     

       248
       +
       			handle:        "gaming.communities.coves.social",

     

       249
       +
       			hostedByDID:   "did:web:coves.social",

     

       250
       +
       			shouldSucceed: true,

     

       251
       +
       		},

     

       252
       +
       		{

     

       253
       +
       			name:          "Simple two-part domain",

     

       254
       +
       			handle:        "gaming.coves.social",

     

       255
       +
       			hostedByDID:   "did:web:coves.social",

     

       256
       +
       			shouldSucceed: true,

     

       257
       +
       		},

     

       258
       +
       		{

     

       259
       +
       			name:          "Multi-part subdomain",

     

       260
       +
       			handle:        "gaming.test.communities.example.com",

     

       261
       +
       			hostedByDID:   "did:web:example.com",

     

       262
       +
       			shouldSucceed: true,

     

       263
       +
       		},

     

       264
       +
       		{

     

       265
       +
       			name:          "Mismatched domain",

     

       266
       +
       			handle:        "gaming.communities.coves.social",

     

       267
       +
       			hostedByDID:   "did:web:example.com",

     

       268
       +
       			shouldSucceed: false,

     

       269
       +
       		},

     

       270
       +
       		// CRITICAL: Multi-part TLD tests (PR review feedback)

     

       271
       +
       		{

     

       272
       +
       			name:          "Multi-part TLD: .co.uk",

     

       273
       +
       			handle:        "gaming.communities.coves.co.uk",

     

       274
       +
       			hostedByDID:   "did:web:coves.co.uk",

     

       275
       +
       			shouldSucceed: true,

     

       276
       +
       		},

     

       277
       +
       		{

     

       278
       +
       			name:          "Multi-part TLD: .com.au",

     

       279
       +
       			handle:        "gaming.communities.example.com.au",

     

       280
       +
       			hostedByDID:   "did:web:example.com.au",

     

       281
       +
       			shouldSucceed: true,

     

       282
       +
       		},

     

       283
       +
       		{

     

       284
       +
       			name:          "Multi-part TLD: Reject incorrect .co.uk extraction",

     

       285
       +
       			handle:        "gaming.communities.coves.co.uk",

     

       286
       +
       			hostedByDID:   "did:web:co.uk", // Wrong! Should be coves.co.uk

     

       287
       +
       			shouldSucceed: false,

     

       288
       +
       		},

     

       289
       +
       		{

     

       290
       +
       			name:          "Multi-part TLD: .org.uk",

     

       291
       +
       			handle:        "gaming.communities.myinstance.org.uk",

     

       292
       +
       			hostedByDID:   "did:web:myinstance.org.uk",

     

       293
       +
       			shouldSucceed: true,

     

       294
       +
       		},

     

       295
       +
       		{

     

       296
       +
       			name:          "Multi-part TLD: .ac.uk",

     

       297
       +
       			handle:        "gaming.communities.university.ac.uk",

     

       298
       +
       			hostedByDID:   "did:web:university.ac.uk",

     

       299
       +
       			shouldSucceed: true,

     

       300
       +
       		},

     

       301
       +
       	}

     

       302
       +
       

     

       303
       +
       	for _, tc := range testCases {

     

       304
       +
       		t.Run(tc.name, func(t *testing.T) {

     

       305
       +
       			consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.social", false)

     

       306
       +
       

     

       307
       +
       			uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       308
       +
       			communityDID := generateTestDID(uniqueSuffix)

     

       309
       +
       

     

       310
       +
       			event := &jetstream.JetstreamEvent{

     

       311
       +
       				Did:    communityDID,

     

       312
       +
       				TimeUS: time.Now().UnixMicro(),

     

       313
       +
       				Kind:   "commit",

     

       314
       +
       				Commit: &jetstream.CommitEvent{

     

       315
       +
       					Rev:        "rev123",

     

       316
       +
       					Operation:  "create",

     

       317
       +
       					Collection: "social.coves.community.profile",

     

       318
       +
       					RKey:       "self",

     

       319
       +
       					CID:        "bafy123abc",

     

       320
       +
       					Record: map[string]interface{}{

     

       321
       +
       						"handle":      tc.handle,

     

       322
       +
       						"name":        "test",

     

       323
       +
       						"displayName": "Test",

     

       324
       +
       						"description": "Test",

     

       325
       +
       						"createdBy":   "did:plc:user123",

     

       326
       +
       						"hostedBy":    tc.hostedByDID,

     

       327
       +
       						"visibility":  "public",

     

       328
       +
       						"federation": map[string]interface{}{

     

       329
       +
       							"allowExternalDiscovery": true,

     

       330
       +
       						},

     

       331
       +
       						"memberCount":     0,

     

       332
       +
       						"subscriberCount": 0,

     

       333
       +
       						"createdAt":       time.Now().Format(time.RFC3339),

     

       334
       +
       					},

     

       335
       +
       				},

     

       336
       +
       			}

     

       337
       +
       

     

       338
       +
       			err := consumer.HandleEvent(ctx, event)

     

       339
       +
       			if tc.shouldSucceed && err != nil {

     

       340
       +
       				t.Errorf("Expected success for %s, got error: %v", tc.handle, err)

     

       341
       +
       			} else if !tc.shouldSucceed && err == nil {

     

       342
       +
       				t.Errorf("Expected failure for %s, got success", tc.handle)

     

       343
       +
       			}

     

       344
       +
       		})

     

       345
       +
       	}

     

       346
       +
       }

+4 -2

tests/integration/community_v2_validation_test.go

···

       19
        
       	}()

     

       20
        
       

     

       21
        
       	repo := postgres.NewCommunityRepository(db)

     

       22
       -
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       0
        
       
     

       23
        
       	ctx := context.Background()

     

       24
        
       

     

       25
        
       	t.Run("accepts V2 community with rkey=self", func(t *testing.T) {

     
···

       241
        
       	}()

     

       242
        
       

     

       243
        
       	repo := postgres.NewCommunityRepository(db)

     

       244
       -
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       0
        
       
     

       245
        
       	ctx := context.Background()

     

       246
        
       

     

       247
        
       	t.Run("indexes community with atProto handle", func(t *testing.T) {

···

       19
        
       	}()

     

       20
        
       

     

       21
        
       	repo := postgres.NewCommunityRepository(db)

     

       22
       +
       	// Skip verification in tests

     

       23
       +
       	consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.local", true)

     

       24
        
       	ctx := context.Background()

     

       25
        
       

     

       26
        
       	t.Run("accepts V2 community with rkey=self", func(t *testing.T) {

     
···

       242
        
       	}()

     

       243
        
       

     

       244
        
       	repo := postgres.NewCommunityRepository(db)

     

       245
       +
       	// Skip verification in tests

     

       246
       +
       	consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.local", true)

     

       247
        
       	ctx := context.Background()

     

       248
        
       

     

       249
        
       	t.Run("indexes community with atProto handle", func(t *testing.T) {

+6 -3

tests/integration/subscription_indexing_test.go

···

       23
        
       	defer cleanupTestDB(t, db)

     

       24
        
       

     

       25
        
       	repo := createTestCommunityRepo(t, db)

     

       26
       -
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       0
        
       
     

       27
        
       

     

       28
        
       	// Create a test community first (with unique DID)

     

       29
        
       	testDID := fmt.Sprintf("did:plc:test-community-%d", time.Now().UnixNano())

     
···

       246
        
       	defer cleanupTestDB(t, db)

     

       247
        
       

     

       248
        
       	repo := createTestCommunityRepo(t, db)

     

       249
       -
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       0
        
       
     

       250
        
       

     

       251
        
       	// Create test community (with unique DID)

     

       252
        
       	testDID := fmt.Sprintf("did:plc:test-unsub-%d", time.Now().UnixNano())

     
···

       360
        
       	defer cleanupTestDB(t, db)

     

       361
        
       

     

       362
        
       	repo := createTestCommunityRepo(t, db)

     

       363
       -
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       0
        
       
     

       364
        
       

     

       365
        
       	// Create test community (with unique DID)

     

       366
        
       	testDID := fmt.Sprintf("did:plc:test-subcount-%d", time.Now().UnixNano())

···

       23
        
       	defer cleanupTestDB(t, db)

     

       24
        
       

     

       25
        
       	repo := createTestCommunityRepo(t, db)

     

       26
       +
       	// Skip verification in tests

     

       27
       +
       	consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.local", true)

     

       28
        
       

     

       29
        
       	// Create a test community first (with unique DID)

     

       30
        
       	testDID := fmt.Sprintf("did:plc:test-community-%d", time.Now().UnixNano())

     
···

       247
        
       	defer cleanupTestDB(t, db)

     

       248
        
       

     

       249
        
       	repo := createTestCommunityRepo(t, db)

     

       250
       +
       	// Skip verification in tests

     

       251
       +
       	consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.local", true)

     

       252
        
       

     

       253
        
       	// Create test community (with unique DID)

     

       254
        
       	testDID := fmt.Sprintf("did:plc:test-unsub-%d", time.Now().UnixNano())

     
···

       362
        
       	defer cleanupTestDB(t, db)

     

       363
        
       

     

       364
        
       	repo := createTestCommunityRepo(t, db)

     

       365
       +
       	// Skip verification in tests

     

       366
       +
       	consumer := jetstream.NewCommunityEventConsumer(repo, "did:web:coves.local", true)

     

       367
        
       

     

       368
        
       	// Create test community (with unique DID)

     

       369
        
       	testDID := fmt.Sprintf("did:plc:test-subcount-%d", time.Now().UnixNano())