commit a3c3bd3a66252043cf484271d53e209c15081dc9 · bretton.dev/coves

+17 -10

cmd/validate-lexicon/main.go

···

       119
        
       	}

     

       120
        
       

     

       121
        
       	for i, schemaID := range schemaIDs {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       122
        
       		if _, err := catalog.Resolve(schemaID); err != nil {

     

       123
        
       			validationErrors = append(validationErrors, fmt.Sprintf("Failed to resolve schema %s (from %s): %v", schemaID, schemaFiles[i], err))

     

       124
        
       		} else if verbose {

     
···

       415
        
       		"social.coves.richtext.facet#spoiler",

     

       416
        
       

     

       417
        
       		// Post types and views

     

       418
       -
       		"social.coves.post.get#postView",

     

       419
       -
       		"social.coves.post.get#authorView",

     

       420
       -
       		"social.coves.post.get#communityRef",

     

       421
       -
       		"social.coves.post.get#imageView",

     

       422
       -
       		"social.coves.post.get#videoView",

     

       423
       -
       		"social.coves.post.get#externalView",

     

       424
       -
       		"social.coves.post.get#postStats",

     

       425
       -
       		"social.coves.post.get#viewerState",

     

       426
        
       

     

       427
       -
       		// Post record types

     

       428
       -
       		"social.coves.post.record#originalAuthor",

     

       429
        
       

     

       430
        
       		// Actor definitions

     

       431
        
       		"social.coves.actor.profile#geoLocation",

···

       119
        
       	}

     

       120
        
       

     

       121
        
       	for i, schemaID := range schemaIDs {

     

       122
       +
       		// Skip validation for definition-only files (*.defs) - they don't need a "main" section

     

       123
       +
       		// These files only contain shared type definitions referenced by other schemas

     

       124
       +
       		if strings.HasSuffix(schemaID, ".defs") {

     

       125
       +
       			if verbose {

     

       126
       +
       				fmt.Printf("  ⏭️  %s (defs-only file, skipping main validation)\n", schemaID)

     

       127
       +
       			}

     

       128
       +
       			continue

     

       129
       +
       		}

     

       130
       +
       

     

       131
        
       		if _, err := catalog.Resolve(schemaID); err != nil {

     

       132
        
       			validationErrors = append(validationErrors, fmt.Sprintf("Failed to resolve schema %s (from %s): %v", schemaID, schemaFiles[i], err))

     

       133
        
       		} else if verbose {

     
···

       424
        
       		"social.coves.richtext.facet#spoiler",

     

       425
        
       

     

       426
        
       		// Post types and views

     

       427
       +
       		"social.coves.community.post.get#postView",

     

       428
       +
       		"social.coves.community.post.get#authorView",

     

       429
       +
       		"social.coves.community.post.get#communityRef",

     

       430
       +
       		"social.coves.community.post.get#postStats",

     

       431
       +
       		"social.coves.community.post.get#viewerState",

     

       432
       +
       		"social.coves.community.post.get#notFoundPost",

     

       433
       +
       		"social.coves.community.post.get#blockedPost",

     

       0
        
       
     

       434
        
       

     

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

     

       0
        
       
     

       436
        
       

     

       437
        
       		// Actor definitions

     

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

+100

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

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

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

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "record",

     

       7
       +
             "description": "A post in a Coves community. Posts live in community repositories and persist independently of the author.",

     

       8
       +
             "key": "tid",

     

       9
       +
             "record": {

     

       10
       +
               "type": "object",

     

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

     

       12
       +
               "properties": {

     

       13
       +
                 "community": {

     

       14
       +
                   "type": "string",

     

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

     

       16
       +
                   "description": "DID or handle of the community this was posted to"

     

       17
       +
                 },

     

       18
       +
                 "author": {

     

       19
       +
                   "type": "string",

     

       20
       +
                   "format": "did",

     

       21
       +
                   "description": "DID of the user who created this post"

     

       22
       +
                 },

     

       23
       +
                 "title": {

     

       24
       +
                   "type": "string",

     

       25
       +
                   "maxGraphemes": 300,

     

       26
       +
                   "maxLength": 3000,

     

       27
       +
                   "description": "Post title (optional for media-only posts)"

     

       28
       +
                 },

     

       29
       +
                 "content": {

     

       30
       +
                   "type": "string",

     

       31
       +
                   "maxGraphemes": 10000,

     

       32
       +
                   "maxLength": 100000,

     

       33
       +
                   "description": "Post content - supports rich text via facets"

     

       34
       +
                 },

     

       35
       +
                 "facets": {

     

       36
       +
                   "type": "array",

     

       37
       +
                   "description": "Annotations for rich text (mentions, links, tags)",

     

       38
       +
                   "items": {

     

       39
       +
                     "type": "ref",

     

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

     

       41
       +
                   }

     

       42
       +
                 },

     

       43
       +
                 "embed": {

     

       44
       +
                   "type": "union",

     

       45
       +
                   "description": "Embedded media, external links, or quoted posts",

     

       46
       +
                   "refs": [

     

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

     

       48
       +
                     "social.coves.embed.video",

     

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

     

       50
       +
                     "social.coves.embed.post"

     

       51
       +
                   ]

     

       52
       +
                 },

     

       53
       +
                 "langs": {

     

       54
       +
                   "type": "array",

     

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

     

       56
       +
                   "maxLength": 3,

     

       57
       +
                   "items": {

     

       58
       +
                     "type": "string",

     

       59
       +
                     "format": "language"

     

       60
       +
                   }

     

       61
       +
                 },

     

       62
       +
                 "labels": {

     

       63
       +
                   "type": "ref",

     

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

     

       65
       +
                   "description": "Self-applied content labels (NSFW, spoilers, etc.)"

     

       66
       +
                 },

     

       67
       +
                 "tags": {

     

       68
       +
                   "type": "array",

     

       69
       +
                   "description": "User-applied topic tags",

     

       70
       +
                   "maxLength": 8,

     

       71
       +
                   "items": {

     

       72
       +
                     "type": "string",

     

       73
       +
                     "maxLength": 64,

     

       74
       +
                     "maxGraphemes": 64

     

       75
       +
                   }

     

       76
       +
                 },

     

       77
       +
                 "crosspostOf": {

     

       78
       +
                   "type": "ref",

     

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

     

       80
       +
                   "description": "If this is a crosspost, strong reference to the immediate parent post"

     

       81
       +
                 },

     

       82
       +
                 "crosspostChain": {

     

       83
       +
                   "type": "array",

     

       84
       +
                   "description": "Full chain of crossposts with version pinning. First element is original, last is immediate parent.",

     

       85
       +
                   "maxLength": 25,

     

       86
       +
                   "items": {

     

       87
       +
                     "type": "ref",

     

       88
       +
                     "ref": "com.atproto.repo.strongRef"

     

       89
       +
                   }

     

       90
       +
                 },

     

       91
       +
                 "createdAt": {

     

       92
       +
                   "type": "string",

     

       93
       +
                   "format": "datetime",

     

       94
       +
                   "description": "Timestamp of post creation"

     

       95
       +
                 }

     

       96
       +
               }

     

       97
       +
             }

     

       98
       +
           }

     

       99
       +
         }

     

       100
       +
       }

+119

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

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

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

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Create a new post in a community",

     

       8
       +
             "input": {

     

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

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

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

     

       13
       +
                 "properties": {

     

       14
       +
                   "community": {

     

       15
       +
                     "type": "string",

     

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

     

       17
       +
                     "description": "DID or handle of the community to post in"

     

       18
       +
                   },

     

       19
       +
                   "title": {

     

       20
       +
                     "type": "string",

     

       21
       +
                     "maxGraphemes": 300,

     

       22
       +
                     "maxLength": 3000,

     

       23
       +
                     "description": "Post title (optional for media-only posts)"

     

       24
       +
                   },

     

       25
       +
                   "content": {

     

       26
       +
                     "type": "string",

     

       27
       +
                     "maxGraphemes": 10000,

     

       28
       +
                     "maxLength": 100000,

     

       29
       +
                     "description": "Post content - supports rich text via facets"

     

       30
       +
                   },

     

       31
       +
                   "facets": {

     

       32
       +
                     "type": "array",

     

       33
       +
                     "description": "Annotations for rich text (mentions, links, tags)",

     

       34
       +
                     "items": {

     

       35
       +
                       "type": "ref",

     

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

     

       37
       +
                     }

     

       38
       +
                   },

     

       39
       +
                   "embed": {

     

       40
       +
                     "type": "union",

     

       41
       +
                     "description": "Embedded media, external links, or quoted posts",

     

       42
       +
                     "refs": [

     

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

     

       44
       +
                       "social.coves.embed.video",

     

       45
       +
                       "social.coves.embed.external",

     

       46
       +
                       "social.coves.embed.post"

     

       47
       +
                     ]

     

       48
       +
                   },

     

       49
       +
                   "langs": {

     

       50
       +
                     "type": "array",

     

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

     

       52
       +
                     "maxLength": 3,

     

       53
       +
                     "items": {

     

       54
       +
                       "type": "string",

     

       55
       +
                       "format": "language"

     

       56
       +
                     }

     

       57
       +
                   },

     

       58
       +
                   "labels": {

     

       59
       +
                     "type": "ref",

     

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

     

       61
       +
                     "description": "Self-applied content labels (NSFW, spoilers, etc.)"

     

       62
       +
                   },

     

       63
       +
                   "tags": {

     

       64
       +
                     "type": "array",

     

       65
       +
                     "description": "User-applied topic tags",

     

       66
       +
                     "maxLength": 8,

     

       67
       +
                     "items": {

     

       68
       +
                       "type": "string",

     

       69
       +
                       "maxLength": 64,

     

       70
       +
                       "maxGraphemes": 64

     

       71
       +
                     }

     

       72
       +
                   }

     

       73
       +
                 }

     

       74
       +
               }

     

       75
       +
             },

     

       76
       +
             "output": {

     

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

     

       78
       +
               "schema": {

     

       79
       +
                 "type": "object",

     

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

     

       81
       +
                 "properties": {

     

       82
       +
                   "uri": {

     

       83
       +
                     "type": "string",

     

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

     

       85
       +
                     "description": "AT-URI of the created post"

     

       86
       +
                   },

     

       87
       +
                   "cid": {

     

       88
       +
                     "type": "string",

     

       89
       +
                     "format": "cid",

     

       90
       +
                     "description": "CID of the created post"

     

       91
       +
                   }

     

       92
       +
                 }

     

       93
       +
               }

     

       94
       +
             },

     

       95
       +
             "errors": [

     

       96
       +
               {

     

       97
       +
                 "name": "CommunityNotFound",

     

       98
       +
                 "description": "Community not found"

     

       99
       +
               },

     

       100
       +
               {

     

       101
       +
                 "name": "NotAuthorized",

     

       102
       +
                 "description": "User is not authorized to post in this community"

     

       103
       +
               },

     

       104
       +
               {

     

       105
       +
                 "name": "Banned",

     

       106
       +
                 "description": "User is banned from this community"

     

       107
       +
               },

     

       108
       +
               {

     

       109
       +
                 "name": "InvalidContent",

     

       110
       +
                 "description": "Post content violates community rules"

     

       111
       +
               },

     

       112
       +
               {

     

       113
       +
                 "name": "ContentRuleViolation",

     

       114
       +
                 "description": "Post violates community content rules (e.g., embeds not allowed, text too short)"

     

       115
       +
               }

     

       116
       +
             ]

     

       117
       +
           }

     

       118
       +
         }

     

       119
       +
       }

+41

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

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

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

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Delete a post",

     

       8
       +
             "input": {

     

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

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

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

     

       13
       +
                 "properties": {

     

       14
       +
                   "uri": {

     

       15
       +
                     "type": "string",

     

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

     

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

     

       18
       +
                   }

     

       19
       +
                 }

     

       20
       +
               }

     

       21
       +
             },

     

       22
       +
             "output": {

     

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

     

       24
       +
               "schema": {

     

       25
       +
                 "type": "object",

     

       26
       +
                 "properties": {}

     

       27
       +
               }

     

       28
       +
             },

     

       29
       +
             "errors": [

     

       30
       +
               {

     

       31
       +
                 "name": "PostNotFound",

     

       32
       +
                 "description": "Post not found"

     

       33
       +
               },

     

       34
       +
               {

     

       35
       +
                 "name": "NotAuthorized",

     

       36
       +
                 "description": "User is not authorized to delete this post"

     

       37
       +
               }

     

       38
       +
             ]

     

       39
       +
           }

     

       40
       +
         }

     

       41
       +
       }

+294

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

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "social.coves.community.post.get",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "description": "Get posts by AT-URI. Supports batch fetching for feed hydration. Returns posts in same order as input URIs.",

     

       8
       +
             "parameters": {

     

       9
       +
               "type": "params",

     

       10
       +
               "required": ["uris"],

     

       11
       +
               "properties": {

     

       12
       +
                 "uris": {

     

       13
       +
                   "type": "array",

     

       14
       +
                   "description": "List of post AT-URIs to fetch (max 25)",

     

       15
       +
                   "items": {

     

       16
       +
                     "type": "string",

     

       17
       +
                     "format": "at-uri"

     

       18
       +
                   },

     

       19
       +
                   "maxLength": 25,

     

       20
       +
                   "minLength": 1

     

       21
       +
                 }

     

       22
       +
               }

     

       23
       +
             },

     

       24
       +
             "output": {

     

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

     

       26
       +
               "schema": {

     

       27
       +
                 "type": "object",

     

       28
       +
                 "required": ["posts"],

     

       29
       +
                 "properties": {

     

       30
       +
                   "posts": {

     

       31
       +
                     "type": "array",

     

       32
       +
                     "description": "Array of post views. May include notFound/blocked entries for missing posts.",

     

       33
       +
                     "items": {

     

       34
       +
                       "type": "union",

     

       35
       +
                       "refs": ["#postView", "#notFoundPost", "#blockedPost"]

     

       36
       +
                     }

     

       37
       +
                   }

     

       38
       +
                 }

     

       39
       +
               }

     

       40
       +
             },

     

       41
       +
             "errors": [

     

       42
       +
               {"name": "InvalidRequest", "description": "Invalid URI format or empty array"}

     

       43
       +
             ]

     

       44
       +
           },

     

       45
       +
           "postView": {

     

       46
       +
             "type": "object",

     

       47
       +
             "required": ["uri", "cid", "author", "record", "community", "createdAt", "indexedAt"],

     

       48
       +
             "properties": {

     

       49
       +
               "uri": {

     

       50
       +
                 "type": "string",

     

       51
       +
                 "format": "at-uri"

     

       52
       +
               },

     

       53
       +
               "cid": {

     

       54
       +
                 "type": "string",

     

       55
       +
                 "format": "cid"

     

       56
       +
               },

     

       57
       +
               "author": {

     

       58
       +
                 "type": "ref",

     

       59
       +
                 "ref": "#authorView"

     

       60
       +
               },

     

       61
       +
               "record": {

     

       62
       +
                 "type": "unknown",

     

       63
       +
                 "description": "The actual post record (text, image, video, etc.)"

     

       64
       +
               },

     

       65
       +
               "community": {

     

       66
       +
                 "type": "ref",

     

       67
       +
                 "ref": "#communityRef"

     

       68
       +
               },

     

       69
       +
               "title": {

     

       70
       +
                 "type": "string"

     

       71
       +
               },

     

       72
       +
               "text": {

     

       73
       +
                 "type": "string"

     

       74
       +
               },

     

       75
       +
               "textFacets": {

     

       76
       +
                 "type": "array",

     

       77
       +
                 "items": {

     

       78
       +
                   "type": "ref",

     

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

     

       80
       +
                 }

     

       81
       +
               },

     

       82
       +
               "embed": {

     

       83
       +
                 "type": "union",

     

       84
       +
                 "description": "Embedded content (images, video, link preview, or quoted post)",

     

       85
       +
                 "refs": [

     

       86
       +
                   "social.coves.embed.images#view",

     

       87
       +
                   "social.coves.embed.video#view",

     

       88
       +
                   "social.coves.embed.external#view",

     

       89
       +
                   "social.coves.embed.record#view",

     

       90
       +
                   "social.coves.embed.recordWithMedia#view"

     

       91
       +
                 ]

     

       92
       +
               },

     

       93
       +
               "language": {

     

       94
       +
                 "type": "string",

     

       95
       +
                 "format": "language"

     

       96
       +
               },

     

       97
       +
               "createdAt": {

     

       98
       +
                 "type": "string",

     

       99
       +
                 "format": "datetime"

     

       100
       +
               },

     

       101
       +
               "editedAt": {

     

       102
       +
                 "type": "string",

     

       103
       +
                 "format": "datetime"

     

       104
       +
               },

     

       105
       +
               "indexedAt": {

     

       106
       +
                 "type": "string",

     

       107
       +
                 "format": "datetime",

     

       108
       +
                 "description": "When this post was indexed by the AppView"

     

       109
       +
               },

     

       110
       +
               "stats": {

     

       111
       +
                 "type": "ref",

     

       112
       +
                 "ref": "#postStats"

     

       113
       +
               },

     

       114
       +
               "viewer": {

     

       115
       +
                 "type": "ref",

     

       116
       +
                 "ref": "#viewerState"

     

       117
       +
               }

     

       118
       +
             }

     

       119
       +
           },

     

       120
       +
           "authorView": {

     

       121
       +
             "type": "object",

     

       122
       +
             "required": ["did", "handle"],

     

       123
       +
             "properties": {

     

       124
       +
               "did": {

     

       125
       +
                 "type": "string",

     

       126
       +
                 "format": "did"

     

       127
       +
               },

     

       128
       +
               "handle": {

     

       129
       +
                 "type": "string",

     

       130
       +
                 "format": "handle"

     

       131
       +
               },

     

       132
       +
               "displayName": {

     

       133
       +
                 "type": "string"

     

       134
       +
               },

     

       135
       +
               "avatar": {

     

       136
       +
                 "type": "string",

     

       137
       +
                 "format": "uri"

     

       138
       +
               },

     

       139
       +
               "reputation": {

     

       140
       +
                 "type": "integer",

     

       141
       +
                 "description": "Author's reputation in the community"

     

       142
       +
               }

     

       143
       +
             }

     

       144
       +
           },

     

       145
       +
           "communityRef": {

     

       146
       +
             "type": "object",

     

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

     

       148
       +
             "properties": {

     

       149
       +
               "did": {

     

       150
       +
                 "type": "string",

     

       151
       +
                 "format": "did"

     

       152
       +
               },

     

       153
       +
               "name": {

     

       154
       +
                 "type": "string"

     

       155
       +
               },

     

       156
       +
               "avatar": {

     

       157
       +
                 "type": "string",

     

       158
       +
                 "format": "uri"

     

       159
       +
               }

     

       160
       +
             }

     

       161
       +
           },

     

       162
       +
           "notFoundPost": {

     

       163
       +
             "type": "object",

     

       164
       +
             "description": "Post was not found (deleted, never indexed, or invalid URI)",

     

       165
       +
             "required": ["uri", "notFound"],

     

       166
       +
             "properties": {

     

       167
       +
               "uri": {

     

       168
       +
                 "type": "string",

     

       169
       +
                 "format": "at-uri"

     

       170
       +
               },

     

       171
       +
               "notFound": {

     

       172
       +
                 "type": "boolean",

     

       173
       +
                 "const": true

     

       174
       +
               }

     

       175
       +
             }

     

       176
       +
           },

     

       177
       +
           "blockedPost": {

     

       178
       +
             "type": "object",

     

       179
       +
             "description": "Post is blocked due to viewer blocking author/community, or community moderation",

     

       180
       +
             "required": ["uri", "blocked"],

     

       181
       +
             "properties": {

     

       182
       +
               "uri": {

     

       183
       +
                 "type": "string",

     

       184
       +
                 "format": "at-uri"

     

       185
       +
               },

     

       186
       +
               "blocked": {

     

       187
       +
                 "type": "boolean",

     

       188
       +
                 "const": true

     

       189
       +
               },

     

       190
       +
               "blockedBy": {

     

       191
       +
                 "type": "string",

     

       192
       +
                 "enum": ["author", "community", "moderator"],

     

       193
       +
                 "description": "What caused the block: viewer blocked author, viewer blocked community, or post was removed by moderators"

     

       194
       +
               },

     

       195
       +
               "author": {

     

       196
       +
                 "type": "ref",

     

       197
       +
                 "ref": "#blockedAuthor"

     

       198
       +
               },

     

       199
       +
               "community": {

     

       200
       +
                 "type": "ref",

     

       201
       +
                 "ref": "#blockedCommunity"

     

       202
       +
               }

     

       203
       +
             }

     

       204
       +
           },

     

       205
       +
           "blockedAuthor": {

     

       206
       +
             "type": "object",

     

       207
       +
             "description": "Minimal author info for blocked posts",

     

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

     

       209
       +
             "properties": {

     

       210
       +
               "did": {

     

       211
       +
                 "type": "string",

     

       212
       +
                 "format": "did"

     

       213
       +
               }

     

       214
       +
             }

     

       215
       +
           },

     

       216
       +
           "blockedCommunity": {

     

       217
       +
             "type": "object",

     

       218
       +
             "description": "Minimal community info for blocked posts",

     

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

     

       220
       +
             "properties": {

     

       221
       +
               "did": {

     

       222
       +
                 "type": "string",

     

       223
       +
                 "format": "did"

     

       224
       +
               },

     

       225
       +
               "name": {

     

       226
       +
                 "type": "string"

     

       227
       +
               }

     

       228
       +
             }

     

       229
       +
           },

     

       230
       +
           "postStats": {

     

       231
       +
             "type": "object",

     

       232
       +
             "required": ["upvotes", "downvotes", "score", "commentCount"],

     

       233
       +
             "properties": {

     

       234
       +
               "upvotes": {

     

       235
       +
                 "type": "integer",

     

       236
       +
                 "minimum": 0

     

       237
       +
               },

     

       238
       +
               "downvotes": {

     

       239
       +
                 "type": "integer",

     

       240
       +
                 "minimum": 0

     

       241
       +
               },

     

       242
       +
               "score": {

     

       243
       +
                 "type": "integer",

     

       244
       +
                 "description": "Calculated score (upvotes - downvotes)"

     

       245
       +
               },

     

       246
       +
               "commentCount": {

     

       247
       +
                 "type": "integer",

     

       248
       +
                 "minimum": 0

     

       249
       +
               },

     

       250
       +
               "shareCount": {

     

       251
       +
                 "type": "integer",

     

       252
       +
                 "minimum": 0

     

       253
       +
               },

     

       254
       +
               "tagCounts": {

     

       255
       +
                 "type": "object",

     

       256
       +
                 "description": "Aggregate counts of tags applied by community members",

     

       257
       +
                 "additionalProperties": {

     

       258
       +
                   "type": "integer",

     

       259
       +
                   "minimum": 0

     

       260
       +
                 }

     

       261
       +
               }

     

       262
       +
             }

     

       263
       +
           },

     

       264
       +
           "viewerState": {

     

       265
       +
             "type": "object",

     

       266
       +
             "properties": {

     

       267
       +
               "vote": {

     

       268
       +
                 "type": "string",

     

       269
       +
                 "enum": ["up", "down"],

     

       270
       +
                 "description": "Viewer's vote on this post"

     

       271
       +
               },

     

       272
       +
               "voteUri": {

     

       273
       +
                 "type": "string",

     

       274
       +
                 "format": "at-uri"

     

       275
       +
               },

     

       276
       +
               "saved": {

     

       277
       +
                 "type": "boolean"

     

       278
       +
               },

     

       279
       +
               "savedUri": {

     

       280
       +
                 "type": "string",

     

       281
       +
                 "format": "at-uri"

     

       282
       +
               },

     

       283
       +
               "tags": {

     

       284
       +
                 "type": "array",

     

       285
       +
                 "description": "Tags applied by the viewer to this post",

     

       286
       +
                 "items": {

     

       287
       +
                   "type": "string",

     

       288
       +
                   "maxLength": 32

     

       289
       +
                 }

     

       290
       +
               }

     

       291
       +
             }

     

       292
       +
           }

     

       293
       +
         }

     

       294
       +
       }

+80

internal/atproto/lexicon/social/coves/community/post/search.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "social.coves.community.post.search",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "description": "Search for posts",

     

       8
       +
             "parameters": {

     

       9
       +
               "type": "params",

     

       10
       +
               "required": ["q"],

     

       11
       +
               "properties": {

     

       12
       +
                 "q": {

     

       13
       +
                   "type": "string",

     

       14
       +
                   "description": "Search query"

     

       15
       +
                 },

     

       16
       +
                 "community": {

     

       17
       +
                   "type": "string",

     

       18
       +
                   "format": "at-identifier",

     

       19
       +
                   "description": "Filter by specific community"

     

       20
       +
                 },

     

       21
       +
                 "author": {

     

       22
       +
                   "type": "string",

     

       23
       +
                   "format": "at-identifier",

     

       24
       +
                   "description": "Filter by author"

     

       25
       +
                 },

     

       26
       +
                 "type": {

     

       27
       +
                   "type": "string",

     

       28
       +
                   "enum": ["text", "image", "video", "article", "microblog"],

     

       29
       +
                   "description": "Filter by post type"

     

       30
       +
                 },

     

       31
       +
                 "tags": {

     

       32
       +
                   "type": "array",

     

       33
       +
                   "items": {

     

       34
       +
                     "type": "string"

     

       35
       +
                   },

     

       36
       +
                   "description": "Filter by tags"

     

       37
       +
                 },

     

       38
       +
                 "sort": {

     

       39
       +
                   "type": "string",

     

       40
       +
                   "enum": ["relevance", "new", "top"],

     

       41
       +
                   "default": "relevance"

     

       42
       +
                 },

     

       43
       +
                 "timeframe": {

     

       44
       +
                   "type": "string",

     

       45
       +
                   "enum": ["hour", "day", "week", "month", "year", "all"],

     

       46
       +
                   "default": "all"

     

       47
       +
                 },

     

       48
       +
                 "limit": {

     

       49
       +
                   "type": "integer",

     

       50
       +
                   "minimum": 1,

     

       51
       +
                   "maximum": 100,

     

       52
       +
                   "default": 50

     

       53
       +
                 },

     

       54
       +
                 "cursor": {

     

       55
       +
                   "type": "string"

     

       56
       +
                 }

     

       57
       +
               }

     

       58
       +
             },

     

       59
       +
             "output": {

     

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

     

       61
       +
               "schema": {

     

       62
       +
                 "type": "object",

     

       63
       +
                 "required": ["posts"],

     

       64
       +
                 "properties": {

     

       65
       +
                   "posts": {

     

       66
       +
                     "type": "array",

     

       67
       +
                     "items": {

     

       68
       +
                       "type": "ref",

     

       69
       +
                       "ref": "social.coves.feed.defs#feedViewPost"

     

       70
       +
                     }

     

       71
       +
                   },

     

       72
       +
                   "cursor": {

     

       73
       +
                     "type": "string"

     

       74
       +
                   }

     

       75
       +
                 }

     

       76
       +
               }

     

       77
       +
             }

     

       78
       +
           }

     

       79
       +
         }

     

       80
       +
       }

+119

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

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

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

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Update an existing post",

     

       8
       +
             "input": {

     

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

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

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

     

       13
       +
                 "properties": {

     

       14
       +
                   "uri": {

     

       15
       +
                     "type": "string",

     

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

     

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

     

       18
       +
                   },

     

       19
       +
                   "title": {

     

       20
       +
                     "type": "string",

     

       21
       +
                     "maxGraphemes": 300,

     

       22
       +
                     "maxLength": 3000,

     

       23
       +
                     "description": "Updated title"

     

       24
       +
                   },

     

       25
       +
                   "content": {

     

       26
       +
                     "type": "string",

     

       27
       +
                     "maxLength": 50000,

     

       28
       +
                     "description": "Updated content - main text for text posts, description for media, etc."

     

       29
       +
                   },

     

       30
       +
                   "facets": {

     

       31
       +
                     "type": "array",

     

       32
       +
                     "description": "Updated rich text annotations for content",

     

       33
       +
                     "items": {

     

       34
       +
                       "type": "ref",

     

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

     

       36
       +
                     }

     

       37
       +
                   },

     

       38
       +
                   "embed": {

     

       39
       +
                     "type": "union",

     

       40
       +
                     "description": "Updated embedded content (note: changing embed type may be restricted)",

     

       41
       +
                     "refs": [

     

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

     

       43
       +
                       "social.coves.embed.video",

     

       44
       +
                       "social.coves.embed.external",

     

       45
       +
                       "social.coves.embed.post"

     

       46
       +
                     ]

     

       47
       +
                   },

     

       48
       +
                   "labels": {

     

       49
       +
                     "type": "ref",

     

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

     

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

     

       52
       +
                   },

     

       53
       +
                   "langs": {

     

       54
       +
                     "type": "array",

     

       55
       +
                     "description": "Updated languages (ISO 639-1)",

     

       56
       +
                     "maxLength": 3,

     

       57
       +
                     "items": {

     

       58
       +
                       "type": "string",

     

       59
       +
                       "format": "language"

     

       60
       +
                     }

     

       61
       +
                   },

     

       62
       +
                   "tags": {

     

       63
       +
                     "type": "array",

     

       64
       +
                     "description": "Updated topic tags",

     

       65
       +
                     "maxLength": 8,

     

       66
       +
                     "items": {

     

       67
       +
                       "type": "string",

     

       68
       +
                       "maxLength": 64,

     

       69
       +
                       "maxGraphemes": 64

     

       70
       +
                     }

     

       71
       +
                   },

     

       72
       +
                   "editNote": {

     

       73
       +
                     "type": "string",

     

       74
       +
                     "maxLength": 300,

     

       75
       +
                     "description": "Optional note explaining the edit"

     

       76
       +
                   }

     

       77
       +
                 }

     

       78
       +
               }

     

       79
       +
             },

     

       80
       +
             "output": {

     

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

     

       82
       +
               "schema": {

     

       83
       +
                 "type": "object",

     

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

     

       85
       +
                 "properties": {

     

       86
       +
                   "uri": {

     

       87
       +
                     "type": "string",

     

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

     

       89
       +
                     "description": "AT-URI of the updated post"

     

       90
       +
                   },

     

       91
       +
                   "cid": {

     

       92
       +
                     "type": "string",

     

       93
       +
                     "format": "cid",

     

       94
       +
                     "description": "New CID of the updated post"

     

       95
       +
                   }

     

       96
       +
                 }

     

       97
       +
               }

     

       98
       +
             },

     

       99
       +
             "errors": [

     

       100
       +
               {

     

       101
       +
                 "name": "PostNotFound",

     

       102
       +
                 "description": "Post not found"

     

       103
       +
               },

     

       104
       +
               {

     

       105
       +
                 "name": "NotAuthorized",

     

       106
       +
                 "description": "User is not authorized to edit this post"

     

       107
       +
               },

     

       108
       +
               {

     

       109
       +
                 "name": "EditWindowExpired",

     

       110
       +
                 "description": "Edit window has expired (posts can only be edited within 24 hours)"

     

       111
       +
               },

     

       112
       +
               {

     

       113
       +
                 "name": "InvalidUpdate",

     

       114
       +
                 "description": "Invalid update operation (e.g., changing post type)"

     

       115
       +
               }

     

       116
       +
             ]

     

       117
       +
           }

     

       118
       +
         }

     

       119
       +
       }

+3 -3

internal/validation/lexicon.go

···

       81
        
       

     

       82
        
       // ValidatePost validates a post record

     

       83
        
       func (v *LexiconValidator) ValidatePost(post map[string]interface{}) error {

     

       84
       -
       	return v.ValidateRecord(post, "social.coves.post.record")

     

       85
        
       }

     

       86
        
       

     

       87
        
       // ValidateComment validates a comment record

     

       88
        
       func (v *LexiconValidator) ValidateComment(comment map[string]interface{}) error {

     

       89
       -
       	return v.ValidateRecord(comment, "social.coves.interaction.comment")

     

       90
        
       }

     

       91
        
       

     

       92
        
       // ValidateVote validates a vote record

     
···

       99
        
       	return v.ValidateRecord(action, fmt.Sprintf("social.coves.moderation.%s", actionType))

     

       100
        
       }

     

       101
        
       

     

       102
       -
       // ResolveReference resolves a schema reference (e.g., "social.coves.post.get#postView")

     

       103
        
       func (v *LexiconValidator) ResolveReference(ref string) (interface{}, error) {

     

       104
        
       	return v.catalog.Resolve(ref)

     

       105
        
       }

···

       81
        
       

     

       82
        
       // ValidatePost validates a post record

     

       83
        
       func (v *LexiconValidator) ValidatePost(post map[string]interface{}) error {

     

       84
       +
       	return v.ValidateRecord(post, "social.coves.community.post")

     

       85
        
       }

     

       86
        
       

     

       87
        
       // ValidateComment validates a comment record

     

       88
        
       func (v *LexiconValidator) ValidateComment(comment map[string]interface{}) error {

     

       89
       +
       	return v.ValidateRecord(comment, "social.coves.feed.comment")

     

       90
        
       }

     

       91
        
       

     

       92
        
       // ValidateVote validates a vote record

     
···

       99
        
       	return v.ValidateRecord(action, fmt.Sprintf("social.coves.moderation.%s", actionType))

     

       100
        
       }

     

       101
        
       

     

       102
       +
       // ResolveReference resolves a schema reference (e.g., "social.coves.community.post.get#postView")

     

       103
        
       func (v *LexiconValidator) ResolveReference(ref string) (interface{}, error) {

     

       104
        
       	return v.catalog.Resolve(ref)

     

       105
        
       }

+7 -3

internal/validation/lexicon_test.go

···

       58
        
       

     

       59
        
       	// Valid post

     

       60
        
       	validPost := map[string]interface{}{

     

       61
       -
       		"$type":     "social.coves.post.record",

     

       62
        
       		"community": "did:plc:test123",

     

       63
        
       		"author":    "did:plc:author123",

     

       64
        
       		"title":     "Test Post",

     
···

       72
        
       

     

       73
        
       	// Invalid post - missing required field (author)

     

       74
        
       	invalidPost := map[string]interface{}{

     

       75
       -
       		"$type":     "social.coves.post.record",

     

       76
        
       		"community": "did:plc:test123",

     

       77
        
       		// Missing required "author" field

     

       78
        
       		"title":     "Test Post",

     
···

       94
        
       	// Test with JSON string

     

       95
        
       	jsonString := `{

     

       96
        
       		"$type": "social.coves.interaction.vote",

     

       97
       -
       		"subject": "at://did:plc:test/social.coves.post.text/abc123",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       99
        
       	}`

     

       100

···

       58
        
       

     

       59
        
       	// Valid post

     

       60
        
       	validPost := map[string]interface{}{

     

       61
       +
       		"$type":     "social.coves.community.post",

     

       62
        
       		"community": "did:plc:test123",

     

       63
        
       		"author":    "did:plc:author123",

     

       64
        
       		"title":     "Test Post",

     
···

       72
        
       

     

       73
        
       	// Invalid post - missing required field (author)

     

       74
        
       	invalidPost := map[string]interface{}{

     

       75
       +
       		"$type":     "social.coves.community.post",

     

       76
        
       		"community": "did:plc:test123",

     

       77
        
       		// Missing required "author" field

     

       78
        
       		"title":     "Test Post",

     
···

       94
        
       	// Test with JSON string

     

       95
        
       	jsonString := `{

     

       96
        
       		"$type": "social.coves.interaction.vote",

     

       97
       +
       		"subject": {

     

       98
       +
       			"uri": "at://did:plc:test/social.coves.community.post/abc123",

     

       99
       +
       			"cid": "bafyreigj3fwnwjuzr35k2kuzmb5dixxczrzjhqkr5srlqplsh6gq3bj3si"

     

       100
       +
       		},

     

       101
       +
       		"direction": "up",

     

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

     

       103
        
       	}`

     

       104

+10 -4

tests/lexicon_validation_test.go

···

       48
        
       		schemaID := strings.ReplaceAll(relPath, string(filepath.Separator), ".")

     

       49
        
       

     

       50
        
       		t.Run(schemaID, func(t *testing.T) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       51
        
       			if _, resolveErr := catalog.Resolve(schemaID); resolveErr != nil {

     

       52
        
       				t.Errorf("Failed to resolve schema %s: %v", schemaID, resolveErr)

     

       53
        
       			}

     
···

       137
        
       		},

     

       138
        
       		{

     

       139
        
       			name:       "Valid post record",

     

       140
       -
       			recordType: "social.coves.post.record",

     

       141
        
       			recordData: map[string]interface{}{

     

       142
       -
       				"$type":     "social.coves.post.record",

     

       143
        
       				"community": "did:plc:programming123",

     

       144
        
       				"author":    "did:plc:testauthor123",

     

       145
        
       				"title":     "Test Post",

     
···

       150
        
       		},

     

       151
        
       		{

     

       152
        
       			name:       "Invalid post record - missing required field",

     

       153
       -
       			recordType: "social.coves.post.record",

     

       154
        
       			recordData: map[string]interface{}{

     

       155
       -
       				"$type":     "social.coves.post.record",

     

       156
        
       				"community": "did:plc:programming123",

     

       157
        
       				// Missing required "author" field

     

       158
        
       				"title":     "Test Post",

···

       48
        
       		schemaID := strings.ReplaceAll(relPath, string(filepath.Separator), ".")

     

       49
        
       

     

       50
        
       		t.Run(schemaID, func(t *testing.T) {

     

       51
       +
       			// Skip validation for definition-only files (*.defs) - they don't need a "main" section

     

       52
       +
       			// These files only contain shared type definitions referenced by other schemas

     

       53
       +
       			if strings.HasSuffix(schemaID, ".defs") {

     

       54
       +
       				t.Skip("Skipping defs-only file (no main section required)")

     

       55
       +
       			}

     

       56
       +
       

     

       57
        
       			if _, resolveErr := catalog.Resolve(schemaID); resolveErr != nil {

     

       58
        
       				t.Errorf("Failed to resolve schema %s: %v", schemaID, resolveErr)

     

       59
        
       			}

     
···

       143
        
       		},

     

       144
        
       		{

     

       145
        
       			name:       "Valid post record",

     

       146
       +
       			recordType: "social.coves.community.post",

     

       147
        
       			recordData: map[string]interface{}{

     

       148
       +
       				"$type":     "social.coves.community.post",

     

       149
        
       				"community": "did:plc:programming123",

     

       150
        
       				"author":    "did:plc:testauthor123",

     

       151
        
       				"title":     "Test Post",

     
···

       156
        
       		},

     

       157
        
       		{

     

       158
        
       			name:       "Invalid post record - missing required field",

     

       159
       +
       			recordType: "social.coves.community.post",

     

       160
        
       			recordData: map[string]interface{}{

     

       161
       +
       				"$type":     "social.coves.community.post",

     

       162
        
       				"community": "did:plc:programming123",

     

       163
        
       				// Missing required "author" field

     

       164
        
       				"title":     "Test Post",