commit 78826e83cb36e107e8b62d4cac4451bb66ebca07 · bretton.dev/coves

+2 -1

cmd/server/main.go

···

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

     

       248
        
       	}

     

       249
        
       

     

       250
       -
       	communityEventConsumer := jetstream.NewCommunityEventConsumer(communityRepo, instanceDID, skipDIDWebVerification)

     

       0
        
       
     

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

     

       252
        
       

     

       253
        
       	go func() {

···

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

     

       248
        
       	}

     

       249
        
       

     

       250
       +
       	// Pass identity resolver to consumer for PLC handle resolution (source of truth)

     

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

     

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

     

       253
        
       

     

       254
        
       	go func() {

+8 -1

cmd/validate-lexicon/main.go

···

       435
        
       		// Post record types (removed - no longer exists in new structure)

     

       436
        
       

     

       437
        
       		// Actor definitions

     

       438
       -
       		"social.coves.actor.profile#geoLocation",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       439
        
       

     

       440
        
       		// Community definitions

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       441
        
       		"social.coves.community.rules#rule",

     

       442
        
       	}

     

       443

···

       435
        
       		// Post record types (removed - no longer exists in new structure)

     

       436
        
       

     

       437
        
       		// Actor definitions

     

       438
       +
       		"social.coves.actor.defs#profileView",

     

       439
       +
       		"social.coves.actor.defs#profileViewDetailed",

     

       440
       +
       		"social.coves.actor.defs#profileStats",

     

       441
       +
       		"social.coves.actor.defs#viewerState",

     

       442
        
       

     

       443
        
       		// Community definitions

     

       444
       +
       		"social.coves.community.defs#communityView",

     

       445
       +
       		"social.coves.community.defs#communityViewDetailed",

     

       446
       +
       		"social.coves.community.defs#communityStats",

     

       447
       +
       		"social.coves.community.defs#viewerState",

     

       448
        
       		"social.coves.community.rules#rule",

     

       449
        
       	}

     

       450

+65 -1

internal/atproto/jetstream/community_consumer.go

···

       1
        
       package jetstream

     

       2
        
       

     

       3
        
       import (

     

       0
        
       
     

       4
        
       	"Coves/internal/atproto/utils"

     

       5
        
       	"Coves/internal/core/communities"

     

       6
        
       	"context"

     
···

       19
        
       // CommunityEventConsumer consumes community-related events from Jetstream

     

       20
        
       type CommunityEventConsumer struct {

     

       21
        
       	repo             communities.Repository           // Repository for community operations

     

       0
        
       
     

       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

     
···

       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 {

     

       0
        
       
     

       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

     
···

       49
        
       

     

       50
        
       	return &CommunityEventConsumer{

     

       51
        
       		repo:             repo,

     

       0
        
       
     

       52
        
       		instanceDID:      instanceDID,

     

       53
        
       		skipVerification: skipVerification,

     

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

     
···

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

     

       130
        
       	}

     

       131
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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 {

     
···

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

     

       224
        
       	if err != nil {

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       226
        
       	}

     

       227
        
       

     

       228
        
       	// V2: Repository DID IS the community DID

     
···

       707
        
       	}

     

       708
        
       

     

       709
        
       	return &profile, nil

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       710
        
       }

     

       711
        
       

     

       712
        
       // extractContentVisibility extracts contentVisibility from subscription record with clamping

···

       1
        
       package jetstream

     

       2
        
       

     

       3
        
       import (

     

       4
       +
       	"Coves/internal/atproto/identity"

     

       5
        
       	"Coves/internal/atproto/utils"

     

       6
        
       	"Coves/internal/core/communities"

     

       7
        
       	"context"

     
···

       20
        
       // CommunityEventConsumer consumes community-related events from Jetstream

     

       21
        
       type CommunityEventConsumer struct {

     

       22
        
       	repo             communities.Repository           // Repository for community operations

     

       23
       +
       	identityResolver interface{ Resolve(context.Context, string) (*identity.Identity, error) } // For resolving handles from DIDs

     

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

     

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

     

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

     
···

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

     

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

     

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

     

       40
       +
       // identityResolver: Optional resolver for resolving handles from DIDs (can be nil for tests)

     

       41
       +
       func NewCommunityEventConsumer(repo communities.Repository, instanceDID string, skipVerification bool, identityResolver interface{ Resolve(context.Context, string) (*identity.Identity, error) }) *CommunityEventConsumer {

     

       42
        
       	// Create bounded LRU cache for DID document verification results

     

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

     

       44
        
       	// Each entry ~100 bytes → max ~100KB memory overhead

     
···

       52
        
       

     

       53
        
       	return &CommunityEventConsumer{

     

       54
        
       		repo:             repo,

     

       55
       +
       		identityResolver: identityResolver, // Optional - can be nil for tests

     

       56
        
       		instanceDID:      instanceDID,

     

       57
        
       		skipVerification: skipVerification,

     

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

     
···

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

     

       134
        
       	}

     

       135
        
       

     

       136
       +
       	// atProto Best Practice: Handles are NOT stored in records (they're mutable, resolved from DIDs)

     

       137
       +
       	// If handle is missing from record (new atProto-compliant records), resolve it from PLC/DID

     

       138
       +
       	if profile.Handle == "" {

     

       139
       +
       		if c.identityResolver != nil {

     

       140
       +
       			// Production: Resolve handle from PLC (source of truth)

     

       141
       +
       			// NO FALLBACK - if PLC is down, we fail and backfill later

     

       142
       +
       			// This prevents creating communities with incorrect handles in federated scenarios

     

       143
       +
       			identity, err := c.identityResolver.Resolve(ctx, did)

     

       144
       +
       			if err != nil {

     

       145
       +
       				return fmt.Errorf("failed to resolve handle from PLC for %s: %w (no fallback - will retry during backfill)", did, err)

     

       146
       +
       			}

     

       147
       +
       			profile.Handle = identity.Handle

     

       148
       +
       			log.Printf("✓ Resolved handle from PLC: %s (did=%s, method=%s)",

     

       149
       +
       				profile.Handle, did, identity.Method)

     

       150
       +
       		} else {

     

       151
       +
       			// Test mode only: construct deterministically when no resolver available

     

       152
       +
       			profile.Handle = constructHandleFromProfile(profile)

     

       153
       +
       			log.Printf("✓ Constructed handle (test mode): %s (name=%s, hostedBy=%s)",

     

       154
       +
       				profile.Handle, profile.Name, profile.HostedBy)

     

       155
       +
       		}

     

       156
       +
       	}

     

       157
       +
       

     

       158
        
       	// SECURITY: Verify hostedBy claim matches handle domain

     

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

     

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

     
···

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

     

       250
        
       	if err != nil {

     

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

     

       252
       +
       	}

     

       253
       +
       

     

       254
       +
       	// atProto Best Practice: Handles are NOT stored in records (they're mutable, resolved from DIDs)

     

       255
       +
       	// If handle is missing from record (new atProto-compliant records), resolve it from PLC/DID

     

       256
       +
       	if profile.Handle == "" {

     

       257
       +
       		if c.identityResolver != nil {

     

       258
       +
       			// Production: Resolve handle from PLC (source of truth)

     

       259
       +
       			// NO FALLBACK - if PLC is down, we fail and backfill later

     

       260
       +
       			// This prevents creating communities with incorrect handles in federated scenarios

     

       261
       +
       			identity, err := c.identityResolver.Resolve(ctx, did)

     

       262
       +
       			if err != nil {

     

       263
       +
       				return fmt.Errorf("failed to resolve handle from PLC for %s: %w (no fallback - will retry during backfill)", did, err)

     

       264
       +
       			}

     

       265
       +
       			profile.Handle = identity.Handle

     

       266
       +
       			log.Printf("✓ Resolved handle from PLC: %s (did=%s, method=%s)",

     

       267
       +
       				profile.Handle, did, identity.Method)

     

       268
       +
       		} else {

     

       269
       +
       			// Test mode only: construct deterministically when no resolver available

     

       270
       +
       			profile.Handle = constructHandleFromProfile(profile)

     

       271
       +
       			log.Printf("✓ Constructed handle (test mode): %s (name=%s, hostedBy=%s)",

     

       272
       +
       				profile.Handle, profile.Name, profile.HostedBy)

     

       273
       +
       		}

     

       274
        
       	}

     

       275
        
       

     

       276
        
       	// V2: Repository DID IS the community DID

     
···

       755
        
       	}

     

       756
        
       

     

       757
        
       	return &profile, nil

     

       758
       +
       }

     

       759
       +
       

     

       760
       +
       // constructHandleFromProfile constructs a deterministic handle from profile data

     

       761
       +
       // Format: {name}.community.{instanceDomain}

     

       762
       +
       // Example: gaming.community.coves.social

     

       763
       +
       // This is ONLY used in test mode (when identity resolver is nil)

     

       764
       +
       // Production MUST resolve handles from PLC (source of truth)

     

       765
       +
       // Returns empty string if hostedBy is not did:web format (caller will fail validation)

     

       766
       +
       func constructHandleFromProfile(profile *CommunityProfile) string {

     

       767
       +
       	if !strings.HasPrefix(profile.HostedBy, "did:web:") {

     

       768
       +
       		// hostedBy must be did:web format for handle construction

     

       769
       +
       		// Return empty to trigger validation error in repository

     

       770
       +
       		return ""

     

       771
       +
       	}

     

       772
       +
       	instanceDomain := strings.TrimPrefix(profile.HostedBy, "did:web:")

     

       773
       +
       	return fmt.Sprintf("%s.community.%s", profile.Name, instanceDomain)

     

       774
        
       }

     

       775
        
       

     

       776
        
       // extractContentVisibility extracts contentVisibility from subscription record with clamping

-33

internal/atproto/lexicon/social/coves/actor/block.json

···

       1
       -
       {

     

       2
       -
         "lexicon": 1,

     

       3
       -
         "id": "social.coves.actor.block",

     

       4
       -
         "defs": {

     

       5
       -
           "main": {

     

       6
       -
             "type": "record",

     

       7
       -
             "description": "A block relationship where one user blocks another",

     

       8
       -
             "key": "tid",

     

       9
       -
             "record": {

     

       10
       -
               "type": "object",

     

       11
       -
               "required": ["subject", "createdAt"],

     

       12
       -
               "properties": {

     

       13
       -
                 "subject": {

     

       14
       -
                   "type": "string",

     

       15
       -
                   "format": "did",

     

       16
       -
                   "description": "DID of the user being blocked"

     

       17
       -
                 },

     

       18
       -
                 "createdAt": {

     

       19
       -
                   "type": "string",

     

       20
       -
                   "format": "datetime",

     

       21
       -
                   "description": "When the block was created"

     

       22
       -
                 },

     

       23
       -
                 "reason": {

     

       24
       -
                   "type": "string",

     

       25
       -
                   "maxGraphemes": 300,

     

       26
       -
                   "maxLength": 3000,

     

       27
       -
                   "description": "Optional reason for blocking"

     

       28
       -
                 }

     

       29
       -
               }

     

       30
       -
             }

     

       31
       -
           }

     

       32
       -
         }

     

       33
       -
       }

-59

internal/atproto/lexicon/social/coves/actor/blockUser.json

···

       1
       -
       {

     

       2
       -
         "lexicon": 1,

     

       3
       -
         "id": "social.coves.actor.blockUser",

     

       4
       -
         "defs": {

     

       5
       -
           "main": {

     

       6
       -
             "type": "procedure",

     

       7
       -
             "description": "Block another user",

     

       8
       -
             "input": {

     

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

     

       10
       -
               "schema": {

     

       11
       -
                 "type": "object",

     

       12
       -
                 "required": ["subject"],

     

       13
       -
                 "properties": {

     

       14
       -
                   "subject": {

     

       15
       -
                     "type": "string",

     

       16
       -
                     "format": "did",

     

       17
       -
                     "description": "DID of the user to block"

     

       18
       -
                   },

     

       19
       -
                   "reason": {

     

       20
       -
                     "type": "string",

     

       21
       -
                     "maxGraphemes": 300,

     

       22
       -
                     "maxLength": 3000,

     

       23
       -
                     "description": "Optional reason for blocking"

     

       24
       -
                   }

     

       25
       -
                 }

     

       26
       -
               }

     

       27
       -
             },

     

       28
       -
             "output": {

     

       29
       -
               "encoding": "application/json",

     

       30
       -
               "schema": {

     

       31
       -
                 "type": "object",

     

       32
       -
                 "required": ["uri", "cid"],

     

       33
       -
                 "properties": {

     

       34
       -
                   "uri": {

     

       35
       -
                     "type": "string",

     

       36
       -
                     "format": "at-uri",

     

       37
       -
                     "description": "AT-URI of the created block record"

     

       38
       -
                   },

     

       39
       -
                   "cid": {

     

       40
       -
                     "type": "string",

     

       41
       -
                     "format": "cid",

     

       42
       -
                     "description": "CID of the created block record"

     

       43
       -
                   },

     

       44
       -
                   "existing": {

     

       45
       -
                     "type": "boolean",

     

       46
       -
                     "description": "True if user was already blocked"

     

       47
       -
                   }

     

       48
       -
                 }

     

       49
       -
               }

     

       50
       -
             },

     

       51
       -
             "errors": [

     

       52
       -
               {

     

       53
       -
                 "name": "SubjectNotFound",

     

       54
       -
                 "description": "Subject user not found"

     

       55
       -
               }

     

       56
       -
             ]

     

       57
       -
           }

     

       58
       -
         }

     

       59
       -
       }

+139

internal/atproto/lexicon/social/coves/actor/defs.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "social.coves.actor.defs",

     

       4
       +
         "defs": {

     

       5
       +
           "profileView": {

     

       6
       +
             "type": "object",

     

       7
       +
             "description": "Basic profile view with essential information",

     

       8
       +
             "required": ["did"],

     

       9
       +
             "properties": {

     

       10
       +
               "did": {

     

       11
       +
                 "type": "string",

     

       12
       +
                 "format": "did"

     

       13
       +
               },

     

       14
       +
               "handle": {

     

       15
       +
                 "type": "string",

     

       16
       +
                 "format": "handle",

     

       17
       +
                 "description": "Current handle resolved from DID"

     

       18
       +
               },

     

       19
       +
               "displayName": {

     

       20
       +
                 "type": "string",

     

       21
       +
                 "maxGraphemes": 64,

     

       22
       +
                 "maxLength": 640

     

       23
       +
               },

     

       24
       +
               "avatar": {

     

       25
       +
                 "type": "string",

     

       26
       +
                 "format": "uri",

     

       27
       +
                 "description": "URL to avatar image"

     

       28
       +
               }

     

       29
       +
             }

     

       30
       +
           },

     

       31
       +
           "profileViewDetailed": {

     

       32
       +
             "type": "object",

     

       33
       +
             "description": "Detailed profile view with stats and viewer state",

     

       34
       +
             "required": ["did"],

     

       35
       +
             "properties": {

     

       36
       +
               "did": {

     

       37
       +
                 "type": "string",

     

       38
       +
                 "format": "did"

     

       39
       +
               },

     

       40
       +
               "handle": {

     

       41
       +
                 "type": "string",

     

       42
       +
                 "format": "handle",

     

       43
       +
                 "description": "Current handle resolved from DID"

     

       44
       +
               },

     

       45
       +
               "displayName": {

     

       46
       +
                 "type": "string",

     

       47
       +
                 "maxGraphemes": 64,

     

       48
       +
                 "maxLength": 640

     

       49
       +
               },

     

       50
       +
               "bio": {

     

       51
       +
                 "type": "string",

     

       52
       +
                 "maxGraphemes": 256,

     

       53
       +
                 "maxLength": 2560

     

       54
       +
               },

     

       55
       +
               "bioFacets": {

     

       56
       +
                 "type": "array",

     

       57
       +
                 "description": "Rich text annotations for bio",

     

       58
       +
                 "items": {

     

       59
       +
                   "type": "ref",

     

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

     

       61
       +
                 }

     

       62
       +
               },

     

       63
       +
               "avatar": {

     

       64
       +
                 "type": "string",

     

       65
       +
                 "format": "uri",

     

       66
       +
                 "description": "URL to avatar image"

     

       67
       +
               },

     

       68
       +
               "banner": {

     

       69
       +
                 "type": "string",

     

       70
       +
                 "format": "uri",

     

       71
       +
                 "description": "URL to banner image"

     

       72
       +
               },

     

       73
       +
               "createdAt": {

     

       74
       +
                 "type": "string",

     

       75
       +
                 "format": "datetime"

     

       76
       +
               },

     

       77
       +
               "stats": {

     

       78
       +
                 "type": "ref",

     

       79
       +
                 "ref": "#profileStats",

     

       80
       +
                 "description": "Aggregated statistics"

     

       81
       +
               },

     

       82
       +
               "viewer": {

     

       83
       +
                 "type": "ref",

     

       84
       +
                 "ref": "#viewerState",

     

       85
       +
                 "description": "Viewer's relationship to this profile"

     

       86
       +
               }

     

       87
       +
             }

     

       88
       +
           },

     

       89
       +
           "profileStats": {

     

       90
       +
             "type": "object",

     

       91
       +
             "description": "Aggregated statistics for a user profile",

     

       92
       +
             "properties": {

     

       93
       +
               "postCount": {

     

       94
       +
                 "type": "integer",

     

       95
       +
                 "minimum": 0,

     

       96
       +
                 "description": "Total number of posts created"

     

       97
       +
               },

     

       98
       +
               "commentCount": {

     

       99
       +
                 "type": "integer",

     

       100
       +
                 "minimum": 0,

     

       101
       +
                 "description": "Total number of comments made"

     

       102
       +
               },

     

       103
       +
               "communityCount": {

     

       104
       +
                 "type": "integer",

     

       105
       +
                 "minimum": 0,

     

       106
       +
                 "description": "Number of communities subscribed to"

     

       107
       +
               },

     

       108
       +
               "reputation": {

     

       109
       +
                 "type": "integer",

     

       110
       +
                 "description": "Global reputation score"

     

       111
       +
               },

     

       112
       +
               "membershipCount": {

     

       113
       +
                 "type": "integer",

     

       114
       +
                 "minimum": 0,

     

       115
       +
                 "description": "Number of communities with membership status"

     

       116
       +
               }

     

       117
       +
             }

     

       118
       +
           },

     

       119
       +
           "viewerState": {

     

       120
       +
             "type": "object",

     

       121
       +
             "description": "The viewing user's relationship to this profile",

     

       122
       +
             "properties": {

     

       123
       +
               "blocked": {

     

       124
       +
                 "type": "boolean",

     

       125
       +
                 "description": "Whether the viewer has blocked this user"

     

       126
       +
               },

     

       127
       +
               "blockedBy": {

     

       128
       +
                 "type": "boolean",

     

       129
       +
                 "description": "Whether the viewer is blocked by this user"

     

       130
       +
               },

     

       131
       +
               "blockUri": {

     

       132
       +
                 "type": "string",

     

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

     

       134
       +
                 "description": "AT-URI of the block record if viewer blocked this user"

     

       135
       +
               }

     

       136
       +
             }

     

       137
       +
           }

     

       138
       +
         }

     

       139
       +
       }

+3 -76

internal/atproto/lexicon/social/coves/actor/getProfile.json

···

       19
        
             "output": {

     

       20
        
               "encoding": "application/json",

     

       21
        
               "schema": {

     

       22
       -
                 "type": "object",

     

       23
       -
                 "required": ["did", "profile"],

     

       24
       -
                 "properties": {

     

       25
       -
                   "did": {

     

       26
       -
                     "type": "string",

     

       27
       -
                     "format": "did"

     

       28
       -
                   },

     

       29
       -
                   "profile": {

     

       30
       -
                     "type": "ref",

     

       31
       -
                     "ref": "social.coves.actor.profile"

     

       32
       -
                   },

     

       33
       -
                   "stats": {

     

       34
       -
                     "type": "ref",

     

       35
       -
                     "ref": "#profileStats"

     

       36
       -
                   },

     

       37
       -
                   "viewer": {

     

       38
       -
                     "type": "ref",

     

       39
       -
                     "ref": "#viewerState",

     

       40
       -
                     "description": "Viewer's relationship to this profile"

     

       41
       -
                   }

     

       42
       -
                 }

     

       43
       -
               }

     

       44
       -
             }

     

       45
       -
           },

     

       46
       -
           "profileStats": {

     

       47
       -
             "type": "object",

     

       48
       -
             "description": "Aggregated statistics for a user profile",

     

       49
       -
             "required": ["postCount", "commentCount", "communityCount", "savedCount", "reputation"],

     

       50
       -
             "properties": {

     

       51
       -
               "postCount": {

     

       52
       -
                 "type": "integer",

     

       53
       -
                 "minimum": 0,

     

       54
       -
                 "description": "Total number of posts created"

     

       55
       -
               },

     

       56
       -
               "commentCount": {

     

       57
       -
                 "type": "integer",

     

       58
       -
                 "minimum": 0,

     

       59
       -
                 "description": "Total number of comments made"

     

       60
       -
               },

     

       61
       -
               "communityCount": {

     

       62
       -
                 "type": "integer",

     

       63
       -
                 "minimum": 0,

     

       64
       -
                 "description": "Number of communities subscribed to"

     

       65
       -
               },

     

       66
       -
               "savedCount": {

     

       67
       -
                 "type": "integer",

     

       68
       -
                 "minimum": 0,

     

       69
       -
                 "description": "Number of saved items"

     

       70
       -
               },

     

       71
       -
               "reputation": {

     

       72
       -
                 "type": "integer",

     

       73
       -
                 "description": "Global reputation score"

     

       74
       -
               },

     

       75
       -
               "membershipCount": {

     

       76
       -
                 "type": "integer",

     

       77
       -
                 "minimum": 0,

     

       78
       -
                 "description": "Number of communities with membership status"

     

       79
       -
               }

     

       80
       -
             }

     

       81
       -
           },

     

       82
       -
           "viewerState": {

     

       83
       -
             "type": "object",

     

       84
       -
             "description": "The viewing user's relationship to this profile",

     

       85
       -
             "properties": {

     

       86
       -
               "blocked": {

     

       87
       -
                 "type": "boolean",

     

       88
       -
                 "description": "Whether the viewer has blocked this user"

     

       89
       -
               },

     

       90
       -
               "blockedBy": {

     

       91
       -
                 "type": "boolean",

     

       92
       -
                 "description": "Whether the viewer is blocked by this user"

     

       93
       -
               },

     

       94
       -
               "blockUri": {

     

       95
       -
                 "type": "string",

     

       96
       -
                 "format": "at-uri",

     

       97
       -
                 "description": "AT-URI of the block record if viewer blocked this user"

     

       98
        
               }

     

       99
        
             }

     

       100
        
           }

···

       19
        
             "output": {

     

       20
        
               "encoding": "application/json",

     

       21
        
               "schema": {

     

       22
       +
                 "type": "ref",

     

       23
       +
                 "ref": "social.coves.actor.defs#profileViewDetailed",

     

       24
       +
                 "description": "Detailed profile view with stats and viewer state"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
               }

     

       26
        
             }

     

       27
        
           }

-85

internal/atproto/lexicon/social/coves/actor/getSaved.json

···

       1
       -
       {

     

       2
       -
         "lexicon": 1,

     

       3
       -
         "id": "social.coves.actor.getSaved",

     

       4
       -
         "defs": {

     

       5
       -
           "main": {

     

       6
       -
             "type": "query",

     

       7
       -
             "description": "Get all saved posts and comments for the authenticated user",

     

       8
       -
             "input": {

     

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

     

       10
       -
               "schema": {

     

       11
       -
                 "type": "object",

     

       12
       -
                 "properties": {

     

       13
       -
                   "limit": {

     

       14
       -
                     "type": "integer",

     

       15
       -
                     "minimum": 1,

     

       16
       -
                     "maximum": 100,

     

       17
       -
                     "default": 50,

     

       18
       -
                     "description": "Number of items to return"

     

       19
       -
                   },

     

       20
       -
                   "cursor": {

     

       21
       -
                     "type": "string",

     

       22
       -
                     "description": "Cursor for pagination"

     

       23
       -
                   },

     

       24
       -
                   "type": {

     

       25
       -
                     "type": "string",

     

       26
       -
                     "enum": ["post", "comment"],

     

       27
       -
                     "description": "Filter by content type (optional)"

     

       28
       -
                   }

     

       29
       -
                 }

     

       30
       -
               }

     

       31
       -
             },

     

       32
       -
             "output": {

     

       33
       -
               "encoding": "application/json",

     

       34
       -
               "schema": {

     

       35
       -
                 "type": "object",

     

       36
       -
                 "required": ["savedItems"],

     

       37
       -
                 "properties": {

     

       38
       -
                   "savedItems": {

     

       39
       -
                     "type": "array",

     

       40
       -
                     "description": "All saved items for the user",

     

       41
       -
                     "items": {

     

       42
       -
                       "type": "ref",

     

       43
       -
                       "ref": "#savedItemView"

     

       44
       -
                     }

     

       45
       -
                   },

     

       46
       -
                   "cursor": {

     

       47
       -
                     "type": "string",

     

       48
       -
                     "description": "Cursor for next page"

     

       49
       -
                   }

     

       50
       -
                 }

     

       51
       -
               }

     

       52
       -
             }

     

       53
       -
           },

     

       54
       -
           "savedItemView": {

     

       55
       -
             "type": "object",

     

       56
       -
             "required": ["uri", "subject", "type", "savedAt"],

     

       57
       -
             "properties": {

     

       58
       -
               "uri": {

     

       59
       -
                 "type": "string",

     

       60
       -
                 "format": "at-uri",

     

       61
       -
                 "description": "AT-URI of the saved record"

     

       62
       -
               },

     

       63
       -
               "subject": {

     

       64
       -
                 "type": "string",

     

       65
       -
                 "format": "at-uri",

     

       66
       -
                 "description": "AT-URI of the saved post or comment"

     

       67
       -
               },

     

       68
       -
               "type": {

     

       69
       -
                 "type": "string",

     

       70
       -
                 "enum": ["post", "comment"],

     

       71
       -
                 "description": "Type of content that was saved"

     

       72
       -
               },

     

       73
       -
               "savedAt": {

     

       74
       -
                 "type": "string",

     

       75
       -
                 "format": "datetime",

     

       76
       -
                 "description": "When the item was saved"

     

       77
       -
               },

     

       78
       -
               "note": {

     

       79
       -
                 "type": "string",

     

       80
       -
                 "description": "Optional note about why this was saved"

     

       81
       -
               }

     

       82
       -
             }

     

       83
       -
           }

     

       84
       -
         }

     

       85
       -
       }

-198

internal/atproto/lexicon/social/coves/actor/preferences.json

···

       1
       -
       {

     

       2
       -
         "lexicon": 1,

     

       3
       -
         "id": "social.coves.actor.preferences",

     

       4
       -
         "defs": {

     

       5
       -
           "main": {

     

       6
       -
             "type": "record",

     

       7
       -
             "description": "User preferences and settings",

     

       8
       -
             "key": "literal:self",

     

       9
       -
             "record": {

     

       10
       -
               "type": "object",

     

       11
       -
               "properties": {

     

       12
       -
                 "feedPreferences": {

     

       13
       -
                   "type": "ref",

     

       14
       -
                   "ref": "#feedPreferences"

     

       15
       -
                 },

     

       16
       -
                 "contentFiltering": {

     

       17
       -
                   "type": "ref",

     

       18
       -
                   "ref": "#contentFiltering"

     

       19
       -
                 },

     

       20
       -
                 "notificationSettings": {

     

       21
       -
                   "type": "ref",

     

       22
       -
                   "ref": "#notificationSettings"

     

       23
       -
                 },

     

       24
       -
                 "privacySettings": {

     

       25
       -
                   "type": "ref",

     

       26
       -
                   "ref": "#privacySettings"

     

       27
       -
                 },

     

       28
       -
                 "displayPreferences": {

     

       29
       -
                   "type": "ref",

     

       30
       -
                   "ref": "#displayPreferences"

     

       31
       -
                 }

     

       32
       -
               }

     

       33
       -
             }

     

       34
       -
           },

     

       35
       -
           "feedPreferences": {

     

       36
       -
             "type": "object",

     

       37
       -
             "description": "Feed and content preferences",

     

       38
       -
             "properties": {

     

       39
       -
               "defaultFeed": {

     

       40
       -
                 "type": "string",

     

       41
       -
                 "enum": ["home", "all"],

     

       42
       -
                 "default": "home"

     

       43
       -
               },

     

       44
       -
               "defaultSort": {

     

       45
       -
                 "type": "string",

     

       46
       -
                 "enum": ["hot", "new", "top"],

     

       47
       -
                 "default": "hot",

     

       48
       -
                 "description": "Default sort order for community feeds"

     

       49
       -
               },

     

       50
       -
               "showNSFW": {

     

       51
       -
                 "type": "boolean",

     

       52
       -
                 "default": false

     

       53
       -
               },

     

       54
       -
               "blurNSFW": {

     

       55
       -
                 "type": "boolean",

     

       56
       -
                 "default": true,

     

       57
       -
                 "description": "Blur NSFW content until clicked"

     

       58
       -
               },

     

       59
       -
               "autoplayVideos": {

     

       60
       -
                 "type": "boolean",

     

       61
       -
                 "default": false

     

       62
       -
               },

     

       63
       -
               "infiniteScroll": {

     

       64
       -
                 "type": "boolean",

     

       65
       -
                 "default": true

     

       66
       -
               }

     

       67
       -
             }

     

       68
       -
           },

     

       69
       -
           "contentFiltering": {

     

       70
       -
             "type": "object",

     

       71
       -
             "description": "Content filtering preferences",

     

       72
       -
             "properties": {

     

       73
       -
               "blockedTags": {

     

       74
       -
                 "type": "array",

     

       75
       -
                 "items": {

     

       76
       -
                   "type": "string"

     

       77
       -
                 },

     

       78
       -
                 "description": "Tags to filter out from feeds"

     

       79
       -
               },

     

       80
       -
               "blockedCommunities": {

     

       81
       -
                 "type": "array",

     

       82
       -
                 "items": {

     

       83
       -
                   "type": "string",

     

       84
       -
                   "format": "did"

     

       85
       -
                 },

     

       86
       -
                 "description": "Communities to filter out from /all feeds"

     

       87
       -
               },

     

       88
       -
               "mutedWords": {

     

       89
       -
                 "type": "array",

     

       90
       -
                 "items": {

     

       91
       -
                   "type": "string"

     

       92
       -
                 },

     

       93
       -
                 "description": "Words to filter out from content"

     

       94
       -
               },

     

       95
       -
               "languageFilter": {

     

       96
       -
                 "type": "array",

     

       97
       -
                 "items": {

     

       98
       -
                   "type": "string",

     

       99
       -
                   "format": "language"

     

       100
       -
                 },

     

       101
       -
                 "description": "Only show content in these languages"

     

       102
       -
               }

     

       103
       -
             }

     

       104
       -
           },

     

       105
       -
           "notificationSettings": {

     

       106
       -
             "type": "object",

     

       107
       -
             "description": "Notification preferences",

     

       108
       -
             "properties": {

     

       109
       -
               "postReplies": {

     

       110
       -
                 "type": "boolean",

     

       111
       -
                 "default": true

     

       112
       -
               },

     

       113
       -
               "commentReplies": {

     

       114
       -
                 "type": "boolean",

     

       115
       -
                 "default": true

     

       116
       -
               },

     

       117
       -
               "mentions": {

     

       118
       -
                 "type": "boolean",

     

       119
       -
                 "default": true

     

       120
       -
               },

     

       121
       -
               "upvotes": {

     

       122
       -
                 "type": "boolean",

     

       123
       -
                 "default": false

     

       124
       -
               },

     

       125
       -
               "newFollowers": {

     

       126
       -
                 "type": "boolean",

     

       127
       -
                 "default": true

     

       128
       -
               },

     

       129
       -
               "communityInvites": {

     

       130
       -
                 "type": "boolean",

     

       131
       -
                 "default": true

     

       132
       -
               },

     

       133
       -
               "moderatorNotifications": {

     

       134
       -
                 "type": "boolean",

     

       135
       -
                 "default": true,

     

       136
       -
                 "description": "Notifications for moderator actions in your communities"

     

       137
       -
               }

     

       138
       -
             }

     

       139
       -
           },

     

       140
       -
           "privacySettings": {

     

       141
       -
             "type": "object",

     

       142
       -
             "description": "Privacy preferences",

     

       143
       -
             "properties": {

     

       144
       -
               "profileVisibility": {

     

       145
       -
                 "type": "string",

     

       146
       -
                 "enum": ["public", "authenticated", "followers"],

     

       147
       -
                 "default": "public"

     

       148
       -
               },

     

       149
       -
               "showSubscriptions": {

     

       150
       -
                 "type": "boolean",

     

       151
       -
                 "default": true

     

       152
       -
               },

     

       153
       -
               "showSavedPosts": {

     

       154
       -
                 "type": "boolean",

     

       155
       -
                 "default": false

     

       156
       -
               },

     

       157
       -
               "showVoteHistory": {

     

       158
       -
                 "type": "boolean",

     

       159
       -
                 "default": false

     

       160
       -
               },

     

       161
       -
               "allowDMs": {

     

       162
       -
                 "type": "string",

     

       163
       -
                 "enum": ["everyone", "followers", "none"],

     

       164
       -
                 "default": "everyone"

     

       165
       -
               }

     

       166
       -
             }

     

       167
       -
           },

     

       168
       -
           "displayPreferences": {

     

       169
       -
             "type": "object",

     

       170
       -
             "description": "Display and UI preferences",

     

       171
       -
             "properties": {

     

       172
       -
               "theme": {

     

       173
       -
                 "type": "string",

     

       174
       -
                 "enum": ["light", "dark", "auto"],

     

       175
       -
                 "default": "auto"

     

       176
       -
               },

     

       177
       -
               "compactView": {

     

       178
       -
                 "type": "boolean",

     

       179
       -
                 "default": false

     

       180
       -
               },

     

       181
       -
               "showAvatars": {

     

       182
       -
                 "type": "boolean",

     

       183
       -
                 "default": true

     

       184
       -
               },

     

       185
       -
               "showThumbnails": {

     

       186
       -
                 "type": "boolean",

     

       187
       -
                 "default": true

     

       188
       -
               },

     

       189
       -
               "postsPerPage": {

     

       190
       -
                 "type": "integer",

     

       191
       -
                 "minimum": 10,

     

       192
       -
                 "maximum": 100,

     

       193
       -
                 "default": 25

     

       194
       -
               }

     

       195
       -
             }

     

       196
       -
           }

     

       197
       -
         }

     

       198
       -
       }

+1 -172

internal/atproto/lexicon/social/coves/actor/profile.json

···

       8
        
             "key": "literal:self",

     

       9
        
             "record": {

     

       10
        
               "type": "object",

     

       11
       -
               "required": ["handle", "createdAt"],

     

       12
        
               "properties": {

     

       13
       -
                 "handle": {

     

       14
       -
                   "type": "string",

     

       15
       -
                   "format": "handle",

     

       16
       -
                   "maxLength": 253,

     

       17
       -
                   "description": "User's handle"

     

       18
       -
                 },

     

       19
        
                 "displayName": {

     

       20
        
                   "type": "string",

     

       21
        
                   "maxGraphemes": 64,

     
···

       46
        
                   "accept": ["image/png", "image/jpeg", "image/webp"],

     

       47
        
                   "maxSize": 2000000

     

       48
        
                 },

     

       49
       -
                 "verified": {

     

       50
       -
                   "type": "boolean",

     

       51
       -
                   "default": false,

     

       52
       -
                   "description": "Whether the user has completed phone verification"

     

       53
       -
                 },

     

       54
       -
                 "verifiedAt": {

     

       55
       -
                   "type": "string",

     

       56
       -
                   "format": "datetime",

     

       57
       -
                   "description": "When the user was verified"

     

       58
       -
                 },

     

       59
       -
                 "verificationExpiresAt": {

     

       60
       -
                   "type": "string",

     

       61
       -
                   "format": "datetime",

     

       62
       -
                   "description": "When verification expires"

     

       63
       -
                 },

     

       64
       -
                 "federatedFrom": {

     

       65
       -
                   "type": "string",

     

       66
       -
                   "knownValues": ["bluesky", "lemmy", "mastodon", "coves"],

     

       67
       -
                   "description": "Platform user federated from"

     

       68
       -
                 },

     

       69
       -
                 "federatedIdentity": {

     

       70
       -
                   "type": "ref",

     

       71
       -
                   "ref": "#federatedIdentity",

     

       72
       -
                   "description": "Identity information from federated platform"

     

       73
       -
                 },

     

       74
       -
                 "location": {

     

       75
       -
                   "type": "ref",

     

       76
       -
                   "ref": "#geoLocation"

     

       77
       -
                 },

     

       78
        
                 "createdAt": {

     

       79
        
                   "type": "string",

     

       80
        
                   "format": "datetime"

     

       81
       -
                 },

     

       82
       -
                 "moderatedCommunities": {

     

       83
       -
                   "type": "array",

     

       84
       -
                   "description": "Communities the user currently moderates",

     

       85
       -
                   "items": {

     

       86
       -
                     "type": "string",

     

       87
       -
                     "format": "did"

     

       88
       -
                   }

     

       89
       -
                 },

     

       90
       -
                 "moderationHistory": {

     

       91
       -
                   "type": "array",

     

       92
       -
                   "description": "Historical record of all moderation roles",

     

       93
       -
                   "items": {

     

       94
       -
                     "type": "ref",

     

       95
       -
                     "ref": "#moderationRole"

     

       96
       -
                   }

     

       97
       -
                 },

     

       98
       -
                 "violations": {

     

       99
       -
                   "type": "array",

     

       100
       -
                   "description": "Record of rule violations across communities",

     

       101
       -
                   "items": {

     

       102
       -
                     "type": "ref",

     

       103
       -
                     "ref": "#violation"

     

       104
       -
                   }

     

       105
        
                 }

     

       106
       -
               }

     

       107
       -
             }

     

       108
       -
           },

     

       109
       -
           "moderationRole": {

     

       110
       -
             "type": "object",

     

       111
       -
             "required": ["communityDid", "role", "startedAt"],

     

       112
       -
             "properties": {

     

       113
       -
               "communityDid": {

     

       114
       -
                 "type": "string",

     

       115
       -
                 "format": "did",

     

       116
       -
                 "description": "Community where moderation role was held"

     

       117
       -
               },

     

       118
       -
               "role": {

     

       119
       -
                 "type": "string",

     

       120
       -
                 "knownValues": ["moderator", "admin"],

     

       121
       -
                 "description": "Type of moderation role"

     

       122
       -
               },

     

       123
       -
               "startedAt": {

     

       124
       -
                 "type": "string",

     

       125
       -
                 "format": "datetime",

     

       126
       -
                 "description": "When the role began"

     

       127
       -
               },

     

       128
       -
               "endedAt": {

     

       129
       -
                 "type": "string",

     

       130
       -
                 "format": "datetime",

     

       131
       -
                 "description": "When the role ended (null if current)"

     

       132
       -
               }

     

       133
       -
             }

     

       134
       -
           },

     

       135
       -
           "violation": {

     

       136
       -
             "type": "object",

     

       137
       -
             "required": ["communityDid", "ruleViolated", "timestamp", "severity"],

     

       138
       -
             "properties": {

     

       139
       -
               "communityDid": {

     

       140
       -
                 "type": "string",

     

       141
       -
                 "format": "did",

     

       142
       -
                 "description": "Community where violation occurred"

     

       143
       -
               },

     

       144
       -
               "ruleViolated": {

     

       145
       -
                 "type": "string",

     

       146
       -
                 "description": "Description of the rule that was violated"

     

       147
       -
               },

     

       148
       -
               "timestamp": {

     

       149
       -
                 "type": "string",

     

       150
       -
                 "format": "datetime",

     

       151
       -
                 "description": "When the violation occurred"

     

       152
       -
               },

     

       153
       -
               "severity": {

     

       154
       -
                 "type": "string",

     

       155
       -
                 "knownValues": ["minor", "moderate", "major", "severe"],

     

       156
       -
                 "description": "Severity level of the violation"

     

       157
       -
               },

     

       158
       -
               "resolution": {

     

       159
       -
                 "type": "string",

     

       160
       -
                 "description": "How the violation was resolved"

     

       161
       -
               },

     

       162
       -
               "postUri": {

     

       163
       -
                 "type": "string",

     

       164
       -
                 "format": "at-uri",

     

       165
       -
                 "description": "Optional reference to the violating content"

     

       166
       -
               }

     

       167
       -
             }

     

       168
       -
           },

     

       169
       -
           "federatedIdentity": {

     

       170
       -
             "type": "object",

     

       171
       -
             "description": "Verified identity from a federated platform",

     

       172
       -
             "required": ["did", "handle", "verifiedAt"],

     

       173
       -
             "properties": {

     

       174
       -
               "did": {

     

       175
       -
                 "type": "string",

     

       176
       -
                 "format": "did",

     

       177
       -
                 "description": "Original DID from the federated platform"

     

       178
       -
               },

     

       179
       -
               "handle": {

     

       180
       -
                 "type": "string",

     

       181
       -
                 "maxLength": 253,

     

       182
       -
                 "description": "Original handle from the federated platform"

     

       183
       -
               },

     

       184
       -
               "verifiedAt": {

     

       185
       -
                 "type": "string",

     

       186
       -
                 "format": "datetime",

     

       187
       -
                 "description": "When the federated identity was verified via OAuth"

     

       188
       -
               },

     

       189
       -
               "lastSyncedAt": {

     

       190
       -
                 "type": "string",

     

       191
       -
                 "format": "datetime",

     

       192
       -
                 "description": "Last time profile data was synced from the federated platform"

     

       193
       -
               },

     

       194
       -
               "homePDS": {

     

       195
       -
                 "type": "string",

     

       196
       -
                 "description": "Home PDS server URL for the federated account"

     

       197
       -
               }

     

       198
       -
             }

     

       199
       -
           },

     

       200
       -
           "geoLocation": {

     

       201
       -
             "type": "object",

     

       202
       -
             "description": "Geographic location information",

     

       203
       -
             "properties": {

     

       204
       -
               "country": {

     

       205
       -
                 "type": "string",

     

       206
       -
                 "maxLength": 2,

     

       207
       -
                 "description": "ISO 3166-1 alpha-2 country code"

     

       208
       -
               },

     

       209
       -
               "region": {

     

       210
       -
                 "type": "string",

     

       211
       -
                 "maxLength": 128,

     

       212
       -
                 "description": "State/province/region name"

     

       213
       -
               },

     

       214
       -
               "displayName": {

     

       215
       -
                 "type": "string",

     

       216
       -
                 "maxLength": 256,

     

       217
       -
                 "description": "Human-readable location name"

     

       218
        
               }

     

       219
        
             }

     

       220
        
           }

···

       8
        
             "key": "literal:self",

     

       9
        
             "record": {

     

       10
        
               "type": "object",

     

       11
       +
               "required": ["createdAt"],

     

       12
        
               "properties": {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
                 "displayName": {

     

       14
        
                   "type": "string",

     

       15
        
                   "maxGraphemes": 64,

     
···

       40
        
                   "accept": ["image/png", "image/jpeg", "image/webp"],

     

       41
        
                   "maxSize": 2000000

     

       42
        
                 },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       43
        
                 "createdAt": {

     

       44
        
                   "type": "string",

     

       45
        
                   "format": "datetime"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       46
        
                 }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       47
        
               }

     

       48
        
             }

     

       49
        
           }

-63

internal/atproto/lexicon/social/coves/actor/saveItem.json

···

       1
       -
       {

     

       2
       -
         "lexicon": 1,

     

       3
       -
         "id": "social.coves.actor.saveItem",

     

       4
       -
         "defs": {

     

       5
       -
           "main": {

     

       6
       -
             "type": "procedure",

     

       7
       -
             "description": "Save a post or comment",

     

       8
       -
             "input": {

     

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

     

       10
       -
               "schema": {

     

       11
       -
                 "type": "object",

     

       12
       -
                 "required": ["subject", "type"],

     

       13
       -
                 "properties": {

     

       14
       -
                   "subject": {

     

       15
       -
                     "type": "string",

     

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

     

       17
       -
                     "description": "AT-URI of the post or comment to save"

     

       18
       -
                   },

     

       19
       -
                   "type": {

     

       20
       -
                     "type": "string",

     

       21
       -
                     "enum": ["post", "comment"],

     

       22
       -
                     "description": "Type of content being saved"

     

       23
       -
                   },

     

       24
       -
                   "note": {

     

       25
       -
                     "type": "string",

     

       26
       -
                     "maxLength": 300,

     

       27
       -
                     "description": "Optional note about why this was saved"

     

       28
       -
                   }

     

       29
       -
                 }

     

       30
       -
               }

     

       31
       -
             },

     

       32
       -
             "output": {

     

       33
       -
               "encoding": "application/json",

     

       34
       -
               "schema": {

     

       35
       -
                 "type": "object",

     

       36
       -
                 "required": ["uri", "cid"],

     

       37
       -
                 "properties": {

     

       38
       -
                   "uri": {

     

       39
       -
                     "type": "string",

     

       40
       -
                     "format": "at-uri",

     

       41
       -
                     "description": "AT-URI of the created saved record"

     

       42
       -
                   },

     

       43
       -
                   "cid": {

     

       44
       -
                     "type": "string",

     

       45
       -
                     "format": "cid",

     

       46
       -
                     "description": "CID of the created saved record"

     

       47
       -
                   },

     

       48
       -
                   "existing": {

     

       49
       -
                     "type": "boolean",

     

       50
       -
                     "description": "True if item was already saved"

     

       51
       -
                   }

     

       52
       -
                 }

     

       53
       -
               }

     

       54
       -
             },

     

       55
       -
             "errors": [

     

       56
       -
               {

     

       57
       -
                 "name": "SubjectNotFound",

     

       58
       -
                 "description": "The post or comment to save was not found"

     

       59
       -
               }

     

       60
       -
             ]

     

       61
       -
           }

     

       62
       -
         }

     

       63
       -
       }

-37

internal/atproto/lexicon/social/coves/actor/saved.json

···

       1
       -
       {

     

       2
       -
         "lexicon": 1,

     

       3
       -
         "id": "social.coves.actor.saved",

     

       4
       -
         "defs": {

     

       5
       -
           "main": {

     

       6
       -
             "type": "record",

     

       7
       -
             "description": "A saved post or comment",

     

       8
       -
             "key": "tid",

     

       9
       -
             "record": {

     

       10
       -
               "type": "object",

     

       11
       -
               "required": ["subject", "type", "createdAt"],

     

       12
       -
               "properties": {

     

       13
       -
                 "subject": {

     

       14
       -
                   "type": "string",

     

       15
       -
                   "format": "at-uri",

     

       16
       -
                   "description": "AT-URI of the post or comment being saved"

     

       17
       -
                 },

     

       18
       -
                 "type": {

     

       19
       -
                   "type": "string",

     

       20
       -
                   "enum": ["post", "comment"],

     

       21
       -
                   "description": "Type of content being saved"

     

       22
       -
                 },

     

       23
       -
                 "createdAt": {

     

       24
       -
                   "type": "string",

     

       25
       -
                   "format": "datetime",

     

       26
       -
                   "description": "When the item was saved"

     

       27
       -
                 },

     

       28
       -
                 "note": {

     

       29
       -
                   "type": "string",

     

       30
       -
                   "maxLength": 300,

     

       31
       -
                   "description": "Optional note about why this was saved"

     

       32
       -
                 }

     

       33
       -
               }

     

       34
       -
             }

     

       35
       -
           }

     

       36
       -
         }

     

       37
       -
       }

-39

internal/atproto/lexicon/social/coves/actor/subscription.json

···

       1
       -
       {

     

       2
       -
         "lexicon": 1,

     

       3
       -
         "id": "social.coves.actor.subscription",

     

       4
       -
         "defs": {

     

       5
       -
           "main": {

     

       6
       -
             "type": "record",

     

       7
       -
             "description": "A subscription to a community",

     

       8
       -
             "key": "tid",

     

       9
       -
             "record": {

     

       10
       -
               "type": "object",

     

       11
       -
               "required": ["community", "createdAt"],

     

       12
       -
               "properties": {

     

       13
       -
                 "community": {

     

       14
       -
                   "type": "string",

     

       15
       -
                   "format": "at-identifier",

     

       16
       -
                   "description": "DID or handle of the community"

     

       17
       -
                 },

     

       18
       -
                 "createdAt": {

     

       19
       -
                   "type": "string",

     

       20
       -
                   "format": "datetime",

     

       21
       -
                   "description": "When the subscription started"

     

       22
       -
                 },

     

       23
       -
                 "endedAt": {

     

       24
       -
                   "type": "string",

     

       25
       -
                   "format": "datetime",

     

       26
       -
                   "description": "When the subscription ended (null if current)"

     

       27
       -
                 },

     

       28
       -
                 "contentVisibility": {

     

       29
       -
                   "type": "integer",

     

       30
       -
                   "minimum": 1,

     

       31
       -
                   "maximum": 5,

     

       32
       -
                   "default": 3,

     

       33
       -
                   "description": "Content visibility level (1=only best content, 5=all content)"

     

       34
       -
                 }

     

       35
       -
               }

     

       36
       -
             }

     

       37
       -
           }

     

       38
       -
         }

     

       39
       -
       }

-37

internal/atproto/lexicon/social/coves/actor/unblockUser.json

···

       1
       -
       {

     

       2
       -
         "lexicon": 1,

     

       3
       -
         "id": "social.coves.actor.unblockUser",

     

       4
       -
         "defs": {

     

       5
       -
           "main": {

     

       6
       -
             "type": "procedure",

     

       7
       -
             "description": "Unblock a previously blocked user",

     

       8
       -
             "input": {

     

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

     

       10
       -
               "schema": {

     

       11
       -
                 "type": "object",

     

       12
       -
                 "required": ["subject"],

     

       13
       -
                 "properties": {

     

       14
       -
                   "subject": {

     

       15
       -
                     "type": "string",

     

       16
       -
                     "format": "did",

     

       17
       -
                     "description": "DID of the user to unblock"

     

       18
       -
                   }

     

       19
       -
                 }

     

       20
       -
               }

     

       21
       -
             },

     

       22
       -
             "output": {

     

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

     

       24
       -
               "schema": {

     

       25
       -
                 "type": "object",

     

       26
       -
                 "properties": {}

     

       27
       -
               }

     

       28
       -
             },

     

       29
       -
             "errors": [

     

       30
       -
               {

     

       31
       -
                 "name": "NotBlocked",

     

       32
       -
                 "description": "User is not currently blocked"

     

       33
       -
               }

     

       34
       -
             ]

     

       35
       -
           }

     

       36
       -
         }

     

       37
       -
       }

-37

internal/atproto/lexicon/social/coves/actor/unsaveItem.json

···

       1
       -
       {

     

       2
       -
         "lexicon": 1,

     

       3
       -
         "id": "social.coves.actor.unsaveItem",

     

       4
       -
         "defs": {

     

       5
       -
           "main": {

     

       6
       -
             "type": "procedure",

     

       7
       -
             "description": "Unsave a previously saved post or comment",

     

       8
       -
             "input": {

     

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

     

       10
       -
               "schema": {

     

       11
       -
                 "type": "object",

     

       12
       -
                 "required": ["subject"],

     

       13
       -
                 "properties": {

     

       14
       -
                   "subject": {

     

       15
       -
                     "type": "string",

     

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

     

       17
       -
                     "description": "AT-URI of the post or comment to unsave"

     

       18
       -
                   }

     

       19
       -
                 }

     

       20
       -
               }

     

       21
       -
             },

     

       22
       -
             "output": {

     

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

     

       24
       -
               "schema": {

     

       25
       -
                 "type": "object",

     

       26
       -
                 "properties": {}

     

       27
       -
               }

     

       28
       -
             },

     

       29
       -
             "errors": [

     

       30
       -
               {

     

       31
       -
                 "name": "NotSaved",

     

       32
       -
                 "description": "Item is not currently saved"

     

       33
       -
               }

     

       34
       -
             ]

     

       35
       -
           }

     

       36
       -
         }

     

       37
       -
       }

-4

internal/atproto/lexicon/social/coves/actor/updateProfile.json

···

       39
        
                     "type": "blob",

     

       40
        
                     "accept": ["image/png", "image/jpeg", "image/webp"],

     

       41
        
                     "maxSize": 2000000

     

       42
       -
                   },

     

       43
       -
                   "location": {

     

       44
       -
                     "type": "ref",

     

       45
       -
                     "ref": "social.coves.actor.profile#geoLocation"

     

       46
        
                   }

     

       47
        
                 }

     

       48
        
               }

···

       39
        
                     "type": "blob",

     

       40
        
                     "accept": ["image/png", "image/jpeg", "image/webp"],

     

       41
        
                     "maxSize": 2000000

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       42
        
                   }

     

       43
        
                 }

     

       44
        
               }

+254

internal/atproto/lexicon/social/coves/community/defs.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "social.coves.community.defs",

     

       4
       +
         "defs": {

     

       5
       +
           "communityView": {

     

       6
       +
             "type": "object",

     

       7
       +
             "description": "Basic community view with essential information and basic stats",

     

       8
       +
             "required": ["did", "name"],

     

       9
       +
             "properties": {

     

       10
       +
               "did": {

     

       11
       +
                 "type": "string",

     

       12
       +
                 "format": "did",

     

       13
       +
                 "description": "DID of the community"

     

       14
       +
               },

     

       15
       +
               "handle": {

     

       16
       +
                 "type": "string",

     

       17
       +
                 "format": "handle",

     

       18
       +
                 "description": "Current handle resolved from DID"

     

       19
       +
               },

     

       20
       +
               "name": {

     

       21
       +
                 "type": "string",

     

       22
       +
                 "maxLength": 64,

     

       23
       +
                 "description": "Short community name"

     

       24
       +
               },

     

       25
       +
               "displayName": {

     

       26
       +
                 "type": "string",

     

       27
       +
                 "maxGraphemes": 128,

     

       28
       +
                 "maxLength": 1280,

     

       29
       +
                 "description": "Display name for the community"

     

       30
       +
               },

     

       31
       +
               "avatar": {

     

       32
       +
                 "type": "string",

     

       33
       +
                 "format": "uri",

     

       34
       +
                 "description": "URL to community avatar image"

     

       35
       +
               },

     

       36
       +
               "visibility": {

     

       37
       +
                 "type": "string",

     

       38
       +
                 "knownValues": ["public", "unlisted", "private"],

     

       39
       +
                 "description": "Community visibility level"

     

       40
       +
               },

     

       41
       +
               "subscriberCount": {

     

       42
       +
                 "type": "integer",

     

       43
       +
                 "minimum": 0,

     

       44
       +
                 "description": "Total number of subscribers"

     

       45
       +
               },

     

       46
       +
               "memberCount": {

     

       47
       +
                 "type": "integer",

     

       48
       +
                 "minimum": 0,

     

       49
       +
                 "description": "Number of users with formal membership status"

     

       50
       +
               },

     

       51
       +
               "postCount": {

     

       52
       +
                 "type": "integer",

     

       53
       +
                 "minimum": 0,

     

       54
       +
                 "description": "Total number of posts in the community"

     

       55
       +
               },

     

       56
       +
               "viewer": {

     

       57
       +
                 "type": "object",

     

       58
       +
                 "description": "Simplified viewer state for list views",

     

       59
       +
                 "properties": {

     

       60
       +
                   "subscribed": {

     

       61
       +
                     "type": "boolean",

     

       62
       +
                     "description": "Whether the viewer is subscribed"

     

       63
       +
                   },

     

       64
       +
                   "member": {

     

       65
       +
                     "type": "boolean",

     

       66
       +
                     "description": "Whether the viewer has membership status"

     

       67
       +
                   }

     

       68
       +
                 }

     

       69
       +
               }

     

       70
       +
             }

     

       71
       +
           },

     

       72
       +
           "communityViewDetailed": {

     

       73
       +
             "type": "object",

     

       74
       +
             "description": "Detailed community view with stats and viewer state",

     

       75
       +
             "required": ["did", "name"],

     

       76
       +
             "properties": {

     

       77
       +
               "did": {

     

       78
       +
                 "type": "string",

     

       79
       +
                 "format": "did",

     

       80
       +
                 "description": "DID of the community"

     

       81
       +
               },

     

       82
       +
               "handle": {

     

       83
       +
                 "type": "string",

     

       84
       +
                 "format": "handle",

     

       85
       +
                 "description": "Current handle resolved from DID"

     

       86
       +
               },

     

       87
       +
               "name": {

     

       88
       +
                 "type": "string",

     

       89
       +
                 "maxLength": 64,

     

       90
       +
                 "description": "Short community name"

     

       91
       +
               },

     

       92
       +
               "displayName": {

     

       93
       +
                 "type": "string",

     

       94
       +
                 "maxGraphemes": 128,

     

       95
       +
                 "maxLength": 1280,

     

       96
       +
                 "description": "Display name for the community"

     

       97
       +
               },

     

       98
       +
               "description": {

     

       99
       +
                 "type": "string",

     

       100
       +
                 "maxGraphemes": 1000,

     

       101
       +
                 "maxLength": 10000,

     

       102
       +
                 "description": "Community description with rich text support"

     

       103
       +
               },

     

       104
       +
               "descriptionFacets": {

     

       105
       +
                 "type": "array",

     

       106
       +
                 "description": "Rich text annotations for description",

     

       107
       +
                 "items": {

     

       108
       +
                   "type": "ref",

     

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

     

       110
       +
                 }

     

       111
       +
               },

     

       112
       +
               "avatar": {

     

       113
       +
                 "type": "string",

     

       114
       +
                 "format": "uri",

     

       115
       +
                 "description": "URL to community avatar image"

     

       116
       +
               },

     

       117
       +
               "banner": {

     

       118
       +
                 "type": "string",

     

       119
       +
                 "format": "uri",

     

       120
       +
                 "description": "URL to community banner image"

     

       121
       +
               },

     

       122
       +
               "createdBy": {

     

       123
       +
                 "type": "string",

     

       124
       +
                 "format": "did",

     

       125
       +
                 "description": "DID of the user who created this community"

     

       126
       +
               },

     

       127
       +
               "createdByProfile": {

     

       128
       +
                 "type": "ref",

     

       129
       +
                 "ref": "social.coves.actor.defs#profileView",

     

       130
       +
                 "description": "Profile of the community creator"

     

       131
       +
               },

     

       132
       +
               "hostedBy": {

     

       133
       +
                 "type": "string",

     

       134
       +
                 "format": "did",

     

       135
       +
                 "description": "DID of the instance hosting this community"

     

       136
       +
               },

     

       137
       +
               "visibility": {

     

       138
       +
                 "type": "string",

     

       139
       +
                 "knownValues": ["public", "unlisted", "private"],

     

       140
       +
                 "description": "Community visibility level"

     

       141
       +
               },

     

       142
       +
               "moderationType": {

     

       143
       +
                 "type": "string",

     

       144
       +
                 "knownValues": ["moderator", "sortition"],

     

       145
       +
                 "description": "Type of moderation system"

     

       146
       +
               },

     

       147
       +
               "contentWarnings": {

     

       148
       +
                 "type": "array",

     

       149
       +
                 "description": "Required content warnings for this community",

     

       150
       +
                 "items": {

     

       151
       +
                   "type": "string",

     

       152
       +
                   "knownValues": ["nsfw", "violence", "spoilers"],

     

       153
       +
                   "maxLength": 32

     

       154
       +
                 }

     

       155
       +
               },

     

       156
       +
               "createdAt": {

     

       157
       +
                 "type": "string",

     

       158
       +
                 "format": "datetime"

     

       159
       +
               },

     

       160
       +
               "stats": {

     

       161
       +
                 "type": "ref",

     

       162
       +
                 "ref": "#communityStats",

     

       163
       +
                 "description": "Aggregated community statistics"

     

       164
       +
               },

     

       165
       +
               "viewer": {

     

       166
       +
                 "type": "ref",

     

       167
       +
                 "ref": "#viewerState",

     

       168
       +
                 "description": "Viewer's relationship to this community"

     

       169
       +
               }

     

       170
       +
             }

     

       171
       +
           },

     

       172
       +
           "communityStats": {

     

       173
       +
             "type": "object",

     

       174
       +
             "description": "Aggregated statistics for a community",

     

       175
       +
             "properties": {

     

       176
       +
               "memberCount": {

     

       177
       +
                 "type": "integer",

     

       178
       +
                 "minimum": 0,

     

       179
       +
                 "description": "Number of users with formal membership status"

     

       180
       +
               },

     

       181
       +
               "subscriberCount": {

     

       182
       +
                 "type": "integer",

     

       183
       +
                 "minimum": 0,

     

       184
       +
                 "description": "Total number of subscribers"

     

       185
       +
               },

     

       186
       +
               "postCount": {

     

       187
       +
                 "type": "integer",

     

       188
       +
                 "minimum": 0,

     

       189
       +
                 "description": "Total number of posts in the community"

     

       190
       +
               },

     

       191
       +
               "commentCount": {

     

       192
       +
                 "type": "integer",

     

       193
       +
                 "minimum": 0,

     

       194
       +
                 "description": "Total number of comments across all posts"

     

       195
       +
               },

     

       196
       +
               "activeUserCount": {

     

       197
       +
                 "type": "integer",

     

       198
       +
                 "minimum": 0,

     

       199
       +
                 "description": "Number of users active in the last 30 days"

     

       200
       +
               },

     

       201
       +
               "activePostersCount": {

     

       202
       +
                 "type": "integer",

     

       203
       +
                 "minimum": 0,

     

       204
       +
                 "description": "Number of unique posters in the last 30 days"

     

       205
       +
               },

     

       206
       +
               "moderatorCount": {

     

       207
       +
                 "type": "integer",

     

       208
       +
                 "minimum": 0,

     

       209
       +
                 "description": "Number of active moderators"

     

       210
       +
               }

     

       211
       +
             }

     

       212
       +
           },

     

       213
       +
           "viewerState": {

     

       214
       +
             "type": "object",

     

       215
       +
             "description": "The viewing user's relationship to this community",

     

       216
       +
             "properties": {

     

       217
       +
               "subscribed": {

     

       218
       +
                 "type": "boolean",

     

       219
       +
                 "description": "Whether the viewer is subscribed to this community"

     

       220
       +
               },

     

       221
       +
               "subscriptionUri": {

     

       222
       +
                 "type": "string",

     

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

     

       224
       +
                 "description": "AT-URI of the viewer's subscription record if subscribed"

     

       225
       +
               },

     

       226
       +
               "member": {

     

       227
       +
                 "type": "boolean",

     

       228
       +
                 "description": "Whether the viewer has membership status (AppView-computed)"

     

       229
       +
               },

     

       230
       +
               "reputation": {

     

       231
       +
                 "type": "integer",

     

       232
       +
                 "description": "Viewer's reputation in this community"

     

       233
       +
               },

     

       234
       +
               "moderator": {

     

       235
       +
                 "type": "boolean",

     

       236
       +
                 "description": "Whether the viewer is a moderator of this community"

     

       237
       +
               },

     

       238
       +
               "creator": {

     

       239
       +
                 "type": "boolean",

     

       240
       +
                 "description": "Whether the viewer created this community"

     

       241
       +
               },

     

       242
       +
               "banned": {

     

       243
       +
                 "type": "boolean",

     

       244
       +
                 "description": "Whether the viewer is banned from this community"

     

       245
       +
               },

     

       246
       +
               "banUri": {

     

       247
       +
                 "type": "string",

     

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

     

       249
       +
                 "description": "AT-URI of the ban record if viewer is banned"

     

       250
       +
               }

     

       251
       +
             }

     

       252
       +
           }

     

       253
       +
         }

     

       254
       +
       }

+3 -83

internal/atproto/lexicon/social/coves/community/get.json

···

       19
        
             "output": {

     

       20
        
               "encoding": "application/json",

     

       21
        
               "schema": {

     

       22
       -
                 "type": "object",

     

       23
       -
                 "required": ["did", "profile"],

     

       24
       -
                 "properties": {

     

       25
       -
                   "did": {

     

       26
       -
                     "type": "string",

     

       27
       -
                     "format": "did"

     

       28
       -
                   },

     

       29
       -
                   "profile": {

     

       30
       -
                     "type": "ref",

     

       31
       -
                     "ref": "social.coves.community.profile"

     

       32
       -
                   },

     

       33
       -
                   "stats": {

     

       34
       -
                     "type": "ref",

     

       35
       -
                     "ref": "#communityStats"

     

       36
       -
                   },

     

       37
       -
                   "viewer": {

     

       38
       -
                     "type": "ref",

     

       39
       -
                     "ref": "#viewerState",

     

       40
       -
                     "description": "Viewer's relationship to this community"

     

       41
       -
                   }

     

       42
       -
                 }

     

       43
       -
               }

     

       44
       -
             }

     

       45
       -
           },

     

       46
       -
           "communityStats": {

     

       47
       -
             "type": "object",

     

       48
       -
             "required": ["subscriberCount", "memberCount", "postCount", "activePostersCount"],

     

       49
       -
             "properties": {

     

       50
       -
               "subscriberCount": {

     

       51
       -
                 "type": "integer",

     

       52
       -
                 "minimum": 0,

     

       53
       -
                 "description": "Number of users subscribed to this community"

     

       54
       -
               },

     

       55
       -
               "memberCount": {

     

       56
       -
                 "type": "integer",

     

       57
       -
                 "minimum": 0,

     

       58
       -
                 "description": "Number of users with membership status"

     

       59
       -
               },

     

       60
       -
               "postCount": {

     

       61
       -
                 "type": "integer",

     

       62
       -
                 "minimum": 0,

     

       63
       -
                 "description": "Total number of posts in this community"

     

       64
       -
               },

     

       65
       -
               "activePostersCount": {

     

       66
       -
                 "type": "integer",

     

       67
       -
                 "minimum": 0,

     

       68
       -
                 "description": "Number of unique posters in the last 30 days"

     

       69
       -
               },

     

       70
       -
               "moderatorCount": {

     

       71
       -
                 "type": "integer",

     

       72
       -
                 "minimum": 0,

     

       73
       -
                 "description": "Number of active moderators"

     

       74
       -
               }

     

       75
       -
             }

     

       76
       -
           },

     

       77
       -
           "viewerState": {

     

       78
       -
             "type": "object",

     

       79
       -
             "description": "The viewing user's relationship to this community",

     

       80
       -
             "properties": {

     

       81
       -
               "subscribed": {

     

       82
       -
                 "type": "boolean",

     

       83
       -
                 "description": "Whether the viewer is subscribed"

     

       84
       -
               },

     

       85
       -
               "subscriptionUri": {

     

       86
       -
                 "type": "string",

     

       87
       -
                 "format": "at-uri",

     

       88
       -
                 "description": "AT-URI of the subscription record if subscribed"

     

       89
       -
               },

     

       90
       -
               "member": {

     

       91
       -
                 "type": "boolean",

     

       92
       -
                 "description": "Whether the viewer has membership status (AppView-computed)"

     

       93
       -
               },

     

       94
       -
               "reputation": {

     

       95
       -
                 "type": "integer",

     

       96
       -
                 "description": "Viewer's reputation in this community"

     

       97
       -
               },

     

       98
       -
               "moderator": {

     

       99
       -
                 "type": "boolean",

     

       100
       -
                 "description": "Whether the viewer is a moderator"

     

       101
       -
               },

     

       102
       -
               "banned": {

     

       103
       -
                 "type": "boolean",

     

       104
       -
                 "description": "Whether the viewer is banned from this community"

     

       105
        
               }

     

       106
        
             }

     

       107
        
           }

···

       19
        
             "output": {

     

       20
        
               "encoding": "application/json",

     

       21
        
               "schema": {

     

       22
       +
                 "type": "ref",

     

       23
       +
                 "ref": "social.coves.community.defs#communityViewDetailed",

     

       24
       +
                 "description": "Detailed community view with stats and viewer state"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
               }

     

       26
        
             }

     

       27
        
           }

+1 -38

internal/atproto/lexicon/social/coves/community/list.json

···

       46
        
                     "type": "array",

     

       47
        
                     "items": {

     

       48
        
                       "type": "ref",

     

       49
       -
                       "ref": "#communityView"

     

       50
        
                     }

     

       51
        
                   },

     

       52
        
                   "cursor": {

     

       53
        
                     "type": "string"

     

       54
       -
                   }

     

       55
       -
                 }

     

       56
       -
               }

     

       57
       -
             }

     

       58
       -
           },

     

       59
       -
           "communityView": {

     

       60
       -
             "type": "object",

     

       61
       -
             "required": ["did", "profile", "subscriberCount", "postCount"],

     

       62
       -
             "properties": {

     

       63
       -
               "did": {

     

       64
       -
                 "type": "string",

     

       65
       -
                 "format": "did"

     

       66
       -
               },

     

       67
       -
               "profile": {

     

       68
       -
                 "type": "ref",

     

       69
       -
                 "ref": "social.coves.community.profile"

     

       70
       -
               },

     

       71
       -
               "subscriberCount": {

     

       72
       -
                 "type": "integer",

     

       73
       -
                 "minimum": 0

     

       74
       -
               },

     

       75
       -
               "memberCount": {

     

       76
       -
                 "type": "integer",

     

       77
       -
                 "minimum": 0

     

       78
       -
               },

     

       79
       -
               "postCount": {

     

       80
       -
                 "type": "integer",

     

       81
       -
                 "minimum": 0

     

       82
       -
               },

     

       83
       -
               "viewer": {

     

       84
       -
                 "type": "object",

     

       85
       -
                 "properties": {

     

       86
       -
                   "subscribed": {

     

       87
       -
                     "type": "boolean"

     

       88
       -
                   },

     

       89
       -
                   "member": {

     

       90
       -
                     "type": "boolean"

     

       91
        
                   }

     

       92
        
                 }

     

       93
        
               }

···

       46
        
                     "type": "array",

     

       47
        
                     "items": {

     

       48
        
                       "type": "ref",

     

       49
       +
                       "ref": "social.coves.community.defs#communityView"

     

       50
        
                     }

     

       51
        
                   },

     

       52
        
                   "cursor": {

     

       53
        
                     "type": "string"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       54
        
                   }

     

       55
        
                 }

     

       56
        
               }

+1 -96

internal/atproto/lexicon/social/coves/community/profile.json

···

       8
        
             "key": "literal:self",

     

       9
        
             "record": {

     

       10
        
               "type": "object",

     

       11
       -
               "required": ["handle", "name", "createdAt", "createdBy", "hostedBy"],

     

       12
        
               "properties": {

     

       13
       -
                 "handle": {

     

       14
       -
                   "type": "string",

     

       15
       -
                   "maxLength": 253,

     

       16
       -
                   "format": "handle",

     

       17
       -
                   "description": "atProto handle (e.g., gaming.community.coves.social) - DNS-resolvable name for this community"

     

       18
       -
                 },

     

       19
        
                 "name": {

     

       20
        
                   "type": "string",

     

       21
        
                   "maxLength": 64,

     
···

       68
        
                   "maxLength": 64,

     

       69
        
                   "description": "Community visibility level"

     

       70
        
                 },

     

       71
       -
                 "federation": {

     

       72
       -
                   "type": "ref",

     

       73
       -
                   "ref": "#federationConfig",

     

       74
       -
                   "description": "Federation and discovery configuration"

     

       75
       -
                 },

     

       76
       -
                 "contentRules": {

     

       77
       -
                   "type": "ref",

     

       78
       -
                   "ref": "#contentRules",

     

       79
       -
                   "description": "Content posting rules and restrictions for this community"

     

       80
       -
                 },

     

       81
        
                 "moderationType": {

     

       82
        
                   "type": "string",

     

       83
        
                   "knownValues": ["moderator", "sortition"],

     
···

       94
        
                     "maxLength": 32

     

       95
        
                   }

     

       96
        
                 },

     

       97
       -
                 "memberCount": {

     

       98
       -
                   "type": "integer",

     

       99
       -
                   "minimum": 0,

     

       100
       -
                   "description": "Cached count of community members"

     

       101
       -
                 },

     

       102
       -
                 "subscriberCount": {

     

       103
       -
                   "type": "integer",

     

       104
       -
                   "minimum": 0,

     

       105
       -
                   "description": "Cached count of community subscribers"

     

       106
       -
                 },

     

       107
       -
                 "federatedFrom": {

     

       108
       -
                   "type": "string",

     

       109
       -
                   "knownValues": ["lemmy", "coves"],

     

       110
       -
                   "description": "Platform community originated from"

     

       111
       -
                 },

     

       112
       -
                 "federatedId": {

     

       113
       -
                   "type": "string",

     

       114
       -
                   "description": "Original ID on federated platform"

     

       115
       -
                 },

     

       116
        
                 "createdAt": {

     

       117
        
                   "type": "string",

     

       118
        
                   "format": "datetime"

     

       119
        
                 }

     

       120
       -
               }

     

       121
       -
             }

     

       122
       -
           },

     

       123
       -
           "federationConfig": {

     

       124
       -
             "type": "object",

     

       125
       -
             "description": "Federation and discovery configuration for this community",

     

       126
       -
             "properties": {

     

       127
       -
               "allowExternalDiscovery": {

     

       128
       -
                 "type": "boolean",

     

       129
       -
                 "default": true,

     

       130
       -
                 "description": "Whether other Coves instances can index and discover this community"

     

       131
       -
               }

     

       132
       -
             }

     

       133
       -
           },

     

       134
       -
           "contentRules": {

     

       135
       -
             "type": "object",

     

       136
       -
             "description": "Content posting rules and restrictions for this community. Rules are validated at post creation time.",

     

       137
       -
             "properties": {

     

       138
       -
               "allowedEmbedTypes": {

     

       139
       -
                 "type": "array",

     

       140
       -
                 "description": "Allowed embed types. Empty array = no embeds allowed. Null/undefined = all embed types allowed.",

     

       141
       -
                 "items": {

     

       142
       -
                   "type": "string",

     

       143
       -
                   "knownValues": ["images", "video", "external", "record"]

     

       144
       -
                 }

     

       145
       -
               },

     

       146
       -
               "requireText": {

     

       147
       -
                 "type": "boolean",

     

       148
       -
                 "default": false,

     

       149
       -
                 "description": "Whether posts must have text content (non-empty content field)"

     

       150
       -
               },

     

       151
       -
               "minTextLength": {

     

       152
       -
                 "type": "integer",

     

       153
       -
                 "minimum": 0,

     

       154
       -
                 "description": "Minimum character length for post content (0 = no minimum)"

     

       155
       -
               },

     

       156
       -
               "maxTextLength": {

     

       157
       -
                 "type": "integer",

     

       158
       -
                 "minimum": 1,

     

       159
       -
                 "description": "Maximum character length for post content (overrides global limit if lower)"

     

       160
       -
               },

     

       161
       -
               "requireTitle": {

     

       162
       -
                 "type": "boolean",

     

       163
       -
                 "default": false,

     

       164
       -
                 "description": "Whether posts must have a title"

     

       165
       -
               },

     

       166
       -
               "minImages": {

     

       167
       -
                 "type": "integer",

     

       168
       -
                 "minimum": 0,

     

       169
       -
                 "description": "Minimum number of images required (0 = no minimum). Only enforced if images embed is present."

     

       170
       -
               },

     

       171
       -
               "maxImages": {

     

       172
       -
                 "type": "integer",

     

       173
       -
                 "minimum": 1,

     

       174
       -
                 "description": "Maximum number of images allowed per post (overrides global limit if lower)"

     

       175
       -
               },

     

       176
       -
               "allowFederated": {

     

       177
       -
                 "type": "boolean",

     

       178
       -
                 "default": true,

     

       179
       -
                 "description": "Whether federated posts (e.g., from app.bsky) are allowed in this community"

     

       180
        
               }

     

       181
        
             }

     

       182
        
           }

···

       8
        
             "key": "literal:self",

     

       9
        
             "record": {

     

       10
        
               "type": "object",

     

       11
       +
               "required": ["name", "createdAt", "createdBy", "hostedBy"],

     

       12
        
               "properties": {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
                 "name": {

     

       14
        
                   "type": "string",

     

       15
        
                   "maxLength": 64,

     
···

       62
        
                   "maxLength": 64,

     

       63
        
                   "description": "Community visibility level"

     

       64
        
                 },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       65
        
                 "moderationType": {

     

       66
        
                   "type": "string",

     

       67
        
                   "knownValues": ["moderator", "sortition"],

     
···

       78
        
                     "maxLength": 32

     

       79
        
                   }

     

       80
        
                 },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       81
        
                 "createdAt": {

     

       82
        
                   "type": "string",

     

       83
        
                   "format": "datetime"

     

       84
        
                 }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       85
        
               }

     

       86
        
             }

     

       87
        
           }

+1 -11

internal/core/communities/service.go

···

       131
        
       	// Build community profile record

     

       132
        
       	profile := map[string]interface{}{

     

       133
        
       		"$type":      "social.coves.community.profile",

     

       134
       -
       		"handle":     pdsAccount.Handle, // atProto handle (e.g., gaming.community.coves.social)

     

       135
       -
       		"name":       req.Name,          // Short name for !mentions (e.g., "gaming")

     

       136
        
       		"visibility": req.Visibility,

     

       137
        
       		"hostedBy":   s.instanceDID, // V2: Instance hosts, community owns

     

       138
        
       		"createdBy":  req.CreatedByDID,

     
···

       158
        
       	if req.Language != "" {

     

       159
        
       		profile["language"] = req.Language

     

       160
        
       	}

     

       161
       -
       

     

       162
       -
       	// Initialize counts

     

       163
       -
       	profile["memberCount"] = 0

     

       164
       -
       	profile["subscriberCount"] = 0

     

       165
        
       

     

       166
        
       	// TODO: Handle avatar and banner blobs

     

       167
        
       	// For now, we'll skip blob uploads. This would require:

     
···

       290
        
       	// Build updated profile record (start with existing)

     

       291
        
       	profile := map[string]interface{}{

     

       292
        
       		"$type":     "social.coves.community.profile",

     

       293
       -
       		"handle":    existing.Handle,

     

       294
        
       		"name":      existing.Name,

     

       295
        
       		"owner":     existing.OwnerDID,

     

       296
        
       		"createdBy": existing.CreatedByDID,

     
···

       340
        
       	} else if len(existing.ContentWarnings) > 0 {

     

       341
        
       		profile["contentWarnings"] = existing.ContentWarnings

     

       342
        
       	}

     

       343
       -
       

     

       344
       -
       	// Preserve counts

     

       345
       -
       	profile["memberCount"] = existing.MemberCount

     

       346
       -
       	profile["subscriberCount"] = existing.SubscriberCount

     

       347
        
       

     

       348
        
       	// V2: Community profiles always use "self" as rkey

     

       349
        
       	// (No need to extract from URI - it's always "self" for V2 communities)

···

       131
        
       	// Build community profile record

     

       132
        
       	profile := map[string]interface{}{

     

       133
        
       		"$type":      "social.coves.community.profile",

     

       134
       +
       		"name":       req.Name, // Short name for !mentions (e.g., "gaming")

     

       0
        
       
     

       135
        
       		"visibility": req.Visibility,

     

       136
        
       		"hostedBy":   s.instanceDID, // V2: Instance hosts, community owns

     

       137
        
       		"createdBy":  req.CreatedByDID,

     
···

       157
        
       	if req.Language != "" {

     

       158
        
       		profile["language"] = req.Language

     

       159
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       160
        
       

     

       161
        
       	// TODO: Handle avatar and banner blobs

     

       162
        
       	// For now, we'll skip blob uploads. This would require:

     
···

       285
        
       	// Build updated profile record (start with existing)

     

       286
        
       	profile := map[string]interface{}{

     

       287
        
       		"$type":     "social.coves.community.profile",

     

       0
        
       
     

       288
        
       		"name":      existing.Name,

     

       289
        
       		"owner":     existing.OwnerDID,

     

       290
        
       		"createdBy": existing.CreatedByDID,

     
···

       334
        
       	} else if len(existing.ContentWarnings) > 0 {

     

       335
        
       		profile["contentWarnings"] = existing.ContentWarnings

     

       336
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       337
        
       

     

       338
        
       	// V2: Community profiles always use "self" as rkey

     

       339
        
       	// (No need to extract from URI - it's always "self" for V2 communities)

+6 -1

internal/db/postgres/community_repo.go

···

       22
        
       

     

       23
        
       // Create inserts a new community into the communities table

     

       24
        
       func (r *postgresCommunityRepo) Create(ctx context.Context, community *communities.Community) (*communities.Community, error) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
       	query := `

     

       26
        
       		INSERT INTO communities (

     

       27
        
       			did, handle, name, display_name, description, description_facets,

     
···

       54
        
       

     

       55
        
       	err := r.db.QueryRowContext(ctx, query,

     

       56
        
       		community.DID,

     

       57
       -
       		community.Handle,

     

       58
        
       		community.Name,

     

       59
        
       		nullString(community.DisplayName),

     

       60
        
       		nullString(community.Description),

···

       22
        
       

     

       23
        
       // Create inserts a new community into the communities table

     

       24
        
       func (r *postgresCommunityRepo) Create(ctx context.Context, community *communities.Community) (*communities.Community, error) {

     

       25
       +
       	// Validate that handle is always provided (constructed by consumer)

     

       26
       +
       	if community.Handle == "" {

     

       27
       +
       		return nil, fmt.Errorf("handle is required (should be constructed by consumer before insert)")

     

       28
       +
       	}

     

       29
       +
       

     

       30
        
       	query := `

     

       31
        
       		INSERT INTO communities (

     

       32
        
       			did, handle, name, display_name, description, description_facets,

     
···

       59
        
       

     

       60
        
       	err := r.db.QueryRowContext(ctx, query,

     

       61
        
       		community.DID,

     

       62
       +
       		community.Handle, // Always non-empty - constructed by AppView consumer

     

       63
        
       		community.Name,

     

       64
        
       		nullString(community.DisplayName),

     

       65
        
       		nullString(community.Description),

+2 -1

tests/integration/community_blocking_test.go

···

       24
        
       

     

       25
        
       	repo := createBlockingTestCommunityRepo(t, db)

     

       26
        
       	// Skip verification in tests

     

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

     

       0
        
       
     

       28
        
       

     

       29
        
       	// Create test community

     

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

···

       24
        
       

     

       25
        
       	repo := createBlockingTestCommunityRepo(t, db)

     

       26
        
       	// Skip verification in tests

     

       27
       +
       	// Pass nil for identity resolver - not needed since consumer constructs handles from DIDs

     

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

     

       29
        
       

     

       30
        
       	// Create test community

     

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

+271 -24

tests/integration/community_consumer_test.go

···

       1
        
       package integration

     

       2
        
       

     

       3
        
       import (

     

       0
        
       
     

       4
        
       	"Coves/internal/atproto/jetstream"

     

       5
        
       	"Coves/internal/core/communities"

     

       6
        
       	"Coves/internal/db/postgres"

     

       7
        
       	"context"

     

       0
        
       
     

       8
        
       	"fmt"

     

       9
        
       	"testing"

     

       10
        
       	"time"

     
···

       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) {

     

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

     

       28
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       29
        
       

     

       30
        
       		// Simulate a Jetstream commit event

     

       31
        
       		event := &jetstream.JetstreamEvent{

     
···

       39
        
       				RKey:       "self",

     

       40
        
       				CID:        "bafy123abc",

     

       41
        
       				Record: map[string]interface{}{

     

       42
       -
       					"did":         communityDID, // Community's unique DID

     

       43
       -
       					"handle":      fmt.Sprintf("!test-community-%s@coves.local", uniqueSuffix),

     

       44
       -
       					"name":        "test-community",

     

       45
        
       					"displayName": "Test Community",

     

       46
        
       					"description": "A test community",

     

       47
        
       					"owner":       "did:web:coves.local",

     
···

       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
        
       		}

     
···

       83
        
       	t.Run("updates existing community", func(t *testing.T) {

     

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

     

       85
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       86
       -
       		handle := fmt.Sprintf("!update-test-%s@coves.local", uniqueSuffix)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       87
        
       

     

       88
        
       		// Create initial community

     

       89
        
       		initialCommunity := &communities.Community{

     

       90
        
       			DID:                    communityDID,

     

       91
       -
       			Handle:                 handle,

     

       92
       -
       			Name:                   "update-test",

     

       93
        
       			DisplayName:            "Original Name",

     

       94
        
       			Description:            "Original description",

     

       95
        
       			OwnerDID:               "did:web:coves.local",

     
···

       117
        
       				RKey:       "self",

     

       118
        
       				CID:        "bafy456def",

     

       119
        
       				Record: map[string]interface{}{

     

       120
       -
       					"did":         communityDID, // Community's unique DID

     

       121
       -
       					"handle":      handle,

     

       122
        
       					"name":        "update-test",

     

       123
        
       					"displayName": "Updated Name",

     

       124
        
       					"description": "Updated description",

     
···

       129
        
       					"federation": map[string]interface{}{

     

       130
        
       						"allowExternalDiscovery": false,

     

       131
        
       					},

     

       132
       -
       					"memberCount":     5,

     

       133
       -
       					"subscriberCount": 10,

     

       134
       -
       					"createdAt":       time.Now().Format(time.RFC3339),

     

       135
        
       				},

     

       136
        
       			},

     

       137
        
       		}

     
···

       164
        
       	t.Run("deletes community", func(t *testing.T) {

     

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

     

       166
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       167
        
       

     

       168
        
       		// Create community to delete

     

       169
        
       		community := &communities.Community{

     

       170
        
       			DID:          communityDID,

     

       171
       -
       			Handle:       fmt.Sprintf("!delete-test-%s@coves.local", uniqueSuffix),

     

       172
       -
       			Name:         "delete-test",

     

       173
        
       			OwnerDID:     "did:web:coves.local",

     

       174
        
       			CreatedByDID: "did:plc:user123",

     

       175
        
       			HostedByDID:  "did:web:coves.local",

     
···

       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) {

     

       224
        
       		// Create a community first

     

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

     

       226
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       227
        
       

     

       228
        
       		community := &communities.Community{

     

       229
        
       			DID:          communityDID,

     

       230
       -
       			Handle:       fmt.Sprintf("!sub-test-%s@coves.local", uniqueSuffix),

     

       231
       -
       			Name:         "sub-test",

     

       232
        
       			OwnerDID:     "did:web:coves.local",

     

       233
        
       			CreatedByDID: "did:plc:user123",

     

       234
        
       			HostedByDID:  "did:web:coves.local",

     
···

       301
        
       	}()

     

       302
        
       

     

       303
        
       	repo := postgres.NewCommunityRepository(db)

     

       304
       -
       	// Skip verification in tests

     

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

     

       0
        
       
     

       306
        
       	ctx := context.Background()

     

       307
        
       

     

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

     
···

       344
        
       		}

     

       345
        
       	})

     

       346
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       1
        
       package integration

     

       2
        
       

     

       3
        
       import (

     

       4
       +
       	"Coves/internal/atproto/identity"

     

       5
        
       	"Coves/internal/atproto/jetstream"

     

       6
        
       	"Coves/internal/core/communities"

     

       7
        
       	"Coves/internal/db/postgres"

     

       8
        
       	"context"

     

       9
       +
       	"errors"

     

       10
        
       	"fmt"

     

       11
        
       	"testing"

     

       12
        
       	"time"

     
···

       21
        
       	}()

     

       22
        
       

     

       23
        
       	repo := postgres.NewCommunityRepository(db)

     

       0
        
       
     

       0
        
       
     

       24
        
       	ctx := context.Background()

     

       25
        
       

     

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

     

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

     

       28
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       29
       +
       		communityName := fmt.Sprintf("test-community-%s", uniqueSuffix)

     

       30
       +
       		expectedHandle := fmt.Sprintf("%s.community.coves.local", communityName)

     

       31
       +
       

     

       32
       +
       		// Set up mock resolver for this test DID

     

       33
       +
       		mockResolver := newMockIdentityResolver()

     

       34
       +
       		mockResolver.resolutions[communityDID] = expectedHandle

     

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

     

       36
        
       

     

       37
        
       		// Simulate a Jetstream commit event

     

       38
        
       		event := &jetstream.JetstreamEvent{

     
···

       46
        
       				RKey:       "self",

     

       47
        
       				CID:        "bafy123abc",

     

       48
        
       				Record: map[string]interface{}{

     

       49
       +
       					// Note: No 'did', 'handle', 'memberCount', or 'subscriberCount' in record

     

       50
       +
       					// These are resolved/computed by AppView, not stored in immutable records

     

       51
       +
       					"name":        communityName,

     

       52
        
       					"displayName": "Test Community",

     

       53
        
       					"description": "A test community",

     

       54
        
       					"owner":       "did:web:coves.local",

     
···

       58
        
       					"federation": map[string]interface{}{

     

       59
        
       						"allowExternalDiscovery": true,

     

       60
        
       					},

     

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

     

       0
        
       
     

       0
        
       
     

       62
        
       				},

     

       63
        
       			},

     

       64
        
       		}

     
···

       88
        
       	t.Run("updates existing community", func(t *testing.T) {

     

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

     

       90
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       91
       +
       		communityName := "update-test"

     

       92
       +
       		expectedHandle := fmt.Sprintf("%s.community.coves.local", communityName)

     

       93
       +
       

     

       94
       +
       		// Set up mock resolver for this test DID

     

       95
       +
       		mockResolver := newMockIdentityResolver()

     

       96
       +
       		mockResolver.resolutions[communityDID] = expectedHandle

     

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

     

       98
        
       

     

       99
        
       		// Create initial community

     

       100
        
       		initialCommunity := &communities.Community{

     

       101
        
       			DID:                    communityDID,

     

       102
       +
       			Handle:                 expectedHandle,

     

       103
       +
       			Name:                   communityName,

     

       104
        
       			DisplayName:            "Original Name",

     

       105
        
       			Description:            "Original description",

     

       106
        
       			OwnerDID:               "did:web:coves.local",

     
···

       128
        
       				RKey:       "self",

     

       129
        
       				CID:        "bafy456def",

     

       130
        
       				Record: map[string]interface{}{

     

       131
       +
       					// Note: No 'did', 'handle', 'memberCount', or 'subscriberCount' in record

     

       132
       +
       					// These are resolved/computed by AppView, not stored in immutable records

     

       133
        
       					"name":        "update-test",

     

       134
        
       					"displayName": "Updated Name",

     

       135
        
       					"description": "Updated description",

     
···

       140
        
       					"federation": map[string]interface{}{

     

       141
        
       						"allowExternalDiscovery": false,

     

       142
        
       					},

     

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

     

       0
        
       
     

       0
        
       
     

       144
        
       				},

     

       145
        
       			},

     

       146
        
       		}

     
···

       173
        
       	t.Run("deletes community", func(t *testing.T) {

     

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

     

       175
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       176
       +
       		communityName := "delete-test"

     

       177
       +
       		expectedHandle := fmt.Sprintf("%s.community.coves.local", communityName)

     

       178
       +
       

     

       179
       +
       		// Set up mock resolver for this test DID

     

       180
       +
       		mockResolver := newMockIdentityResolver()

     

       181
       +
       		mockResolver.resolutions[communityDID] = expectedHandle

     

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

     

       183
        
       

     

       184
        
       		// Create community to delete

     

       185
        
       		community := &communities.Community{

     

       186
        
       			DID:          communityDID,

     

       187
       +
       			Handle:       expectedHandle,

     

       188
       +
       			Name:         communityName,

     

       189
        
       			OwnerDID:     "did:web:coves.local",

     

       190
        
       			CreatedByDID: "did:plc:user123",

     

       191
        
       			HostedByDID:  "did:web:coves.local",

     
···

       232
        
       	}()

     

       233
        
       

     

       234
        
       	repo := postgres.NewCommunityRepository(db)

     

       0
        
       
     

       0
        
       
     

       235
        
       	ctx := context.Background()

     

       236
        
       

     

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

     

       238
        
       		// Create a community first

     

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

     

       240
        
       		communityDID := generateTestDID(uniqueSuffix)

     

       241
       +
       		communityName := "sub-test"

     

       242
       +
       		expectedHandle := fmt.Sprintf("%s.community.coves.local", communityName)

     

       243
       +
       

     

       244
       +
       		// Set up mock resolver for this test DID

     

       245
       +
       		mockResolver := newMockIdentityResolver()

     

       246
       +
       		mockResolver.resolutions[communityDID] = expectedHandle

     

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

     

       248
        
       

     

       249
        
       		community := &communities.Community{

     

       250
        
       			DID:          communityDID,

     

       251
       +
       			Handle:       expectedHandle,

     

       252
       +
       			Name:         communityName,

     

       253
        
       			OwnerDID:     "did:web:coves.local",

     

       254
        
       			CreatedByDID: "did:plc:user123",

     

       255
        
       			HostedByDID:  "did:web:coves.local",

     
···

       322
        
       	}()

     

       323
        
       

     

       324
        
       	repo := postgres.NewCommunityRepository(db)

     

       325
       +
       	// Use mock resolver (though these tests don't create communities, so it won't be called)

     

       326
       +
       	mockResolver := newMockIdentityResolver()

     

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

     

       328
        
       	ctx := context.Background()

     

       329
        
       

     

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

     
···

       366
        
       		}

     

       367
        
       	})

     

       368
        
       }

     

       369
       +
       

     

       370
       +
       // mockIdentityResolver is a test double for identity resolution

     

       371
       +
       type mockIdentityResolver struct {

     

       372
       +
       	// Map of DID -> handle for successful resolutions

     

       373
       +
       	resolutions map[string]string

     

       374
       +
       	// If true, Resolve returns an error

     

       375
       +
       	shouldFail bool

     

       376
       +
       	// Track calls to verify invocation

     

       377
       +
       	callCount int

     

       378
       +
       	lastDID   string

     

       379
       +
       }

     

       380
       +
       

     

       381
       +
       func newMockIdentityResolver() *mockIdentityResolver {

     

       382
       +
       	return &mockIdentityResolver{

     

       383
       +
       		resolutions: make(map[string]string),

     

       384
       +
       	}

     

       385
       +
       }

     

       386
       +
       

     

       387
       +
       func (m *mockIdentityResolver) Resolve(ctx context.Context, did string) (*identity.Identity, error) {

     

       388
       +
       	m.callCount++

     

       389
       +
       	m.lastDID = did

     

       390
       +
       

     

       391
       +
       	if m.shouldFail {

     

       392
       +
       		return nil, errors.New("mock PLC resolution failure")

     

       393
       +
       	}

     

       394
       +
       

     

       395
       +
       	handle, ok := m.resolutions[did]

     

       396
       +
       	if !ok {

     

       397
       +
       		return nil, fmt.Errorf("no resolution configured for DID: %s", did)

     

       398
       +
       	}

     

       399
       +
       

     

       400
       +
       	return &identity.Identity{

     

       401
       +
       		DID:        did,

     

       402
       +
       		Handle:     handle,

     

       403
       +
       		PDSURL:     "https://pds.example.com",

     

       404
       +
       		ResolvedAt: time.Now(),

     

       405
       +
       		Method:     identity.MethodHTTPS,

     

       406
       +
       	}, nil

     

       407
       +
       }

     

       408
       +
       

     

       409
       +
       func TestCommunityConsumer_PLCHandleResolution(t *testing.T) {

     

       410
       +
       	db := setupTestDB(t)

     

       411
       +
       	defer func() {

     

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

     

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

     

       414
       +
       		}

     

       415
       +
       	}()

     

       416
       +
       

     

       417
       +
       	repo := postgres.NewCommunityRepository(db)

     

       418
       +
       	ctx := context.Background()

     

       419
       +
       

     

       420
       +
       	t.Run("resolves handle from PLC successfully", func(t *testing.T) {

     

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

     

       422
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       423
       +
       		communityName := fmt.Sprintf("test-plc-%s", uniqueSuffix)

     

       424
       +
       		expectedHandle := fmt.Sprintf("%s.community.coves.social", communityName)

     

       425
       +
       

     

       426
       +
       		// Create mock resolver

     

       427
       +
       		mockResolver := newMockIdentityResolver()

     

       428
       +
       		mockResolver.resolutions[communityDID] = expectedHandle

     

       429
       +
       

     

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

     

       431
       +
       

     

       432
       +
       		// Simulate Jetstream event without handle in record

     

       433
       +
       		event := &jetstream.JetstreamEvent{

     

       434
       +
       			Did:    communityDID,

     

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

     

       436
       +
       			Kind:   "commit",

     

       437
       +
       			Commit: &jetstream.CommitEvent{

     

       438
       +
       				Rev:        "rev123",

     

       439
       +
       				Operation:  "create",

     

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

     

       441
       +
       				RKey:       "self",

     

       442
       +
       				CID:        "bafy123abc",

     

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

     

       444
       +
       					// No handle field - should trigger PLC resolution

     

       445
       +
       					"name":        communityName,

     

       446
       +
       					"displayName": "Test PLC Community",

     

       447
       +
       					"description": "Testing PLC resolution",

     

       448
       +
       					"owner":       "did:web:coves.local",

     

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

     

       450
       +
       					"hostedBy":    "did:web:coves.local",

     

       451
       +
       					"visibility":  "public",

     

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

     

       453
       +
       						"allowExternalDiscovery": true,

     

       454
       +
       					},

     

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

     

       456
       +
       				},

     

       457
       +
       			},

     

       458
       +
       		}

     

       459
       +
       

     

       460
       +
       		// Handle the event

     

       461
       +
       		if err := consumer.HandleEvent(ctx, event); err != nil {

     

       462
       +
       			t.Fatalf("Failed to handle event: %v", err)

     

       463
       +
       		}

     

       464
       +
       

     

       465
       +
       		// Verify mock was called

     

       466
       +
       		if mockResolver.callCount != 1 {

     

       467
       +
       			t.Errorf("Expected 1 PLC resolution call, got %d", mockResolver.callCount)

     

       468
       +
       		}

     

       469
       +
       		if mockResolver.lastDID != communityDID {

     

       470
       +
       			t.Errorf("Expected PLC resolution for DID %s, got %s", communityDID, mockResolver.lastDID)

     

       471
       +
       		}

     

       472
       +
       

     

       473
       +
       		// Verify community was indexed with PLC-resolved handle

     

       474
       +
       		community, err := repo.GetByDID(ctx, communityDID)

     

       475
       +
       		if err != nil {

     

       476
       +
       			t.Fatalf("Failed to get indexed community: %v", err)

     

       477
       +
       		}

     

       478
       +
       

     

       479
       +
       		if community.Handle != expectedHandle {

     

       480
       +
       			t.Errorf("Expected handle %s from PLC, got %s", expectedHandle, community.Handle)

     

       481
       +
       		}

     

       482
       +
       	})

     

       483
       +
       

     

       484
       +
       	t.Run("fails when PLC resolution fails (no fallback)", func(t *testing.T) {

     

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

     

       486
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       487
       +
       		communityName := fmt.Sprintf("test-plc-fail-%s", uniqueSuffix)

     

       488
       +
       

     

       489
       +
       		// Create mock resolver that fails

     

       490
       +
       		mockResolver := newMockIdentityResolver()

     

       491
       +
       		mockResolver.shouldFail = true

     

       492
       +
       

     

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

     

       494
       +
       

     

       495
       +
       		// Simulate Jetstream event without handle in record

     

       496
       +
       		event := &jetstream.JetstreamEvent{

     

       497
       +
       			Did:    communityDID,

     

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

     

       499
       +
       			Kind:   "commit",

     

       500
       +
       			Commit: &jetstream.CommitEvent{

     

       501
       +
       				Rev:        "rev456",

     

       502
       +
       				Operation:  "create",

     

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

     

       504
       +
       				RKey:       "self",

     

       505
       +
       				CID:        "bafy456def",

     

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

     

       507
       +
       					"name":        communityName,

     

       508
       +
       					"displayName": "Test PLC Failure",

     

       509
       +
       					"description": "Testing PLC failure",

     

       510
       +
       					"owner":       "did:web:coves.local",

     

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

     

       512
       +
       					"hostedBy":    "did:web:coves.local",

     

       513
       +
       					"visibility":  "public",

     

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

     

       515
       +
       						"allowExternalDiscovery": true,

     

       516
       +
       					},

     

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

     

       518
       +
       				},

     

       519
       +
       			},

     

       520
       +
       		}

     

       521
       +
       

     

       522
       +
       		// Handle the event - should fail

     

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

     

       524
       +
       		if err == nil {

     

       525
       +
       			t.Fatal("Expected error when PLC resolution fails, got nil")

     

       526
       +
       		}

     

       527
       +
       

     

       528
       +
       		// Verify error message indicates PLC failure

     

       529
       +
       		expectedErrSubstring := "failed to resolve handle from PLC"

     

       530
       +
       		if !contains(err.Error(), expectedErrSubstring) {

     

       531
       +
       			t.Errorf("Expected error containing '%s', got: %v", expectedErrSubstring, err)

     

       532
       +
       		}

     

       533
       +
       

     

       534
       +
       		// Verify community was NOT indexed

     

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

     

       536
       +
       		if !communities.IsNotFound(err) {

     

       537
       +
       			t.Errorf("Expected community NOT to be indexed when PLC fails, but got: %v", err)

     

       538
       +
       		}

     

       539
       +
       

     

       540
       +
       		// Verify mock was called (failure happened during resolution, not before)

     

       541
       +
       		if mockResolver.callCount != 1 {

     

       542
       +
       			t.Errorf("Expected 1 PLC resolution attempt, got %d", mockResolver.callCount)

     

       543
       +
       		}

     

       544
       +
       	})

     

       545
       +
       

     

       546
       +
       	t.Run("test mode rejects invalid hostedBy format", func(t *testing.T) {

     

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

     

       548
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       549
       +
       		communityName := fmt.Sprintf("test-invalid-hosted-%s", uniqueSuffix)

     

       550
       +
       

     

       551
       +
       		// No identity resolver (test mode)

     

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

     

       553
       +
       

     

       554
       +
       		// Event with invalid hostedBy format (not did:web)

     

       555
       +
       		event := &jetstream.JetstreamEvent{

     

       556
       +
       			Did:    communityDID,

     

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

     

       558
       +
       			Kind:   "commit",

     

       559
       +
       			Commit: &jetstream.CommitEvent{

     

       560
       +
       				Rev:        "rev789",

     

       561
       +
       				Operation:  "create",

     

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

     

       563
       +
       				RKey:       "self",

     

       564
       +
       				CID:        "bafy789ghi",

     

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

     

       566
       +
       					"name":        communityName,

     

       567
       +
       					"displayName": "Test Invalid HostedBy",

     

       568
       +
       					"description": "Testing validation",

     

       569
       +
       					"owner":       "did:web:coves.local",

     

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

     

       571
       +
       					"hostedBy":    "did:plc:invalid", // Invalid format - not did:web

     

       572
       +
       					"visibility":  "public",

     

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

     

       574
       +
       						"allowExternalDiscovery": true,

     

       575
       +
       					},

     

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

     

       577
       +
       				},

     

       578
       +
       			},

     

       579
       +
       		}

     

       580
       +
       

     

       581
       +
       		// Handle the event - should fail due to empty handle

     

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

     

       583
       +
       		if err == nil {

     

       584
       +
       			t.Fatal("Expected error for invalid hostedBy format in test mode, got nil")

     

       585
       +
       		}

     

       586
       +
       

     

       587
       +
       		// Verify error is about handle being required

     

       588
       +
       		expectedErrSubstring := "handle is required"

     

       589
       +
       		if !contains(err.Error(), expectedErrSubstring) {

     

       590
       +
       			t.Errorf("Expected error containing '%s', got: %v", expectedErrSubstring, err)

     

       591
       +
       		}

     

       592
       +
       	})

     

       593
       +
       }

+9 -11

tests/integration/community_e2e_test.go

···

       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()

     
···

       259
        
       			t.Logf("   Record value:\n   %s", string(recordJSON))

     

       260
        
       		}

     

       261
        
       

     

       262
       -
       		// V2: DID is NOT in the record - it's in the repository URI

     

       263
       -
       		// The record should have handle, name, etc. but no 'did' field

     

       264
       -
       		// This matches Bluesky's app.bsky.actor.profile pattern

     

       265
       -
       		if pdsRecord.Value["handle"] != community.Handle {

     

       266
       -
       			t.Errorf("Community handle mismatch in PDS record: expected %s, got %v",

     

       267
       -
       				community.Handle, pdsRecord.Value["handle"])

     

       268
       -
       		}

     

       269
        
       

     

       270
        
       		// ====================================================================================

     

       271
        
       		// Part 2: TRUE E2E - Real Jetstream Firehose Consumer

     
···

       437
        
       					Collection: "social.coves.community.profile",

     

       438
        
       					RKey:       rkey,

     

       439
        
       					Record: map[string]interface{}{

     

       440
       -
       						"did":         createResp.DID,    // Community's DID from response

     

       441
       -
       						"handle":      createResp.Handle, // Community's handle from response

     

       442
        
       						"name":        createReq["name"],

     

       443
        
       						"displayName": createReq["displayName"],

     

       444
        
       						"description": createReq["description"],

     

       445
        
       						"visibility":  createReq["visibility"],

     

       446
        
       						// Server-side derives these from JWT auth (instanceDID is the authenticated user)

     

       0
        
       
     

       447
        
       						"createdBy": instanceDID,

     

       448
        
       						"hostedBy":  instanceDID,

     

       449
        
       						"federation": map[string]interface{}{

···

       142
        
       		svc.SetPDSAccessToken(accessToken)

     

       143
        
       	}

     

       144
        
       

     

       145
       +
       	// Use real identity resolver with local PLC for production-like testing

     

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

     

       147
        
       

     

       148
        
       	// Setup HTTP server with XRPC routes

     

       149
        
       	r := chi.NewRouter()

     
···

       259
        
       			t.Logf("   Record value:\n   %s", string(recordJSON))

     

       260
        
       		}

     

       261
        
       

     

       262
       +
       		// V2: DID and Handle are NOT in the record - they're resolved from the repository URI

     

       263
       +
       		// The record should have name, hostedBy, createdBy, etc. but no 'did' or 'handle' fields

     

       264
       +
       		// This matches Bluesky's app.bsky.actor.profile pattern (no handle in record)

     

       265
       +
       		// Handles are mutable and resolved from DIDs via PLC, so they shouldn't be stored in immutable records

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       266
        
       

     

       267
        
       		// ====================================================================================

     

       268
        
       		// Part 2: TRUE E2E - Real Jetstream Firehose Consumer

     
···

       434
        
       					Collection: "social.coves.community.profile",

     

       435
        
       					RKey:       rkey,

     

       436
        
       					Record: map[string]interface{}{

     

       437
       +
       						// Note: No 'did' or 'handle' in record (atProto best practice)

     

       438
       +
       						// These are mutable and resolved from DIDs, not stored in immutable records

     

       439
        
       						"name":        createReq["name"],

     

       440
        
       						"displayName": createReq["displayName"],

     

       441
        
       						"description": createReq["description"],

     

       442
        
       						"visibility":  createReq["visibility"],

     

       443
        
       						// Server-side derives these from JWT auth (instanceDID is the authenticated user)

     

       444
       +
       						"owner":     instanceDID,

     

       445
        
       						"createdBy": instanceDID,

     

       446
        
       						"hostedBy":  instanceDID,

     

       447
        
       						"federation": map[string]interface{}{

+10 -5

tests/integration/community_hostedby_security_test.go

···

       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)

     

       0
        
       
     

       27
        
       

     

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

     

       29
        
       		communityDID := generateTestDID(uniqueSuffix)

     
···

       81
        
       

     

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

     

       83
        
       		// Create consumer with verification enabled

     

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

     

       0
        
       
     

       85
        
       

     

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

     

       87
        
       		communityDID := generateTestDID(uniqueSuffix)

     
···

       134
        
       

     

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

     

       136
        
       		// Create consumer with verification enabled

     

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

     

       0
        
       
     

       138
        
       

     

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

     

       140
        
       		communityDID := generateTestDID(uniqueSuffix)

     
···

       179
        
       

     

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

     

       181
        
       		// Create consumer with verification DISABLED

     

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

     

       0
        
       
     

       183
        
       

     

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

     

       185
        
       		communityDID := generateTestDID(uniqueSuffix)

     
···

       306
        
       

     

       307
        
       	for _, tc := range testCases {

     

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

     

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

     

       0
        
       
     

       310
        
       

     

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

     

       312
        
       			communityDID := generateTestDID(uniqueSuffix)

···

       23
        
       

     

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

     

       25
        
       		// Create consumer with verification enabled

     

       26
       +
       		// Pass nil for identity resolver - not needed since consumer constructs handles from DIDs

     

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

     

       28
        
       

     

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

     

       30
        
       		communityDID := generateTestDID(uniqueSuffix)

     
···

       82
        
       

     

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

     

       84
        
       		// Create consumer with verification enabled

     

       85
       +
       		// Pass nil for identity resolver - not needed since consumer constructs handles from DIDs

     

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

     

       87
        
       

     

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

     

       89
        
       		communityDID := generateTestDID(uniqueSuffix)

     
···

       136
        
       

     

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

     

       138
        
       		// Create consumer with verification enabled

     

       139
       +
       		// Pass nil for identity resolver - not needed since consumer constructs handles from DIDs

     

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

     

       141
        
       

     

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

     

       143
        
       		communityDID := generateTestDID(uniqueSuffix)

     
···

       182
        
       

     

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

     

       184
        
       		// Create consumer with verification DISABLED

     

       185
       +
       		// Pass nil for identity resolver - not needed since consumer constructs handles from DIDs

     

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

     

       187
        
       

     

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

     

       189
        
       		communityDID := generateTestDID(uniqueSuffix)

     
···

       310
        
       

     

       311
        
       	for _, tc := range testCases {

     

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

     

       313
       +
       			// Pass nil for identity resolver - not needed since consumer constructs handles from DIDs

     

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

     

       315
        
       

     

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

     

       317
        
       			communityDID := generateTestDID(uniqueSuffix)

+4 -2

tests/integration/community_v2_validation_test.go

···

       21
        
       

     

       22
        
       	repo := postgres.NewCommunityRepository(db)

     

       23
        
       	// Skip verification in tests

     

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

     

       0
        
       
     

       25
        
       	ctx := context.Background()

     

       26
        
       

     

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

     
···

       249
        
       

     

       250
        
       	repo := postgres.NewCommunityRepository(db)

     

       251
        
       	// Skip verification in tests

     

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

     

       0
        
       
     

       253
        
       	ctx := context.Background()

     

       254
        
       

     

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

···

       21
        
       

     

       22
        
       	repo := postgres.NewCommunityRepository(db)

     

       23
        
       	// Skip verification in tests

     

       24
       +
       	// Pass nil for identity resolver - not needed since consumer constructs handles from DIDs

     

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

     

       26
        
       	ctx := context.Background()

     

       27
        
       

     

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

     
···

       250
        
       

     

       251
        
       	repo := postgres.NewCommunityRepository(db)

     

       252
        
       	// Skip verification in tests

     

       253
       +
       	// Pass nil for identity resolver - not needed since consumer constructs handles from DIDs

     

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

     

       255
        
       	ctx := context.Background()

     

       256
        
       

     

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

+6 -3

tests/integration/subscription_indexing_test.go

···

       25
        
       

     

       26
        
       	repo := createTestCommunityRepo(t, db)

     

       27
        
       	// Skip verification in tests

     

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

     

       0
        
       
     

       29
        
       

     

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

     

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

     
···

       249
        
       

     

       250
        
       	repo := createTestCommunityRepo(t, db)

     

       251
        
       	// Skip verification in tests

     

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

     

       0
        
       
     

       253
        
       

     

       254
        
       	// Create test community (with unique DID)

     

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

     
···

       364
        
       

     

       365
        
       	repo := createTestCommunityRepo(t, db)

     

       366
        
       	// Skip verification in tests

     

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

     

       0
        
       
     

       368
        
       

     

       369
        
       	// Create test community (with unique DID)

     

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

···

       25
        
       

     

       26
        
       	repo := createTestCommunityRepo(t, db)

     

       27
        
       	// Skip verification in tests

     

       28
       +
       	// Pass nil for identity resolver - not needed since consumer constructs handles from DIDs

     

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

     

       30
        
       

     

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

     

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

     
···

       250
        
       

     

       251
        
       	repo := createTestCommunityRepo(t, db)

     

       252
        
       	// Skip verification in tests

     

       253
       +
       	// Pass nil for identity resolver - not needed since consumer constructs handles from DIDs

     

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

     

       255
        
       

     

       256
        
       	// Create test community (with unique DID)

     

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

     
···

       366
        
       

     

       367
        
       	repo := createTestCommunityRepo(t, db)

     

       368
        
       	// Skip verification in tests

     

       369
       +
       	// Pass nil for identity resolver - not needed since consumer constructs handles from DIDs

     

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

     

       371
        
       

     

       372
        
       	// Create test community (with unique DID)

     

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

+12

tests/integration/user_test.go

···

       70
        
       	return db

     

       71
        
       }

     

       72
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       73
        
       // generateTestDID generates a unique test DID for integration tests

     

       74
        
       // V2.0: No longer uses DID generator - just creates valid did:plc strings

     

       75
        
       func generateTestDID(suffix string) string {

···

       70
        
       	return db

     

       71
        
       }

     

       72
        
       

     

       73
       +
       // setupIdentityResolver creates an identity resolver configured for local PLC testing

     

       74
       +
       func setupIdentityResolver(db *sql.DB) interface{ Resolve(context.Context, string) (*identity.Identity, error) } {

     

       75
       +
       	plcURL := os.Getenv("PLC_DIRECTORY_URL")

     

       76
       +
       	if plcURL == "" {

     

       77
       +
       		plcURL = "http://localhost:3002" // Local PLC directory

     

       78
       +
       	}

     

       79
       +
       

     

       80
       +
       	config := identity.DefaultConfig()

     

       81
       +
       	config.PLCURL = plcURL

     

       82
       +
       	return identity.NewResolver(db, config)

     

       83
       +
       }

     

       84
       +
       

     

       85
        
       // generateTestDID generates a unique test DID for integration tests

     

       86
        
       // V2.0: No longer uses DID generator - just creates valid did:plc strings

     

       87
        
       func generateTestDID(suffix string) string {

-5

tests/lexicon-test-data/actor/block-invalid-did.json

···

       1
       -
       {

     

       2
       -
         "$type": "social.coves.actor.block",

     

       3
       -
         "subject": "not-a-valid-did",

     

       4
       -
         "createdAt": "2025-01-05T09:15:00Z"

     

       5
       -
       }

-6

tests/lexicon-test-data/actor/block-valid.json

···

       1
       -
       {

     

       2
       -
         "$type": "social.coves.actor.block",

     

       3
       -
         "subject": "did:plc:blockeduser123",

     

       4
       -
         "createdAt": "2025-01-05T09:15:00Z",

     

       5
       -
         "reason": "Repeated harassment and spam"

     

       6
       -
       }

-7

tests/lexicon-test-data/actor/preferences-invalid-enum.json

···

       1
       -
       {

     

       2
       -
         "$type": "social.coves.actor.preferences",

     

       3
       -
         "feedPreferences": {

     

       4
       -
           "defaultFeed": "invalid-feed-type",

     

       5
       -
           "defaultSort": "hot"

     

       6
       -
         }

     

       7
       -
       }

-40

tests/lexicon-test-data/actor/preferences-valid.json

···

       1
       -
       {

     

       2
       -
         "$type": "social.coves.actor.preferences",

     

       3
       -
         "feedPreferences": {

     

       4
       -
           "defaultFeed": "home",

     

       5
       -
           "defaultSort": "hot",

     

       6
       -
           "showNSFW": false,

     

       7
       -
           "blurNSFW": true,

     

       8
       -
           "autoplayVideos": true,

     

       9
       -
           "infiniteScroll": true

     

       10
       -
         },

     

       11
       -
         "contentFiltering": {

     

       12
       -
           "blockedTags": ["politics", "spoilers"],

     

       13
       -
           "blockedCommunities": ["did:plc:controversialcommunity"],

     

       14
       -
           "mutedWords": ["spam", "scam"],

     

       15
       -
           "languageFilter": ["en", "es"]

     

       16
       -
         },

     

       17
       -
         "notificationSettings": {

     

       18
       -
           "postReplies": true,

     

       19
       -
           "commentReplies": true,

     

       20
       -
           "mentions": true,

     

       21
       -
           "upvotes": false,

     

       22
       -
           "newFollowers": true,

     

       23
       -
           "communityInvites": true,

     

       24
       -
           "moderatorNotifications": true

     

       25
       -
         },

     

       26
       -
         "privacySettings": {

     

       27
       -
           "profileVisibility": "public",

     

       28
       -
           "showSubscriptions": true,

     

       29
       -
           "showSavedPosts": false,

     

       30
       -
           "showVoteHistory": false,

     

       31
       -
           "allowDMs": "followers"

     

       32
       -
         },

     

       33
       -
         "displayPreferences": {

     

       34
       -
           "theme": "dark",

     

       35
       -
           "compactView": false,

     

       36
       -
           "showAvatars": true,

     

       37
       -
           "showThumbnails": true,

     

       38
       -
           "postsPerPage": 25

     

       39
       -
         }

     

       40
       -
       }

-6

tests/lexicon-test-data/actor/profile-invalid-handle-format.json

···

       1
       -
       {

     

       2
       -
         "$type": "social.coves.actor.profile",

     

       3
       -
         "handle": "invalid handle with spaces",

     

       4
       -
         "displayName": "Test User",

     

       5
       -
         "createdAt": "2024-01-01T00:00:00Z"

     

       6
       -
       }

-4

tests/lexicon-test-data/actor/profile-invalid-missing-handle.json

···

       1
       -
       {

     

       2
       -
         "$type": "social.coves.actor.profile",

     

       3
       -
         "displayName": "Missing Required Fields"

     

       4
       -
       }

-1

tests/lexicon-test-data/actor/profile-valid.json

···

       1
        
       {

     

       2
        
         "$type": "social.coves.actor.profile",

     

       3
       -
         "handle": "alice.example.com",

     

       4
        
         "displayName": "Alice Johnson",

     

       5
        
         "bio": "Software developer passionate about open-source",

     

       6
        
         "createdAt": "2024-01-15T10:30:00Z"

···

       1
        
       {

     

       2
        
         "$type": "social.coves.actor.profile",

     

       0
        
       
     

       3
        
         "displayName": "Alice Johnson",

     

       4
        
         "bio": "Software developer passionate about open-source",

     

       5
        
         "createdAt": "2024-01-15T10:30:00Z"

-6

tests/lexicon-test-data/actor/saved-invalid-type.json

···

       1
       -
       {

     

       2
       -
         "$type": "social.coves.actor.saved",

     

       3
       -
         "subject": "at://$1/social.coves.community.post/3k7a3dmb5bk2c",

     

       4
       -
         "type": "article",

     

       5
       -
         "createdAt": "2025-01-09T14:30:00Z"

     

       6
       -
       }

-7

tests/lexicon-test-data/actor/saved-valid.json

···

       1
       -
       {

     

       2
       -
         "$type": "social.coves.actor.saved",

     

       3
       -
         "subject": "at://$1/social.coves.community.post/3k7a3dmb5bk2c",

     

       4
       -
         "type": "post",

     

       5
       -
         "createdAt": "2025-01-09T14:30:00Z",

     

       6
       -
         "note": "Great tutorial on Go concurrency patterns"

     

       7
       -
       }

+9 -8

tests/lexicon_validation_test.go

···

       72
        
       

     

       73
        
       	// Test specific cross-references that should work

     

       74
        
       	crossRefs := map[string]string{

     

       75
       -
       		"social.coves.richtext.facet#byteSlice":  "byteSlice definition in facet schema",

     

       76
       -
       		"social.coves.actor.profile#geoLocation": "geoLocation definition in actor profile",

     

       77
       -
       		"social.coves.community.rules#rule":      "rule definition in community rules",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       78
        
       	}

     

       79
        
       

     

       80
        
       	for ref, description := range crossRefs {

     
···

       108
        
       			recordType: "social.coves.actor.profile",

     

       109
        
       			recordData: map[string]interface{}{

     

       110
        
       				"$type":       "social.coves.actor.profile",

     

       111
       -
       				"handle":      "alice.example.com",

     

       112
        
       				"displayName": "Alice Johnson",

     

       113
        
       				"createdAt":   "2024-01-15T10:30:00Z",

     

       114
        
       			},

     
···

       120
        
       			recordData: map[string]interface{}{

     

       121
        
       				"$type":       "social.coves.actor.profile",

     

       122
        
       				"displayName": "Alice Johnson",

     

       0
        
       
     

       123
        
       			},

     

       124
        
       			shouldFail:    true,

     

       125
       -
       			errorContains: "required field missing: handle",

     

       126
        
       		},

     

       127
        
       		{

     

       128
        
       			name:       "Valid community profile",

     

       129
        
       			recordType: "social.coves.community.profile",

     

       130
        
       			recordData: map[string]interface{}{

     

       131
        
       				"$type":          "social.coves.community.profile",

     

       132
       -
       				"handle":         "programming.community.coves.social",

     

       133
        
       				"name":           "programming",

     

       134
        
       				"displayName":    "Programming Community",

     

       135
        
       				"createdBy":      "did:plc:creator123",

     

       136
        
       				"hostedBy":       "did:plc:coves123",

     

       137
        
       				"visibility":     "public",

     

       138
        
       				"moderationType": "moderator",

     

       139
       -
       				"federatedFrom":  "coves",

     

       140
        
       				"createdAt":      "2023-12-01T08:00:00Z",

     

       141
        
       			},

     

       142
        
       			shouldFail: false,

     
···

       205
        
       	// Test with strict validation flags

     

       206
        
       	recordData := map[string]interface{}{

     

       207
        
       		"$type":       "social.coves.actor.profile",

     

       208
       -
       		"handle":      "alice.example.com",

     

       209
        
       		"displayName": "Alice Johnson",

     

       210
        
       		"createdAt":   "2024-01-15T10:30:00", // Missing timezone

     

       211
        
       	}

···

       72
        
       

     

       73
        
       	// Test specific cross-references that should work

     

       74
        
       	crossRefs := map[string]string{

     

       75
       +
       		"social.coves.richtext.facet#byteSlice":     "byteSlice definition in facet schema",

     

       76
       +
       		"social.coves.community.rules#rule":         "rule definition in community rules",

     

       77
       +
       		"social.coves.actor.defs#profileView":       "profileView definition in actor defs",

     

       78
       +
       		"social.coves.actor.defs#profileStats":      "profileStats definition in actor defs",

     

       79
       +
       		"social.coves.actor.defs#viewerState":       "viewerState definition in actor defs",

     

       80
       +
       		"social.coves.community.defs#communityView": "communityView definition in community defs",

     

       81
       +
       		"social.coves.community.defs#communityStats": "communityStats definition in community defs",

     

       82
        
       	}

     

       83
        
       

     

       84
        
       	for ref, description := range crossRefs {

     
···

       112
        
       			recordType: "social.coves.actor.profile",

     

       113
        
       			recordData: map[string]interface{}{

     

       114
        
       				"$type":       "social.coves.actor.profile",

     

       0
        
       
     

       115
        
       				"displayName": "Alice Johnson",

     

       116
        
       				"createdAt":   "2024-01-15T10:30:00Z",

     

       117
        
       			},

     
···

       123
        
       			recordData: map[string]interface{}{

     

       124
        
       				"$type":       "social.coves.actor.profile",

     

       125
        
       				"displayName": "Alice Johnson",

     

       126
       +
       				// Missing required createdAt

     

       127
        
       			},

     

       128
        
       			shouldFail:    true,

     

       129
       +
       			errorContains: "required field missing",

     

       130
        
       		},

     

       131
        
       		{

     

       132
        
       			name:       "Valid community profile",

     

       133
        
       			recordType: "social.coves.community.profile",

     

       134
        
       			recordData: map[string]interface{}{

     

       135
        
       				"$type":          "social.coves.community.profile",

     

       0
        
       
     

       136
        
       				"name":           "programming",

     

       137
        
       				"displayName":    "Programming Community",

     

       138
        
       				"createdBy":      "did:plc:creator123",

     

       139
        
       				"hostedBy":       "did:plc:coves123",

     

       140
        
       				"visibility":     "public",

     

       141
        
       				"moderationType": "moderator",

     

       0
        
       
     

       142
        
       				"createdAt":      "2023-12-01T08:00:00Z",

     

       143
        
       			},

     

       144
        
       			shouldFail: false,

     
···

       207
        
       	// Test with strict validation flags

     

       208
        
       	recordData := map[string]interface{}{

     

       209
        
       		"$type":       "social.coves.actor.profile",

     

       0
        
       
     

       210
        
       		"displayName": "Alice Johnson",

     

       211
        
       		"createdAt":   "2024-01-15T10:30:00", // Missing timezone

     

       212
        
       	}