commit c047f0359ebdb18d88a03ac4c7984db0d288451e · zbrox.com/jacquard

+15 -4

codegen_plan.md

···

       129
       129
        
       

     

       130
       130
        
       **Tasks**:

     

       131
       131
        
       1. Create `LexiconCorpus` struct

     

       132
       132
       -
          - `HashMap<SmolStr, LexiconDoc<'static>>` - NSID → doc

     

       132
       132
       +
          - `BTreeMap<SmolStr, LexiconDoc<'static>>` - NSID → doc

     

       133
       133
        
          - Methods: `load_from_dir()`, `get()`, `resolve_ref()`

     

       134
       134
        
       2. Load all `.json` files from lexicon directory

     

       135
       135
        
       3. Parse into `LexiconDoc` and insert into registry

     
···

       261
       261
        
           // ... fields

     

       262
       262
        
       }

     

       263
       263
        
       

     

       264
       264
       -
       impl Collection for Post<'_> {

     

       264
       264
       +
       impl Collection for Post<'p> {

     

       265
       265
        
           const NSID: &'static str = "app.bsky.feed.post";

     

       266
       266
       -
           type Record = Post<'static>;

     

       266
       266
       +
           type Record = Post<'p>;

     

       267
       267
        
       }

     

       268
       268
        
       ```

     

       269
       269
        
       

     
···

       275
       275
        
           /// The NSID for this XRPC method

     

       276
       276
        
           const NSID: &'static str;

     

       277
       277
        
       

     

       278
       278
       -
           /// HTTP method (GET for queries, POST for procedures)

     

       278
       278
       +
           /// XRPC method (query/GET, procedure/POST)

     

       279
       279
        
           const METHOD: XrpcMethod;

     

       280
       280
        
       

     

       281
       281
        
           /// Input encoding (MIME type, e.g., "application/json")

     
···

       290
       290
        
       

     

       291
       291
        
           /// Response output type

     

       292
       292
        
           type Output: Deserialize<'x>;

     

       293
       293
       +
       

     

       294
       294
       +
           type Err: Error;

     

       293
       295
        
       }

     

       294
       296
        
       

     

       295
       297
        
       pub enum XrpcMethod {

     
···

       298
       300
        
       }

     

       299
       301
        
       ```

     

       300
       302
        
       

     

       303
       303
       +
       

     

       304
       304
       +
       

     

       301
       305
        
       **Generated implementation:**

     

       302
       306
        
       ```rust

     

       303
       307
        
       pub struct GetAuthorFeedParams<'a> {

     
···

       319
       323
        
       

     

       320
       324
        
           type Params = Self;

     

       321
       325
        
           type Output = GetAuthorFeedOutput<'static>;

     

       326
       326
       +
           type Err = GetAuthorFeedError;

     

       322
       327
        
       }

     

       323
       328
        
       ```

     

       324
       329
        
       

     
···

       332
       337
        
       - Allows monomorphization (static dispatch) for performance

     

       333
       338
        
       - Also supports `dyn XrpcRequest` for dynamic dispatch if needed

     

       334
       339
        
       - Client code can be generic over `impl XrpcRequest`

     

       340
       340
       +
       

     

       341
       341
       +
       

     

       342
       342
       +
       #### XRPC Errors

     

       343
       343
       +
       Lexicons contain information on the kind of errors they can return.

     

       344
       344
       +
       Trait contains an associated error type. Error enum with thiserror::Error and

     

       345
       345
       +
       miette:Diagnostic derives and appropriate content generated based on lexicon info.

     

       335
       346
        
       

     

       336
       347
        
       ### Subscriptions

     

       337
       348
        
       WebSocket streams - defer for now. Will need separate trait with message types.

+34 -1

crates/jacquard-common/src/into_static.rs

···

       1
       1
        
       use std::borrow::Cow;

     

       2
       2
       +
       use std::collections::BTreeMap;

     

       2
       3
        
       use std::collections::HashMap;

     

       3
       4
        
       use std::collections::HashSet;

     

       4
       5
        
       use std::collections::VecDeque;

     
···

       67
       68
        
       }

     

       68
       69
        
       

     

       69
       70
        
       impl_into_static_passthru!(

     

       70
       70
       -
           String, u128, u64, u32, u16, u8, i128, i64, i32, i16, i8, bool, char, usize, isize, f32, f64

     

       71
       71
       +
           String,

     

       72
       72
       +
           u128,

     

       73
       73
       +
           u64,

     

       74
       74
       +
           u32,

     

       75
       75
       +
           u16,

     

       76
       76
       +
           u8,

     

       77
       77
       +
           i128,

     

       78
       78
       +
           i64,

     

       79
       79
       +
           i32,

     

       80
       80
       +
           i16,

     

       81
       81
       +
           i8,

     

       82
       82
       +
           bool,

     

       83
       83
       +
           char,

     

       84
       84
       +
           usize,

     

       85
       85
       +
           isize,

     

       86
       86
       +
           f32,

     

       87
       87
       +
           f64,

     

       88
       88
       +
           crate::smol_str::SmolStr

     

       71
       89
        
       );

     

       72
       90
        
       

     

       73
       91
        
       impl<T: IntoStatic> IntoStatic for Box<T> {

     
···

       111
       129
        
           K::Output: Eq + Hash,

     

       112
       130
        
       {

     

       113
       131
        
           type Output = HashMap<K::Output, V::Output, S>;

     

       132
       132
       +
       

     

       133
       133
       +
           fn into_static(self) -> Self::Output {

     

       134
       134
       +
               self.into_iter()

     

       135
       135
       +
                   .map(|(k, v)| (k.into_static(), v.into_static()))

     

       136
       136
       +
                   .collect()

     

       137
       137
       +
           }

     

       138
       138
       +
       }

     

       139
       139
       +
       

     

       140
       140
       +
       impl<K, V> IntoStatic for BTreeMap<K, V>

     

       141
       141
       +
       where

     

       142
       142
       +
           K: IntoStatic + Ord,

     

       143
       143
       +
           V: IntoStatic,

     

       144
       144
       +
           K::Output: Ord,

     

       145
       145
       +
       {

     

       146
       146
       +
           type Output = BTreeMap<K::Output, V::Output>;

     

       114
       147
        
       

     

       115
       148
        
           fn into_static(self) -> Self::Output {

     

       116
       149
        
               self.into_iter()

+7 -11

crates/jacquard-common/src/types/value/convert.rs

···

       1
       1
       -
       use core::{any::TypeId, fmt};

     

       2
       2
       -
       use std::{borrow::ToOwned, boxed::Box, collections::BTreeMap, vec::Vec};

     

       3
       3
       -
       

     

       4
       4
       -
       use crate::{

     

       5
       5
       -
           CowStr,

     

       6
       6
       -
           types::{

     

       7
       7
       -
               DataModelType,

     

       8
       8
       -
               cid::Cid,

     

       9
       9
       -
               string::AtprotoStr,

     

       10
       10
       -
               value::{Array, Data, Object},

     

       11
       11
       -
           },

     

       1
       1
       +
       use crate::types::{

     

       2
       2
       +
           DataModelType,

     

       3
       3
       +
           cid::Cid,

     

       4
       4
       +
           string::AtprotoStr,

     

       5
       5
       +
           value::{Array, Data, Object},

     

       12
       6
        
       };

     

       13
       7
        
       use bytes::Bytes;

     

       8
       8
       +
       use core::{any::TypeId, fmt};

     

       14
       9
        
       use smol_str::SmolStr;

     

       10
       10
       +
       use std::{borrow::ToOwned, boxed::Box, collections::BTreeMap, vec::Vec};

     

       15
       11
        
       

     

       16
       12
        
       /// Error used for converting from and into [`crate::types::value::Data`].

     

       17
       13
        
       #[derive(Clone, Debug)]

+162

crates/jacquard-lexicon/src/corpus.rs

···

       1
       1
       +
       use crate::lexicon::{LexiconDoc, LexUserType};

     

       2
       2
       +
       use jacquard_common::{into_static::IntoStatic, smol_str::SmolStr};

     

       3
       3
       +
       use std::collections::BTreeMap;

     

       4
       4
       +
       use std::fs;

     

       5
       5
       +
       use std::io;

     

       6
       6
       +
       use std::path::Path;

     

       7
       7
       +
       

     

       8
       8
       +
       /// Registry of all loaded lexicons for reference resolution

     

       9
       9
       +
       #[derive(Debug, Clone)]

     

       10
       10
       +
       pub struct LexiconCorpus {

     

       11
       11
       +
           /// Map from NSID to lexicon document

     

       12
       12
       +
           docs: BTreeMap<SmolStr, LexiconDoc<'static>>,

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       impl LexiconCorpus {

     

       16
       16
       +
           /// Create an empty corpus

     

       17
       17
       +
           pub fn new() -> Self {

     

       18
       18
       +
               Self {

     

       19
       19
       +
                   docs: BTreeMap::new(),

     

       20
       20
       +
               }

     

       21
       21
       +
           }

     

       22
       22
       +
       

     

       23
       23
       +
           /// Load all lexicons from a directory

     

       24
       24
       +
           pub fn load_from_dir(path: impl AsRef<Path>) -> io::Result<Self> {

     

       25
       25
       +
               let mut corpus = Self::new();

     

       26
       26
       +
       

     

       27
       27
       +
               let schemas = crate::fs::find_schemas(path.as_ref())?;

     

       28
       28
       +
               for schema_path in schemas {

     

       29
       29
       +
                   let content = fs::read_to_string(schema_path.as_ref())?;

     

       30
       30
       +
                   let doc: LexiconDoc = serde_json::from_str(&content).map_err(|e| {

     

       31
       31
       +
                       io::Error::new(

     

       32
       32
       +
                           io::ErrorKind::InvalidData,

     

       33
       33
       +
                           format!("Failed to parse {}: {}", schema_path.as_ref().display(), e),

     

       34
       34
       +
                       )

     

       35
       35
       +
                   })?;

     

       36
       36
       +
       

     

       37
       37
       +
                   let nsid = SmolStr::from(doc.id.to_string());

     

       38
       38
       +
                   corpus.docs.insert(nsid, doc.into_static());

     

       39
       39
       +
               }

     

       40
       40
       +
       

     

       41
       41
       +
               Ok(corpus)

     

       42
       42
       +
           }

     

       43
       43
       +
       

     

       44
       44
       +
           /// Get a lexicon document by NSID

     

       45
       45
       +
           pub fn get(&self, nsid: &str) -> Option<&LexiconDoc<'static>> {

     

       46
       46
       +
               self.docs.get(nsid)

     

       47
       47
       +
           }

     

       48
       48
       +
       

     

       49
       49
       +
           /// Resolve a reference, handling fragments

     

       50
       50
       +
           ///

     

       51
       51
       +
           /// Examples:

     

       52
       52
       +
           /// - `app.bsky.feed.post` → main def from that lexicon

     

       53
       53
       +
           /// - `app.bsky.feed.post#replyRef` → replyRef def from that lexicon

     

       54
       54
       +
           pub fn resolve_ref(&self, ref_str: &str) -> Option<(&LexiconDoc<'static>, &LexUserType<'static>)> {

     

       55
       55
       +
               let (nsid, def_name) = if let Some((nsid, fragment)) = ref_str.split_once('#') {

     

       56
       56
       +
                   (nsid, fragment)

     

       57
       57
       +
               } else {

     

       58
       58
       +
                   (ref_str, "main")

     

       59
       59
       +
               };

     

       60
       60
       +
       

     

       61
       61
       +
               let doc = self.get(nsid)?;

     

       62
       62
       +
               let def = doc.defs.get(def_name)?;

     

       63
       63
       +
               Some((doc, def))

     

       64
       64
       +
           }

     

       65
       65
       +
       

     

       66
       66
       +
           /// Check if a reference exists

     

       67
       67
       +
           pub fn ref_exists(&self, ref_str: &str) -> bool {

     

       68
       68
       +
               self.resolve_ref(ref_str).is_some()

     

       69
       69
       +
           }

     

       70
       70
       +
       

     

       71
       71
       +
           /// Iterate over all documents

     

       72
       72
       +
           pub fn iter(&self) -> impl Iterator<Item = (&SmolStr, &LexiconDoc<'static>)> {

     

       73
       73
       +
               self.docs.iter()

     

       74
       74
       +
           }

     

       75
       75
       +
       

     

       76
       76
       +
           /// Number of loaded lexicons

     

       77
       77
       +
           pub fn len(&self) -> usize {

     

       78
       78
       +
               self.docs.len()

     

       79
       79
       +
           }

     

       80
       80
       +
       

     

       81
       81
       +
           /// Check if corpus is empty

     

       82
       82
       +
           pub fn is_empty(&self) -> bool {

     

       83
       83
       +
               self.docs.is_empty()

     

       84
       84
       +
           }

     

       85
       85
       +
       }

     

       86
       86
       +
       

     

       87
       87
       +
       impl Default for LexiconCorpus {

     

       88
       88
       +
           fn default() -> Self {

     

       89
       89
       +
               Self::new()

     

       90
       90
       +
           }

     

       91
       91
       +
       }

     

       92
       92
       +
       

     

       93
       93
       +
       #[cfg(test)]

     

       94
       94
       +
       mod tests {

     

       95
       95
       +
           use super::*;

     

       96
       96
       +
           use crate::lexicon::LexUserType;

     

       97
       97
       +
       

     

       98
       98
       +
           #[test]

     

       99
       99
       +
           fn test_empty_corpus() {

     

       100
       100
       +
               let corpus = LexiconCorpus::new();

     

       101
       101
       +
               assert!(corpus.is_empty());

     

       102
       102
       +
               assert_eq!(corpus.len(), 0);

     

       103
       103
       +
           }

     

       104
       104
       +
       

     

       105
       105
       +
           #[test]

     

       106
       106
       +
           fn test_load_real_lexicons() {

     

       107
       107
       +
               let corpus = LexiconCorpus::load_from_dir("tests/fixtures/lexicons")

     

       108
       108
       +
                   .expect("failed to load lexicons");

     

       109
       109
       +
       

     

       110
       110
       +
               assert!(!corpus.is_empty());

     

       111
       111
       +
               assert_eq!(corpus.len(), 10);

     

       112
       112
       +
       

     

       113
       113
       +
               // Check that we loaded the expected lexicons

     

       114
       114
       +
               assert!(corpus.get("app.bsky.feed.post").is_some());

     

       115
       115
       +
               assert!(corpus.get("app.bsky.feed.getAuthorFeed").is_some());

     

       116
       116
       +
               assert!(corpus.get("app.bsky.richtext.facet").is_some());

     

       117
       117
       +
               assert!(corpus.get("app.bsky.embed.images").is_some());

     

       118
       118
       +
               assert!(corpus.get("com.atproto.repo.strongRef").is_some());

     

       119
       119
       +
               assert!(corpus.get("com.atproto.label.defs").is_some());

     

       120
       120
       +
           }

     

       121
       121
       +
       

     

       122
       122
       +
           #[test]

     

       123
       123
       +
           fn test_resolve_ref_without_fragment() {

     

       124
       124
       +
               let corpus = LexiconCorpus::load_from_dir("tests/fixtures/lexicons")

     

       125
       125
       +
                   .expect("failed to load lexicons");

     

       126
       126
       +
       

     

       127
       127
       +
               // Without fragment should resolve to main def

     

       128
       128
       +
               let (doc, def) = corpus

     

       129
       129
       +
                   .resolve_ref("app.bsky.feed.post")

     

       130
       130
       +
                   .expect("should resolve");

     

       131
       131
       +
               assert_eq!(doc.id.as_ref(), "app.bsky.feed.post");

     

       132
       132
       +
               assert!(matches!(def, LexUserType::Record(_)));

     

       133
       133
       +
           }

     

       134
       134
       +
       

     

       135
       135
       +
           #[test]

     

       136
       136
       +
           fn test_resolve_ref_with_fragment() {

     

       137
       137
       +
               let corpus = LexiconCorpus::load_from_dir("tests/fixtures/lexicons")

     

       138
       138
       +
                   .expect("failed to load lexicons");

     

       139
       139
       +
       

     

       140
       140
       +
               // With fragment should resolve to specific def

     

       141
       141
       +
               let (doc, def) = corpus

     

       142
       142
       +
                   .resolve_ref("app.bsky.richtext.facet#mention")

     

       143
       143
       +
                   .expect("should resolve");

     

       144
       144
       +
               assert_eq!(doc.id.as_ref(), "app.bsky.richtext.facet");

     

       145
       145
       +
               assert!(matches!(def, LexUserType::Object(_)));

     

       146
       146
       +
           }

     

       147
       147
       +
       

     

       148
       148
       +
           #[test]

     

       149
       149
       +
           fn test_ref_exists() {

     

       150
       150
       +
               let corpus = LexiconCorpus::load_from_dir("tests/fixtures/lexicons")

     

       151
       151
       +
                   .expect("failed to load lexicons");

     

       152
       152
       +
       

     

       153
       153
       +
               // Existing refs

     

       154
       154
       +
               assert!(corpus.ref_exists("app.bsky.feed.post"));

     

       155
       155
       +
               assert!(corpus.ref_exists("app.bsky.feed.post#main"));

     

       156
       156
       +
               assert!(corpus.ref_exists("app.bsky.richtext.facet#mention"));

     

       157
       157
       +
       

     

       158
       158
       +
               // Non-existing refs

     

       159
       159
       +
               assert!(!corpus.ref_exists("com.example.fake"));

     

       160
       160
       +
               assert!(!corpus.ref_exists("app.bsky.feed.post#nonexistent"));

     

       161
       161
       +
           }

     

       162
       162
       +
       }

+433 -1

crates/jacquard-lexicon/src/lexicon.rs

···

       2
       2
        
       // https://github.com/atrium-rs/atrium/blob/main/lexicon/atrium-lex/src/lexicon.rs

     

       3
       3
        
       // https://github.com/atrium-rs/atrium/blob/main/lexicon/atrium-lex/src/lib.rs

     

       4
       4
        
       

     

       5
       5
       -
       use jacquard_common::{CowStr, smol_str::SmolStr, types::blob::MimeType};

     

       5
       5
       +
       use jacquard_common::{into_static::IntoStatic, smol_str::SmolStr, types::blob::MimeType, CowStr};

     

       6
       6
        
       use serde::{Deserialize, Serialize};

     

       7
       7
        
       use serde_repr::{Deserialize_repr, Serialize_repr};

     

       8
       8
        
       use serde_with::skip_serializing_none;

     
···

       402
       402
        
           CidLink(LexCidLink<'s>),

     

       403
       403
        
           // lexUnknown

     

       404
       404
        
           Unknown(LexUnknown<'s>),

     

       405
       405
       +
       }

     

       406
       406
       +
       

     

       407
       407
       +
       // IntoStatic implementations for all lexicon types

     

       408
       408
       +
       // These enable converting borrowed lexicon docs to owned 'static versions

     

       409
       409
       +
       

     

       410
       410
       +
       macro_rules! impl_into_static_for_lex_struct {

     

       411
       411
       +
           ($($ty:ident),+ $(,)?) => {

     

       412
       412
       +
               $(

     

       413
       413
       +
                   impl IntoStatic for $ty<'_> {

     

       414
       414
       +
                       type Output = $ty<'static>;

     

       415
       415
       +
       

     

       416
       416
       +
                       fn into_static(self) -> Self::Output {

     

       417
       417
       +
                           let Self {

     

       418
       418
       +
                               $(description,)?

     

       419
       419
       +
                               ..$fields

     

       420
       420
       +
                           } = self;

     

       421
       421
       +
                           Self::Output {

     

       422
       422
       +
                               $(description: description.into_static(),)?

     

       423
       423
       +
                               ..$fields.into_static()

     

       424
       424
       +
                           }

     

       425
       425
       +
                       }

     

       426
       426
       +
                   }

     

       427
       427
       +
               )+

     

       428
       428
       +
           };

     

       429
       429
       +
       }

     

       430
       430
       +
       

     

       431
       431
       +
       // Simpler approach: just clone and convert each field

     

       432
       432
       +
       impl IntoStatic for Lexicon {

     

       433
       433
       +
           type Output = Lexicon;

     

       434
       434
       +
           fn into_static(self) -> Self::Output {

     

       435
       435
       +
               self

     

       436
       436
       +
           }

     

       437
       437
       +
       }

     

       438
       438
       +
       

     

       439
       439
       +
       impl IntoStatic for LexStringFormat {

     

       440
       440
       +
           type Output = LexStringFormat;

     

       441
       441
       +
           fn into_static(self) -> Self::Output {

     

       442
       442
       +
               self

     

       443
       443
       +
           }

     

       444
       444
       +
       }

     

       445
       445
       +
       

     

       446
       446
       +
       impl IntoStatic for LexiconDoc<'_> {

     

       447
       447
       +
           type Output = LexiconDoc<'static>;

     

       448
       448
       +
           fn into_static(self) -> Self::Output {

     

       449
       449
       +
               LexiconDoc {

     

       450
       450
       +
                   lexicon: self.lexicon,

     

       451
       451
       +
                   id: self.id.into_static(),

     

       452
       452
       +
                   revision: self.revision,

     

       453
       453
       +
                   description: self.description.into_static(),

     

       454
       454
       +
                   defs: self.defs.into_static(),

     

       455
       455
       +
               }

     

       456
       456
       +
           }

     

       457
       457
       +
       }

     

       458
       458
       +
       

     

       459
       459
       +
       impl IntoStatic for LexBoolean<'_> {

     

       460
       460
       +
           type Output = LexBoolean<'static>;

     

       461
       461
       +
           fn into_static(self) -> Self::Output {

     

       462
       462
       +
               LexBoolean {

     

       463
       463
       +
                   description: self.description.into_static(),

     

       464
       464
       +
                   default: self.default,

     

       465
       465
       +
                   r#const: self.r#const,

     

       466
       466
       +
               }

     

       467
       467
       +
           }

     

       468
       468
       +
       }

     

       469
       469
       +
       

     

       470
       470
       +
       impl IntoStatic for LexInteger<'_> {

     

       471
       471
       +
           type Output = LexInteger<'static>;

     

       472
       472
       +
           fn into_static(self) -> Self::Output {

     

       473
       473
       +
               LexInteger {

     

       474
       474
       +
                   description: self.description.into_static(),

     

       475
       475
       +
                   default: self.default,

     

       476
       476
       +
                   minimum: self.minimum,

     

       477
       477
       +
                   maximum: self.maximum,

     

       478
       478
       +
                   r#enum: self.r#enum,

     

       479
       479
       +
                   r#const: self.r#const,

     

       480
       480
       +
               }

     

       481
       481
       +
           }

     

       482
       482
       +
       }

     

       483
       483
       +
       

     

       484
       484
       +
       impl IntoStatic for LexString<'_> {

     

       485
       485
       +
           type Output = LexString<'static>;

     

       486
       486
       +
           fn into_static(self) -> Self::Output {

     

       487
       487
       +
               LexString {

     

       488
       488
       +
                   description: self.description.into_static(),

     

       489
       489
       +
                   format: self.format,

     

       490
       490
       +
                   default: self.default.into_static(),

     

       491
       491
       +
                   min_length: self.min_length,

     

       492
       492
       +
                   max_length: self.max_length,

     

       493
       493
       +
                   min_graphemes: self.min_graphemes,

     

       494
       494
       +
                   max_graphemes: self.max_graphemes,

     

       495
       495
       +
                   r#enum: self.r#enum.into_static(),

     

       496
       496
       +
                   r#const: self.r#const.into_static(),

     

       497
       497
       +
                   known_values: self.known_values.into_static(),

     

       498
       498
       +
               }

     

       499
       499
       +
           }

     

       500
       500
       +
       }

     

       501
       501
       +
       

     

       502
       502
       +
       impl IntoStatic for LexUnknown<'_> {

     

       503
       503
       +
           type Output = LexUnknown<'static>;

     

       504
       504
       +
           fn into_static(self) -> Self::Output {

     

       505
       505
       +
               LexUnknown {

     

       506
       506
       +
                   description: self.description.into_static(),

     

       507
       507
       +
               }

     

       508
       508
       +
           }

     

       509
       509
       +
       }

     

       510
       510
       +
       

     

       511
       511
       +
       impl IntoStatic for LexBytes<'_> {

     

       512
       512
       +
           type Output = LexBytes<'static>;

     

       513
       513
       +
           fn into_static(self) -> Self::Output {

     

       514
       514
       +
               LexBytes {

     

       515
       515
       +
                   description: self.description.into_static(),

     

       516
       516
       +
                   max_length: self.max_length,

     

       517
       517
       +
                   min_length: self.min_length,

     

       518
       518
       +
               }

     

       519
       519
       +
           }

     

       520
       520
       +
       }

     

       521
       521
       +
       

     

       522
       522
       +
       impl IntoStatic for LexCidLink<'_> {

     

       523
       523
       +
           type Output = LexCidLink<'static>;

     

       524
       524
       +
           fn into_static(self) -> Self::Output {

     

       525
       525
       +
               LexCidLink {

     

       526
       526
       +
                   description: self.description.into_static(),

     

       527
       527
       +
               }

     

       528
       528
       +
           }

     

       529
       529
       +
       }

     

       530
       530
       +
       

     

       531
       531
       +
       impl IntoStatic for LexRef<'_> {

     

       532
       532
       +
           type Output = LexRef<'static>;

     

       533
       533
       +
           fn into_static(self) -> Self::Output {

     

       534
       534
       +
               LexRef {

     

       535
       535
       +
                   description: self.description.into_static(),

     

       536
       536
       +
                   r#ref: self.r#ref.into_static(),

     

       537
       537
       +
               }

     

       538
       538
       +
           }

     

       539
       539
       +
       }

     

       540
       540
       +
       

     

       541
       541
       +
       impl IntoStatic for LexRefUnion<'_> {

     

       542
       542
       +
           type Output = LexRefUnion<'static>;

     

       543
       543
       +
           fn into_static(self) -> Self::Output {

     

       544
       544
       +
               LexRefUnion {

     

       545
       545
       +
                   description: self.description.into_static(),

     

       546
       546
       +
                   refs: self.refs.into_static(),

     

       547
       547
       +
                   closed: self.closed,

     

       548
       548
       +
               }

     

       549
       549
       +
           }

     

       550
       550
       +
       }

     

       551
       551
       +
       

     

       552
       552
       +
       impl IntoStatic for LexBlob<'_> {

     

       553
       553
       +
           type Output = LexBlob<'static>;

     

       554
       554
       +
           fn into_static(self) -> Self::Output {

     

       555
       555
       +
               LexBlob {

     

       556
       556
       +
                   description: self.description.into_static(),

     

       557
       557
       +
                   accept: self.accept.into_static(),

     

       558
       558
       +
                   max_size: self.max_size,

     

       559
       559
       +
               }

     

       560
       560
       +
           }

     

       561
       561
       +
       }

     

       562
       562
       +
       

     

       563
       563
       +
       impl IntoStatic for LexArrayItem<'_> {

     

       564
       564
       +
           type Output = LexArrayItem<'static>;

     

       565
       565
       +
           fn into_static(self) -> Self::Output {

     

       566
       566
       +
               match self {

     

       567
       567
       +
                   Self::Boolean(x) => LexArrayItem::Boolean(x.into_static()),

     

       568
       568
       +
                   Self::Integer(x) => LexArrayItem::Integer(x.into_static()),

     

       569
       569
       +
                   Self::String(x) => LexArrayItem::String(x.into_static()),

     

       570
       570
       +
                   Self::Unknown(x) => LexArrayItem::Unknown(x.into_static()),

     

       571
       571
       +
                   Self::Bytes(x) => LexArrayItem::Bytes(x.into_static()),

     

       572
       572
       +
                   Self::CidLink(x) => LexArrayItem::CidLink(x.into_static()),

     

       573
       573
       +
                   Self::Blob(x) => LexArrayItem::Blob(x.into_static()),

     

       574
       574
       +
                   Self::Ref(x) => LexArrayItem::Ref(x.into_static()),

     

       575
       575
       +
                   Self::Union(x) => LexArrayItem::Union(x.into_static()),

     

       576
       576
       +
               }

     

       577
       577
       +
           }

     

       578
       578
       +
       }

     

       579
       579
       +
       

     

       580
       580
       +
       impl IntoStatic for LexArray<'_> {

     

       581
       581
       +
           type Output = LexArray<'static>;

     

       582
       582
       +
           fn into_static(self) -> Self::Output {

     

       583
       583
       +
               LexArray {

     

       584
       584
       +
                   description: self.description.into_static(),

     

       585
       585
       +
                   items: self.items.into_static(),

     

       586
       586
       +
                   min_length: self.min_length,

     

       587
       587
       +
                   max_length: self.max_length,

     

       588
       588
       +
               }

     

       589
       589
       +
           }

     

       590
       590
       +
       }

     

       591
       591
       +
       

     

       592
       592
       +
       impl IntoStatic for LexPrimitiveArrayItem<'_> {

     

       593
       593
       +
           type Output = LexPrimitiveArrayItem<'static>;

     

       594
       594
       +
           fn into_static(self) -> Self::Output {

     

       595
       595
       +
               match self {

     

       596
       596
       +
                   Self::Boolean(x) => LexPrimitiveArrayItem::Boolean(x.into_static()),

     

       597
       597
       +
                   Self::Integer(x) => LexPrimitiveArrayItem::Integer(x.into_static()),

     

       598
       598
       +
                   Self::String(x) => LexPrimitiveArrayItem::String(x.into_static()),

     

       599
       599
       +
                   Self::Unknown(x) => LexPrimitiveArrayItem::Unknown(x.into_static()),

     

       600
       600
       +
               }

     

       601
       601
       +
           }

     

       602
       602
       +
       }

     

       603
       603
       +
       

     

       604
       604
       +
       impl IntoStatic for LexPrimitiveArray<'_> {

     

       605
       605
       +
           type Output = LexPrimitiveArray<'static>;

     

       606
       606
       +
           fn into_static(self) -> Self::Output {

     

       607
       607
       +
               LexPrimitiveArray {

     

       608
       608
       +
                   description: self.description.into_static(),

     

       609
       609
       +
                   items: self.items.into_static(),

     

       610
       610
       +
                   min_length: self.min_length,

     

       611
       611
       +
                   max_length: self.max_length,

     

       612
       612
       +
               }

     

       613
       613
       +
           }

     

       614
       614
       +
       }

     

       615
       615
       +
       

     

       616
       616
       +
       impl IntoStatic for LexToken<'_> {

     

       617
       617
       +
           type Output = LexToken<'static>;

     

       618
       618
       +
           fn into_static(self) -> Self::Output {

     

       619
       619
       +
               LexToken {

     

       620
       620
       +
                   description: self.description.into_static(),

     

       621
       621
       +
               }

     

       622
       622
       +
           }

     

       623
       623
       +
       }

     

       624
       624
       +
       

     

       625
       625
       +
       impl IntoStatic for LexObjectProperty<'_> {

     

       626
       626
       +
           type Output = LexObjectProperty<'static>;

     

       627
       627
       +
           fn into_static(self) -> Self::Output {

     

       628
       628
       +
               match self {

     

       629
       629
       +
                   Self::Ref(x) => LexObjectProperty::Ref(x.into_static()),

     

       630
       630
       +
                   Self::Union(x) => LexObjectProperty::Union(x.into_static()),

     

       631
       631
       +
                   Self::Bytes(x) => LexObjectProperty::Bytes(x.into_static()),

     

       632
       632
       +
                   Self::CidLink(x) => LexObjectProperty::CidLink(x.into_static()),

     

       633
       633
       +
                   Self::Array(x) => LexObjectProperty::Array(x.into_static()),

     

       634
       634
       +
                   Self::Blob(x) => LexObjectProperty::Blob(x.into_static()),

     

       635
       635
       +
                   Self::Boolean(x) => LexObjectProperty::Boolean(x.into_static()),

     

       636
       636
       +
                   Self::Integer(x) => LexObjectProperty::Integer(x.into_static()),

     

       637
       637
       +
                   Self::String(x) => LexObjectProperty::String(x.into_static()),

     

       638
       638
       +
                   Self::Unknown(x) => LexObjectProperty::Unknown(x.into_static()),

     

       639
       639
       +
               }

     

       640
       640
       +
           }

     

       641
       641
       +
       }

     

       642
       642
       +
       

     

       643
       643
       +
       impl IntoStatic for LexObject<'_> {

     

       644
       644
       +
           type Output = LexObject<'static>;

     

       645
       645
       +
           fn into_static(self) -> Self::Output {

     

       646
       646
       +
               LexObject {

     

       647
       647
       +
                   description: self.description.into_static(),

     

       648
       648
       +
                   required: self.required,

     

       649
       649
       +
                   nullable: self.nullable,

     

       650
       650
       +
                   properties: self.properties.into_static(),

     

       651
       651
       +
               }

     

       652
       652
       +
           }

     

       653
       653
       +
       }

     

       654
       654
       +
       

     

       655
       655
       +
       impl IntoStatic for LexXrpcParametersProperty<'_> {

     

       656
       656
       +
           type Output = LexXrpcParametersProperty<'static>;

     

       657
       657
       +
           fn into_static(self) -> Self::Output {

     

       658
       658
       +
               match self {

     

       659
       659
       +
                   Self::Boolean(x) => LexXrpcParametersProperty::Boolean(x.into_static()),

     

       660
       660
       +
                   Self::Integer(x) => LexXrpcParametersProperty::Integer(x.into_static()),

     

       661
       661
       +
                   Self::String(x) => LexXrpcParametersProperty::String(x.into_static()),

     

       662
       662
       +
                   Self::Unknown(x) => LexXrpcParametersProperty::Unknown(x.into_static()),

     

       663
       663
       +
                   Self::Array(x) => LexXrpcParametersProperty::Array(x.into_static()),

     

       664
       664
       +
               }

     

       665
       665
       +
           }

     

       666
       666
       +
       }

     

       667
       667
       +
       

     

       668
       668
       +
       impl IntoStatic for LexXrpcParameters<'_> {

     

       669
       669
       +
           type Output = LexXrpcParameters<'static>;

     

       670
       670
       +
           fn into_static(self) -> Self::Output {

     

       671
       671
       +
               LexXrpcParameters {

     

       672
       672
       +
                   description: self.description.into_static(),

     

       673
       673
       +
                   required: self.required,

     

       674
       674
       +
                   properties: self.properties.into_static(),

     

       675
       675
       +
               }

     

       676
       676
       +
           }

     

       677
       677
       +
       }

     

       678
       678
       +
       

     

       679
       679
       +
       impl IntoStatic for LexXrpcBodySchema<'_> {

     

       680
       680
       +
           type Output = LexXrpcBodySchema<'static>;

     

       681
       681
       +
           fn into_static(self) -> Self::Output {

     

       682
       682
       +
               match self {

     

       683
       683
       +
                   Self::Ref(x) => LexXrpcBodySchema::Ref(x.into_static()),

     

       684
       684
       +
                   Self::Union(x) => LexXrpcBodySchema::Union(x.into_static()),

     

       685
       685
       +
                   Self::Object(x) => LexXrpcBodySchema::Object(x.into_static()),

     

       686
       686
       +
               }

     

       687
       687
       +
           }

     

       688
       688
       +
       }

     

       689
       689
       +
       

     

       690
       690
       +
       impl IntoStatic for LexXrpcBody<'_> {

     

       691
       691
       +
           type Output = LexXrpcBody<'static>;

     

       692
       692
       +
           fn into_static(self) -> Self::Output {

     

       693
       693
       +
               LexXrpcBody {

     

       694
       694
       +
                   description: self.description.into_static(),

     

       695
       695
       +
                   encoding: self.encoding.into_static(),

     

       696
       696
       +
                   schema: self.schema.into_static(),

     

       697
       697
       +
               }

     

       698
       698
       +
           }

     

       699
       699
       +
       }

     

       700
       700
       +
       

     

       701
       701
       +
       impl IntoStatic for LexXrpcSubscriptionMessageSchema<'_> {

     

       702
       702
       +
           type Output = LexXrpcSubscriptionMessageSchema<'static>;

     

       703
       703
       +
           fn into_static(self) -> Self::Output {

     

       704
       704
       +
               match self {

     

       705
       705
       +
                   Self::Ref(x) => LexXrpcSubscriptionMessageSchema::Ref(x.into_static()),

     

       706
       706
       +
                   Self::Union(x) => LexXrpcSubscriptionMessageSchema::Union(x.into_static()),

     

       707
       707
       +
                   Self::Object(x) => LexXrpcSubscriptionMessageSchema::Object(x.into_static()),

     

       708
       708
       +
               }

     

       709
       709
       +
           }

     

       710
       710
       +
       }

     

       711
       711
       +
       

     

       712
       712
       +
       impl IntoStatic for LexXrpcSubscriptionMessage<'_> {

     

       713
       713
       +
           type Output = LexXrpcSubscriptionMessage<'static>;

     

       714
       714
       +
           fn into_static(self) -> Self::Output {

     

       715
       715
       +
               LexXrpcSubscriptionMessage {

     

       716
       716
       +
                   description: self.description.into_static(),

     

       717
       717
       +
                   schema: self.schema.into_static(),

     

       718
       718
       +
               }

     

       719
       719
       +
           }

     

       720
       720
       +
       }

     

       721
       721
       +
       

     

       722
       722
       +
       impl IntoStatic for LexXrpcError<'_> {

     

       723
       723
       +
           type Output = LexXrpcError<'static>;

     

       724
       724
       +
           fn into_static(self) -> Self::Output {

     

       725
       725
       +
               LexXrpcError {

     

       726
       726
       +
                   description: self.description.into_static(),

     

       727
       727
       +
                   name: self.name.into_static(),

     

       728
       728
       +
               }

     

       729
       729
       +
           }

     

       730
       730
       +
       }

     

       731
       731
       +
       

     

       732
       732
       +
       impl IntoStatic for LexXrpcQueryParameter<'_> {

     

       733
       733
       +
           type Output = LexXrpcQueryParameter<'static>;

     

       734
       734
       +
           fn into_static(self) -> Self::Output {

     

       735
       735
       +
               match self {

     

       736
       736
       +
                   Self::Params(x) => LexXrpcQueryParameter::Params(x.into_static()),

     

       737
       737
       +
               }

     

       738
       738
       +
           }

     

       739
       739
       +
       }

     

       740
       740
       +
       

     

       741
       741
       +
       impl IntoStatic for LexXrpcQuery<'_> {

     

       742
       742
       +
           type Output = LexXrpcQuery<'static>;

     

       743
       743
       +
           fn into_static(self) -> Self::Output {

     

       744
       744
       +
               LexXrpcQuery {

     

       745
       745
       +
                   description: self.description.into_static(),

     

       746
       746
       +
                   parameters: self.parameters.into_static(),

     

       747
       747
       +
                   output: self.output.into_static(),

     

       748
       748
       +
                   errors: self.errors.into_static(),

     

       749
       749
       +
               }

     

       750
       750
       +
           }

     

       751
       751
       +
       }

     

       752
       752
       +
       

     

       753
       753
       +
       impl IntoStatic for LexXrpcProcedureParameter<'_> {

     

       754
       754
       +
           type Output = LexXrpcProcedureParameter<'static>;

     

       755
       755
       +
           fn into_static(self) -> Self::Output {

     

       756
       756
       +
               match self {

     

       757
       757
       +
                   Self::Params(x) => LexXrpcProcedureParameter::Params(x.into_static()),

     

       758
       758
       +
               }

     

       759
       759
       +
           }

     

       760
       760
       +
       }

     

       761
       761
       +
       

     

       762
       762
       +
       impl IntoStatic for LexXrpcProcedure<'_> {

     

       763
       763
       +
           type Output = LexXrpcProcedure<'static>;

     

       764
       764
       +
           fn into_static(self) -> Self::Output {

     

       765
       765
       +
               LexXrpcProcedure {

     

       766
       766
       +
                   description: self.description.into_static(),

     

       767
       767
       +
                   parameters: self.parameters.into_static(),

     

       768
       768
       +
                   input: self.input.into_static(),

     

       769
       769
       +
                   output: self.output.into_static(),

     

       770
       770
       +
                   errors: self.errors.into_static(),

     

       771
       771
       +
               }

     

       772
       772
       +
           }

     

       773
       773
       +
       }

     

       774
       774
       +
       

     

       775
       775
       +
       impl IntoStatic for LexXrpcSubscriptionParameter<'_> {

     

       776
       776
       +
           type Output = LexXrpcSubscriptionParameter<'static>;

     

       777
       777
       +
           fn into_static(self) -> Self::Output {

     

       778
       778
       +
               match self {

     

       779
       779
       +
                   Self::Params(x) => LexXrpcSubscriptionParameter::Params(x.into_static()),

     

       780
       780
       +
               }

     

       781
       781
       +
           }

     

       782
       782
       +
       }

     

       783
       783
       +
       

     

       784
       784
       +
       impl IntoStatic for LexXrpcSubscription<'_> {

     

       785
       785
       +
           type Output = LexXrpcSubscription<'static>;

     

       786
       786
       +
           fn into_static(self) -> Self::Output {

     

       787
       787
       +
               LexXrpcSubscription {

     

       788
       788
       +
                   description: self.description.into_static(),

     

       789
       789
       +
                   parameters: self.parameters.into_static(),

     

       790
       790
       +
                   message: self.message.into_static(),

     

       791
       791
       +
                   infos: self.infos.into_static(),

     

       792
       792
       +
                   errors: self.errors.into_static(),

     

       793
       793
       +
               }

     

       794
       794
       +
           }

     

       795
       795
       +
       }

     

       796
       796
       +
       

     

       797
       797
       +
       impl IntoStatic for LexRecordRecord<'_> {

     

       798
       798
       +
           type Output = LexRecordRecord<'static>;

     

       799
       799
       +
           fn into_static(self) -> Self::Output {

     

       800
       800
       +
               match self {

     

       801
       801
       +
                   Self::Object(x) => LexRecordRecord::Object(x.into_static()),

     

       802
       802
       +
               }

     

       803
       803
       +
           }

     

       804
       804
       +
       }

     

       805
       805
       +
       

     

       806
       806
       +
       impl IntoStatic for LexRecord<'_> {

     

       807
       807
       +
           type Output = LexRecord<'static>;

     

       808
       808
       +
           fn into_static(self) -> Self::Output {

     

       809
       809
       +
               LexRecord {

     

       810
       810
       +
                   description: self.description.into_static(),

     

       811
       811
       +
                   key: self.key.into_static(),

     

       812
       812
       +
                   record: self.record.into_static(),

     

       813
       813
       +
               }

     

       814
       814
       +
           }

     

       815
       815
       +
       }

     

       816
       816
       +
       

     

       817
       817
       +
       impl IntoStatic for LexUserType<'_> {

     

       818
       818
       +
           type Output = LexUserType<'static>;

     

       819
       819
       +
           fn into_static(self) -> Self::Output {

     

       820
       820
       +
               match self {

     

       821
       821
       +
                   Self::Record(x) => LexUserType::Record(x.into_static()),

     

       822
       822
       +
                   Self::XrpcQuery(x) => LexUserType::XrpcQuery(x.into_static()),

     

       823
       823
       +
                   Self::XrpcProcedure(x) => LexUserType::XrpcProcedure(x.into_static()),

     

       824
       824
       +
                   Self::XrpcSubscription(x) => LexUserType::XrpcSubscription(x.into_static()),

     

       825
       825
       +
                   Self::Blob(x) => LexUserType::Blob(x.into_static()),

     

       826
       826
       +
                   Self::Array(x) => LexUserType::Array(x.into_static()),

     

       827
       827
       +
                   Self::Token(x) => LexUserType::Token(x.into_static()),

     

       828
       828
       +
                   Self::Object(x) => LexUserType::Object(x.into_static()),

     

       829
       829
       +
                   Self::Boolean(x) => LexUserType::Boolean(x.into_static()),

     

       830
       830
       +
                   Self::Integer(x) => LexUserType::Integer(x.into_static()),

     

       831
       831
       +
                   Self::String(x) => LexUserType::String(x.into_static()),

     

       832
       832
       +
                   Self::Bytes(x) => LexUserType::Bytes(x.into_static()),

     

       833
       833
       +
                   Self::CidLink(x) => LexUserType::CidLink(x.into_static()),

     

       834
       834
       +
                   Self::Unknown(x) => LexUserType::Unknown(x.into_static()),

     

       835
       835
       +
               }

     

       836
       836
       +
           }

     

       405
       837
        
       }

     

       406
       838
        
       

     

       407
       839
        
       #[cfg(test)]

crates/jacquard-lexicon/src/lib.rs

···

       1
       1
       +
       pub mod corpus;

     

       1
       2
        
       pub mod fs;

     

       2
       3
        
       pub mod lexicon;

     

       3
       4
        
       pub mod output;

+156

crates/jacquard-lexicon/tests/fixtures/lexicons/defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "com.atproto.label.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "label": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "description": "Metadata tag on an atproto resource (eg, repo or record).",

     

       8
       8
       +
             "required": ["src", "uri", "val", "cts"],

     

       9
       9
       +
             "properties": {

     

       10
       10
       +
               "ver": {

     

       11
       11
       +
                 "type": "integer",

     

       12
       12
       +
                 "description": "The AT Protocol version of the label object."

     

       13
       13
       +
               },

     

       14
       14
       +
               "src": {

     

       15
       15
       +
                 "type": "string",

     

       16
       16
       +
                 "format": "did",

     

       17
       17
       +
                 "description": "DID of the actor who created this label."

     

       18
       18
       +
               },

     

       19
       19
       +
               "uri": {

     

       20
       20
       +
                 "type": "string",

     

       21
       21
       +
                 "format": "uri",

     

       22
       22
       +
                 "description": "AT URI of the record, repository (account), or other resource that this label applies to."

     

       23
       23
       +
               },

     

       24
       24
       +
               "cid": {

     

       25
       25
       +
                 "type": "string",

     

       26
       26
       +
                 "format": "cid",

     

       27
       27
       +
                 "description": "Optionally, CID specifying the specific version of 'uri' resource this label applies to."

     

       28
       28
       +
               },

     

       29
       29
       +
               "val": {

     

       30
       30
       +
                 "type": "string",

     

       31
       31
       +
                 "maxLength": 128,

     

       32
       32
       +
                 "description": "The short string name of the value or type of this label."

     

       33
       33
       +
               },

     

       34
       34
       +
               "neg": {

     

       35
       35
       +
                 "type": "boolean",

     

       36
       36
       +
                 "description": "If true, this is a negation label, overwriting a previous label."

     

       37
       37
       +
               },

     

       38
       38
       +
               "cts": {

     

       39
       39
       +
                 "type": "string",

     

       40
       40
       +
                 "format": "datetime",

     

       41
       41
       +
                 "description": "Timestamp when this label was created."

     

       42
       42
       +
               },

     

       43
       43
       +
               "exp": {

     

       44
       44
       +
                 "type": "string",

     

       45
       45
       +
                 "format": "datetime",

     

       46
       46
       +
                 "description": "Timestamp at which this label expires (no longer applies)."

     

       47
       47
       +
               },

     

       48
       48
       +
               "sig": {

     

       49
       49
       +
                 "type": "bytes",

     

       50
       50
       +
                 "description": "Signature of dag-cbor encoded label."

     

       51
       51
       +
               }

     

       52
       52
       +
             }

     

       53
       53
       +
           },

     

       54
       54
       +
           "selfLabels": {

     

       55
       55
       +
             "type": "object",

     

       56
       56
       +
             "description": "Metadata tags on an atproto record, published by the author within the record.",

     

       57
       57
       +
             "required": ["values"],

     

       58
       58
       +
             "properties": {

     

       59
       59
       +
               "values": {

     

       60
       60
       +
                 "type": "array",

     

       61
       61
       +
                 "items": { "type": "ref", "ref": "#selfLabel" },

     

       62
       62
       +
                 "maxLength": 10

     

       63
       63
       +
               }

     

       64
       64
       +
             }

     

       65
       65
       +
           },

     

       66
       66
       +
           "selfLabel": {

     

       67
       67
       +
             "type": "object",

     

       68
       68
       +
             "description": "Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel.",

     

       69
       69
       +
             "required": ["val"],

     

       70
       70
       +
             "properties": {

     

       71
       71
       +
               "val": {

     

       72
       72
       +
                 "type": "string",

     

       73
       73
       +
                 "maxLength": 128,

     

       74
       74
       +
                 "description": "The short string name of the value or type of this label."

     

       75
       75
       +
               }

     

       76
       76
       +
             }

     

       77
       77
       +
           },

     

       78
       78
       +
           "labelValueDefinition": {

     

       79
       79
       +
             "type": "object",

     

       80
       80
       +
             "description": "Declares a label value and its expected interpretations and behaviors.",

     

       81
       81
       +
             "required": ["identifier", "severity", "blurs", "locales"],

     

       82
       82
       +
             "properties": {

     

       83
       83
       +
               "identifier": {

     

       84
       84
       +
                 "type": "string",

     

       85
       85
       +
                 "description": "The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+).",

     

       86
       86
       +
                 "maxLength": 100,

     

       87
       87
       +
                 "maxGraphemes": 100

     

       88
       88
       +
               },

     

       89
       89
       +
               "severity": {

     

       90
       90
       +
                 "type": "string",

     

       91
       91
       +
                 "description": "How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing.",

     

       92
       92
       +
                 "knownValues": ["inform", "alert", "none"]

     

       93
       93
       +
               },

     

       94
       94
       +
               "blurs": {

     

       95
       95
       +
                 "type": "string",

     

       96
       96
       +
                 "description": "What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing.",

     

       97
       97
       +
                 "knownValues": ["content", "media", "none"]

     

       98
       98
       +
               },

     

       99
       99
       +
               "defaultSetting": {

     

       100
       100
       +
                 "type": "string",

     

       101
       101
       +
                 "description": "The default setting for this label.",

     

       102
       102
       +
                 "knownValues": ["ignore", "warn", "hide"],

     

       103
       103
       +
                 "default": "warn"

     

       104
       104
       +
               },

     

       105
       105
       +
               "adultOnly": {

     

       106
       106
       +
                 "type": "boolean",

     

       107
       107
       +
                 "description": "Does the user need to have adult content enabled in order to configure this label?"

     

       108
       108
       +
               },

     

       109
       109
       +
               "locales": {

     

       110
       110
       +
                 "type": "array",

     

       111
       111
       +
                 "items": { "type": "ref", "ref": "#labelValueDefinitionStrings" }

     

       112
       112
       +
               }

     

       113
       113
       +
             }

     

       114
       114
       +
           },

     

       115
       115
       +
           "labelValueDefinitionStrings": {

     

       116
       116
       +
             "type": "object",

     

       117
       117
       +
             "description": "Strings which describe the label in the UI, localized into a specific language.",

     

       118
       118
       +
             "required": ["lang", "name", "description"],

     

       119
       119
       +
             "properties": {

     

       120
       120
       +
               "lang": {

     

       121
       121
       +
                 "type": "string",

     

       122
       122
       +
                 "description": "The code of the language these strings are written in.",

     

       123
       123
       +
                 "format": "language"

     

       124
       124
       +
               },

     

       125
       125
       +
               "name": {

     

       126
       126
       +
                 "type": "string",

     

       127
       127
       +
                 "description": "A short human-readable name for the label.",

     

       128
       128
       +
                 "maxGraphemes": 64,

     

       129
       129
       +
                 "maxLength": 640

     

       130
       130
       +
               },

     

       131
       131
       +
               "description": {

     

       132
       132
       +
                 "type": "string",

     

       133
       133
       +
                 "description": "A longer description of what the label means and why it might be applied.",

     

       134
       134
       +
                 "maxGraphemes": 10000,

     

       135
       135
       +
                 "maxLength": 100000

     

       136
       136
       +
               }

     

       137
       137
       +
             }

     

       138
       138
       +
           },

     

       139
       139
       +
           "labelValue": {

     

       140
       140
       +
             "type": "string",

     

       141
       141
       +
             "knownValues": [

     

       142
       142
       +
               "!hide",

     

       143
       143
       +
               "!no-promote",

     

       144
       144
       +
               "!warn",

     

       145
       145
       +
               "!no-unauthenticated",

     

       146
       146
       +
               "dmca-violation",

     

       147
       147
       +
               "doxxing",

     

       148
       148
       +
               "porn",

     

       149
       149
       +
               "sexual",

     

       150
       150
       +
               "nudity",

     

       151
       151
       +
               "nsfl",

     

       152
       152
       +
               "gore"

     

       153
       153
       +
             ]

     

       154
       154
       +
           }

     

       155
       155
       +
         }

     

       156
       156
       +
       }

+51

crates/jacquard-lexicon/tests/fixtures/lexicons/external.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.bsky.embed.external",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "description": "A representation of some externally linked content (eg, a URL and 'card'), embedded in a Bluesky record (eg, a post).",

     

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

     

       9
       9
       +
             "properties": {

     

       10
       10
       +
               "external": {

     

       11
       11
       +
                 "type": "ref",

     

       12
       12
       +
                 "ref": "#external"

     

       13
       13
       +
               }

     

       14
       14
       +
             }

     

       15
       15
       +
           },

     

       16
       16
       +
           "external": {

     

       17
       17
       +
             "type": "object",

     

       18
       18
       +
             "required": ["uri", "title", "description"],

     

       19
       19
       +
             "properties": {

     

       20
       20
       +
               "uri": { "type": "string", "format": "uri" },

     

       21
       21
       +
               "title": { "type": "string" },

     

       22
       22
       +
               "description": { "type": "string" },

     

       23
       23
       +
               "thumb": {

     

       24
       24
       +
                 "type": "blob",

     

       25
       25
       +
                 "accept": ["image/*"],

     

       26
       26
       +
                 "maxSize": 1000000

     

       27
       27
       +
               }

     

       28
       28
       +
             }

     

       29
       29
       +
           },

     

       30
       30
       +
           "view": {

     

       31
       31
       +
             "type": "object",

     

       32
       32
       +
             "required": ["external"],

     

       33
       33
       +
             "properties": {

     

       34
       34
       +
               "external": {

     

       35
       35
       +
                 "type": "ref",

     

       36
       36
       +
                 "ref": "#viewExternal"

     

       37
       37
       +
               }

     

       38
       38
       +
             }

     

       39
       39
       +
           },

     

       40
       40
       +
           "viewExternal": {

     

       41
       41
       +
             "type": "object",

     

       42
       42
       +
             "required": ["uri", "title", "description"],

     

       43
       43
       +
             "properties": {

     

       44
       44
       +
               "uri": { "type": "string", "format": "uri" },

     

       45
       45
       +
               "title": { "type": "string" },

     

       46
       46
       +
               "description": { "type": "string" },

     

       47
       47
       +
               "thumb": { "type": "string", "format": "uri" }

     

       48
       48
       +
             }

     

       49
       49
       +
           }

     

       50
       50
       +
         }

     

       51
       51
       +
       }

+51

crates/jacquard-lexicon/tests/fixtures/lexicons/facet.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.bsky.richtext.facet",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "description": "Annotation of a sub-string within rich text.",

     

       8
       8
       +
             "required": ["index", "features"],

     

       9
       9
       +
             "properties": {

     

       10
       10
       +
               "index": { "type": "ref", "ref": "#byteSlice" },

     

       11
       11
       +
               "features": {

     

       12
       12
       +
                 "type": "array",

     

       13
       13
       +
                 "items": { "type": "union", "refs": ["#mention", "#link", "#tag"] }

     

       14
       14
       +
               }

     

       15
       15
       +
             }

     

       16
       16
       +
           },

     

       17
       17
       +
           "mention": {

     

       18
       18
       +
             "type": "object",

     

       19
       19
       +
             "description": "Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID.",

     

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

     

       21
       21
       +
             "properties": {

     

       22
       22
       +
               "did": { "type": "string", "format": "did" }

     

       23
       23
       +
             }

     

       24
       24
       +
           },

     

       25
       25
       +
           "link": {

     

       26
       26
       +
             "type": "object",

     

       27
       27
       +
             "description": "Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.",

     

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

     

       29
       29
       +
             "properties": {

     

       30
       30
       +
               "uri": { "type": "string", "format": "uri" }

     

       31
       31
       +
             }

     

       32
       32
       +
           },

     

       33
       33
       +
           "tag": {

     

       34
       34
       +
             "type": "object",

     

       35
       35
       +
             "description": "Facet feature for a hashtag. The text usually includes a '#' prefix, but the facet reference should not (except in the case of 'double hash tags').",

     

       36
       36
       +
             "required": ["tag"],

     

       37
       37
       +
             "properties": {

     

       38
       38
       +
               "tag": { "type": "string", "maxLength": 640, "maxGraphemes": 64 }

     

       39
       39
       +
             }

     

       40
       40
       +
           },

     

       41
       41
       +
           "byteSlice": {

     

       42
       42
       +
             "type": "object",

     

       43
       43
       +
             "description": "Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets.",

     

       44
       44
       +
             "required": ["byteStart", "byteEnd"],

     

       45
       45
       +
             "properties": {

     

       46
       46
       +
               "byteStart": { "type": "integer", "minimum": 0 },

     

       47
       47
       +
               "byteEnd": { "type": "integer", "minimum": 0 }

     

       48
       48
       +
             }

     

       49
       49
       +
           }

     

       50
       50
       +
         }

     

       51
       51
       +
       }

+58

crates/jacquard-lexicon/tests/fixtures/lexicons/getAuthorFeed.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.bsky.feed.getAuthorFeed",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get a view of an actor's 'author feed' (post and reposts by the author). Does not require auth.",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

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

     

       11
       11
       +
               "properties": {

     

       12
       12
       +
                 "actor": { "type": "string", "format": "at-identifier" },

     

       13
       13
       +
                 "limit": {

     

       14
       14
       +
                   "type": "integer",

     

       15
       15
       +
                   "minimum": 1,

     

       16
       16
       +
                   "maximum": 100,

     

       17
       17
       +
                   "default": 50

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "cursor": { "type": "string" },

     

       20
       20
       +
                 "filter": {

     

       21
       21
       +
                   "type": "string",

     

       22
       22
       +
                   "description": "Combinations of post/repost types to include in response.",

     

       23
       23
       +
                   "knownValues": [

     

       24
       24
       +
                     "posts_with_replies",

     

       25
       25
       +
                     "posts_no_replies",

     

       26
       26
       +
                     "posts_with_media",

     

       27
       27
       +
                     "posts_and_author_threads",

     

       28
       28
       +
                     "posts_with_video"

     

       29
       29
       +
                   ],

     

       30
       30
       +
                   "default": "posts_with_replies"

     

       31
       31
       +
                 },

     

       32
       32
       +
                 "includePins": {

     

       33
       33
       +
                   "type": "boolean",

     

       34
       34
       +
                   "default": false

     

       35
       35
       +
                 }

     

       36
       36
       +
               }

     

       37
       37
       +
             },

     

       38
       38
       +
             "output": {

     

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

     

       40
       40
       +
               "schema": {

     

       41
       41
       +
                 "type": "object",

     

       42
       42
       +
                 "required": ["feed"],

     

       43
       43
       +
                 "properties": {

     

       44
       44
       +
                   "cursor": { "type": "string" },

     

       45
       45
       +
                   "feed": {

     

       46
       46
       +
                     "type": "array",

     

       47
       47
       +
                     "items": {

     

       48
       48
       +
                       "type": "ref",

     

       49
       49
       +
                       "ref": "app.bsky.feed.defs#feedViewPost"

     

       50
       50
       +
                     }

     

       51
       51
       +
                   }

     

       52
       52
       +
                 }

     

       53
       53
       +
               }

     

       54
       54
       +
             },

     

       55
       55
       +
             "errors": [{ "name": "BlockedActor" }, { "name": "BlockedByActor" }]

     

       56
       56
       +
           }

     

       57
       57
       +
         }

     

       58
       58
       +
       }

+72

crates/jacquard-lexicon/tests/fixtures/lexicons/images.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.bsky.embed.images",

     

       4
       4
       +
         "description": "A set of images embedded in a Bluesky record (eg, a post).",

     

       5
       5
       +
         "defs": {

     

       6
       6
       +
           "main": {

     

       7
       7
       +
             "type": "object",

     

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

     

       9
       9
       +
             "properties": {

     

       10
       10
       +
               "images": {

     

       11
       11
       +
                 "type": "array",

     

       12
       12
       +
                 "items": { "type": "ref", "ref": "#image" },

     

       13
       13
       +
                 "maxLength": 4

     

       14
       14
       +
               }

     

       15
       15
       +
             }

     

       16
       16
       +
           },

     

       17
       17
       +
           "image": {

     

       18
       18
       +
             "type": "object",

     

       19
       19
       +
             "required": ["image", "alt"],

     

       20
       20
       +
             "properties": {

     

       21
       21
       +
               "image": {

     

       22
       22
       +
                 "type": "blob",

     

       23
       23
       +
                 "accept": ["image/*"],

     

       24
       24
       +
                 "maxSize": 1000000

     

       25
       25
       +
               },

     

       26
       26
       +
               "alt": {

     

       27
       27
       +
                 "type": "string",

     

       28
       28
       +
                 "description": "Alt text description of the image, for accessibility."

     

       29
       29
       +
               },

     

       30
       30
       +
               "aspectRatio": {

     

       31
       31
       +
                 "type": "ref",

     

       32
       32
       +
                 "ref": "app.bsky.embed.defs#aspectRatio"

     

       33
       33
       +
               }

     

       34
       34
       +
             }

     

       35
       35
       +
           },

     

       36
       36
       +
           "view": {

     

       37
       37
       +
             "type": "object",

     

       38
       38
       +
             "required": ["images"],

     

       39
       39
       +
             "properties": {

     

       40
       40
       +
               "images": {

     

       41
       41
       +
                 "type": "array",

     

       42
       42
       +
                 "items": { "type": "ref", "ref": "#viewImage" },

     

       43
       43
       +
                 "maxLength": 4

     

       44
       44
       +
               }

     

       45
       45
       +
             }

     

       46
       46
       +
           },

     

       47
       47
       +
           "viewImage": {

     

       48
       48
       +
             "type": "object",

     

       49
       49
       +
             "required": ["thumb", "fullsize", "alt"],

     

       50
       50
       +
             "properties": {

     

       51
       51
       +
               "thumb": {

     

       52
       52
       +
                 "type": "string",

     

       53
       53
       +
                 "format": "uri",

     

       54
       54
       +
                 "description": "Fully-qualified URL where a thumbnail of the image can be fetched. For example, CDN location provided by the App View."

     

       55
       55
       +
               },

     

       56
       56
       +
               "fullsize": {

     

       57
       57
       +
                 "type": "string",

     

       58
       58
       +
                 "format": "uri",

     

       59
       59
       +
                 "description": "Fully-qualified URL where a large version of the image can be fetched. May or may not be the exact original blob. For example, CDN location provided by the App View."

     

       60
       60
       +
               },

     

       61
       61
       +
               "alt": {

     

       62
       62
       +
                 "type": "string",

     

       63
       63
       +
                 "description": "Alt text description of the image, for accessibility."

     

       64
       64
       +
               },

     

       65
       65
       +
               "aspectRatio": {

     

       66
       66
       +
                 "type": "ref",

     

       67
       67
       +
                 "ref": "app.bsky.embed.defs#aspectRatio"

     

       68
       68
       +
               }

     

       69
       69
       +
             }

     

       70
       70
       +
           }

     

       71
       71
       +
         }

     

       72
       72
       +
       }

+96

crates/jacquard-lexicon/tests/fixtures/lexicons/post.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.bsky.feed.post",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "record",

     

       7
       7
       +
             "description": "Record containing a Bluesky post.",

     

       8
       8
       +
             "key": "tid",

     

       9
       9
       +
             "record": {

     

       10
       10
       +
               "type": "object",

     

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

     

       12
       12
       +
               "properties": {

     

       13
       13
       +
                 "text": {

     

       14
       14
       +
                   "type": "string",

     

       15
       15
       +
                   "maxLength": 3000,

     

       16
       16
       +
                   "maxGraphemes": 300,

     

       17
       17
       +
                   "description": "The primary post content. May be an empty string, if there are embeds."

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "entities": {

     

       20
       20
       +
                   "type": "array",

     

       21
       21
       +
                   "description": "DEPRECATED: replaced by app.bsky.richtext.facet.",

     

       22
       22
       +
                   "items": { "type": "ref", "ref": "#entity" }

     

       23
       23
       +
                 },

     

       24
       24
       +
                 "facets": {

     

       25
       25
       +
                   "type": "array",

     

       26
       26
       +
                   "description": "Annotations of text (mentions, URLs, hashtags, etc)",

     

       27
       27
       +
                   "items": { "type": "ref", "ref": "app.bsky.richtext.facet" }

     

       28
       28
       +
                 },

     

       29
       29
       +
                 "reply": { "type": "ref", "ref": "#replyRef" },

     

       30
       30
       +
                 "embed": {

     

       31
       31
       +
                   "type": "union",

     

       32
       32
       +
                   "refs": [

     

       33
       33
       +
                     "app.bsky.embed.images",

     

       34
       34
       +
                     "app.bsky.embed.video",

     

       35
       35
       +
                     "app.bsky.embed.external",

     

       36
       36
       +
                     "app.bsky.embed.record",

     

       37
       37
       +
                     "app.bsky.embed.recordWithMedia"

     

       38
       38
       +
                   ]

     

       39
       39
       +
                 },

     

       40
       40
       +
                 "langs": {

     

       41
       41
       +
                   "type": "array",

     

       42
       42
       +
                   "description": "Indicates human language of post primary text content.",

     

       43
       43
       +
                   "maxLength": 3,

     

       44
       44
       +
                   "items": { "type": "string", "format": "language" }

     

       45
       45
       +
                 },

     

       46
       46
       +
                 "labels": {

     

       47
       47
       +
                   "type": "union",

     

       48
       48
       +
                   "description": "Self-label values for this post. Effectively content warnings.",

     

       49
       49
       +
                   "refs": ["com.atproto.label.defs#selfLabels"]

     

       50
       50
       +
                 },

     

       51
       51
       +
                 "tags": {

     

       52
       52
       +
                   "type": "array",

     

       53
       53
       +
                   "description": "Additional hashtags, in addition to any included in post text and facets.",

     

       54
       54
       +
                   "maxLength": 8,

     

       55
       55
       +
                   "items": { "type": "string", "maxLength": 640, "maxGraphemes": 64 }

     

       56
       56
       +
                 },

     

       57
       57
       +
                 "createdAt": {

     

       58
       58
       +
                   "type": "string",

     

       59
       59
       +
                   "format": "datetime",

     

       60
       60
       +
                   "description": "Client-declared timestamp when this post was originally created."

     

       61
       61
       +
                 }

     

       62
       62
       +
               }

     

       63
       63
       +
             }

     

       64
       64
       +
           },

     

       65
       65
       +
           "replyRef": {

     

       66
       66
       +
             "type": "object",

     

       67
       67
       +
             "required": ["root", "parent"],

     

       68
       68
       +
             "properties": {

     

       69
       69
       +
               "root": { "type": "ref", "ref": "com.atproto.repo.strongRef" },

     

       70
       70
       +
               "parent": { "type": "ref", "ref": "com.atproto.repo.strongRef" }

     

       71
       71
       +
             }

     

       72
       72
       +
           },

     

       73
       73
       +
           "entity": {

     

       74
       74
       +
             "type": "object",

     

       75
       75
       +
             "description": "Deprecated: use facets instead.",

     

       76
       76
       +
             "required": ["index", "type", "value"],

     

       77
       77
       +
             "properties": {

     

       78
       78
       +
               "index": { "type": "ref", "ref": "#textSlice" },

     

       79
       79
       +
               "type": {

     

       80
       80
       +
                 "type": "string",

     

       81
       81
       +
                 "description": "Expected values are 'mention' and 'link'."

     

       82
       82
       +
               },

     

       83
       83
       +
               "value": { "type": "string" }

     

       84
       84
       +
             }

     

       85
       85
       +
           },

     

       86
       86
       +
           "textSlice": {

     

       87
       87
       +
             "type": "object",

     

       88
       88
       +
             "description": "Deprecated. Use app.bsky.richtext instead -- A text segment. Start is inclusive, end is exclusive. Indices are for utf16-encoded strings.",

     

       89
       89
       +
             "required": ["start", "end"],

     

       90
       90
       +
             "properties": {

     

       91
       91
       +
               "start": { "type": "integer", "minimum": 0 },

     

       92
       92
       +
               "end": { "type": "integer", "minimum": 0 }

     

       93
       93
       +
             }

     

       94
       94
       +
           }

     

       95
       95
       +
         }

     

       96
       96
       +
       }

+96

crates/jacquard-lexicon/tests/fixtures/lexicons/record.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.bsky.embed.record",

     

       4
       4
       +
         "description": "A representation of a record embedded in a Bluesky record (eg, a post). For example, a quote-post, or sharing a feed generator record.",

     

       5
       5
       +
         "defs": {

     

       6
       6
       +
           "main": {

     

       7
       7
       +
             "type": "object",

     

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

     

       9
       9
       +
             "properties": {

     

       10
       10
       +
               "record": { "type": "ref", "ref": "com.atproto.repo.strongRef" }

     

       11
       11
       +
             }

     

       12
       12
       +
           },

     

       13
       13
       +
           "view": {

     

       14
       14
       +
             "type": "object",

     

       15
       15
       +
             "required": ["record"],

     

       16
       16
       +
             "properties": {

     

       17
       17
       +
               "record": {

     

       18
       18
       +
                 "type": "union",

     

       19
       19
       +
                 "refs": [

     

       20
       20
       +
                   "#viewRecord",

     

       21
       21
       +
                   "#viewNotFound",

     

       22
       22
       +
                   "#viewBlocked",

     

       23
       23
       +
                   "#viewDetached",

     

       24
       24
       +
                   "app.bsky.feed.defs#generatorView",

     

       25
       25
       +
                   "app.bsky.graph.defs#listView",

     

       26
       26
       +
                   "app.bsky.labeler.defs#labelerView",

     

       27
       27
       +
                   "app.bsky.graph.defs#starterPackViewBasic"

     

       28
       28
       +
                 ]

     

       29
       29
       +
               }

     

       30
       30
       +
             }

     

       31
       31
       +
           },

     

       32
       32
       +
           "viewRecord": {

     

       33
       33
       +
             "type": "object",

     

       34
       34
       +
             "required": ["uri", "cid", "author", "value", "indexedAt"],

     

       35
       35
       +
             "properties": {

     

       36
       36
       +
               "uri": { "type": "string", "format": "at-uri" },

     

       37
       37
       +
               "cid": { "type": "string", "format": "cid" },

     

       38
       38
       +
               "author": {

     

       39
       39
       +
                 "type": "ref",

     

       40
       40
       +
                 "ref": "app.bsky.actor.defs#profileViewBasic"

     

       41
       41
       +
               },

     

       42
       42
       +
               "value": {

     

       43
       43
       +
                 "type": "unknown",

     

       44
       44
       +
                 "description": "The record data itself."

     

       45
       45
       +
               },

     

       46
       46
       +
               "labels": {

     

       47
       47
       +
                 "type": "array",

     

       48
       48
       +
                 "items": { "type": "ref", "ref": "com.atproto.label.defs#label" }

     

       49
       49
       +
               },

     

       50
       50
       +
               "replyCount": { "type": "integer" },

     

       51
       51
       +
               "repostCount": { "type": "integer" },

     

       52
       52
       +
               "likeCount": { "type": "integer" },

     

       53
       53
       +
               "quoteCount": { "type": "integer" },

     

       54
       54
       +
               "embeds": {

     

       55
       55
       +
                 "type": "array",

     

       56
       56
       +
                 "items": {

     

       57
       57
       +
                   "type": "union",

     

       58
       58
       +
                   "refs": [

     

       59
       59
       +
                     "app.bsky.embed.images#view",

     

       60
       60
       +
                     "app.bsky.embed.video#view",

     

       61
       61
       +
                     "app.bsky.embed.external#view",

     

       62
       62
       +
                     "app.bsky.embed.record#view",

     

       63
       63
       +
                     "app.bsky.embed.recordWithMedia#view"

     

       64
       64
       +
                   ]

     

       65
       65
       +
                 }

     

       66
       66
       +
               },

     

       67
       67
       +
               "indexedAt": { "type": "string", "format": "datetime" }

     

       68
       68
       +
             }

     

       69
       69
       +
           },

     

       70
       70
       +
           "viewNotFound": {

     

       71
       71
       +
             "type": "object",

     

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

     

       73
       73
       +
             "properties": {

     

       74
       74
       +
               "uri": { "type": "string", "format": "at-uri" },

     

       75
       75
       +
               "notFound": { "type": "boolean", "const": true }

     

       76
       76
       +
             }

     

       77
       77
       +
           },

     

       78
       78
       +
           "viewBlocked": {

     

       79
       79
       +
             "type": "object",

     

       80
       80
       +
             "required": ["uri", "blocked", "author"],

     

       81
       81
       +
             "properties": {

     

       82
       82
       +
               "uri": { "type": "string", "format": "at-uri" },

     

       83
       83
       +
               "blocked": { "type": "boolean", "const": true },

     

       84
       84
       +
               "author": { "type": "ref", "ref": "app.bsky.feed.defs#blockedAuthor" }

     

       85
       85
       +
             }

     

       86
       86
       +
           },

     

       87
       87
       +
           "viewDetached": {

     

       88
       88
       +
             "type": "object",

     

       89
       89
       +
             "required": ["uri", "detached"],

     

       90
       90
       +
             "properties": {

     

       91
       91
       +
               "uri": { "type": "string", "format": "at-uri" },

     

       92
       92
       +
               "detached": { "type": "boolean", "const": true }

     

       93
       93
       +
             }

     

       94
       94
       +
           }

     

       95
       95
       +
         }

     

       96
       96
       +
       }

+43

crates/jacquard-lexicon/tests/fixtures/lexicons/recordWithMedia.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.bsky.embed.recordWithMedia",

     

       4
       4
       +
         "description": "A representation of a record embedded in a Bluesky record (eg, a post), alongside other compatible embeds. For example, a quote post and image, or a quote post and external URL card.",

     

       5
       5
       +
         "defs": {

     

       6
       6
       +
           "main": {

     

       7
       7
       +
             "type": "object",

     

       8
       8
       +
             "required": ["record", "media"],

     

       9
       9
       +
             "properties": {

     

       10
       10
       +
               "record": {

     

       11
       11
       +
                 "type": "ref",

     

       12
       12
       +
                 "ref": "app.bsky.embed.record"

     

       13
       13
       +
               },

     

       14
       14
       +
               "media": {

     

       15
       15
       +
                 "type": "union",

     

       16
       16
       +
                 "refs": [

     

       17
       17
       +
                   "app.bsky.embed.images",

     

       18
       18
       +
                   "app.bsky.embed.video",

     

       19
       19
       +
                   "app.bsky.embed.external"

     

       20
       20
       +
                 ]

     

       21
       21
       +
               }

     

       22
       22
       +
             }

     

       23
       23
       +
           },

     

       24
       24
       +
           "view": {

     

       25
       25
       +
             "type": "object",

     

       26
       26
       +
             "required": ["record", "media"],

     

       27
       27
       +
             "properties": {

     

       28
       28
       +
               "record": {

     

       29
       29
       +
                 "type": "ref",

     

       30
       30
       +
                 "ref": "app.bsky.embed.record#view"

     

       31
       31
       +
               },

     

       32
       32
       +
               "media": {

     

       33
       33
       +
                 "type": "union",

     

       34
       34
       +
                 "refs": [

     

       35
       35
       +
                   "app.bsky.embed.images#view",

     

       36
       36
       +
                   "app.bsky.embed.video#view",

     

       37
       37
       +
                   "app.bsky.embed.external#view"

     

       38
       38
       +
                 ]

     

       39
       39
       +
               }

     

       40
       40
       +
             }

     

       41
       41
       +
           }

     

       42
       42
       +
         }

     

       43
       43
       +
       }

+15

crates/jacquard-lexicon/tests/fixtures/lexicons/strongRef.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "com.atproto.repo.strongRef",

     

       4
       4
       +
         "description": "A URI with a content-hash fingerprint.",

     

       5
       5
       +
         "defs": {

     

       6
       6
       +
           "main": {

     

       7
       7
       +
             "type": "object",

     

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

     

       9
       9
       +
             "properties": {

     

       10
       10
       +
               "uri": { "type": "string", "format": "at-uri" },

     

       11
       11
       +
               "cid": { "type": "string", "format": "cid" }

     

       12
       12
       +
             }

     

       13
       13
       +
           }

     

       14
       14
       +
         }

     

       15
       15
       +
       }

+67

crates/jacquard-lexicon/tests/fixtures/lexicons/video.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.bsky.embed.video",

     

       4
       4
       +
         "description": "A video embedded in a Bluesky record (eg, a post).",

     

       5
       5
       +
         "defs": {

     

       6
       6
       +
           "main": {

     

       7
       7
       +
             "type": "object",

     

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

     

       9
       9
       +
             "properties": {

     

       10
       10
       +
               "video": {

     

       11
       11
       +
                 "type": "blob",

     

       12
       12
       +
                 "description": "The mp4 video file. May be up to 100mb, formerly limited to 50mb.",

     

       13
       13
       +
                 "accept": ["video/mp4"],

     

       14
       14
       +
                 "maxSize": 100000000

     

       15
       15
       +
               },

     

       16
       16
       +
               "captions": {

     

       17
       17
       +
                 "type": "array",

     

       18
       18
       +
                 "items": { "type": "ref", "ref": "#caption" },

     

       19
       19
       +
                 "maxLength": 20

     

       20
       20
       +
               },

     

       21
       21
       +
               "alt": {

     

       22
       22
       +
                 "type": "string",

     

       23
       23
       +
                 "description": "Alt text description of the video, for accessibility.",

     

       24
       24
       +
                 "maxGraphemes": 1000,

     

       25
       25
       +
                 "maxLength": 10000

     

       26
       26
       +
               },

     

       27
       27
       +
               "aspectRatio": {

     

       28
       28
       +
                 "type": "ref",

     

       29
       29
       +
                 "ref": "app.bsky.embed.defs#aspectRatio"

     

       30
       30
       +
               }

     

       31
       31
       +
             }

     

       32
       32
       +
           },

     

       33
       33
       +
           "caption": {

     

       34
       34
       +
             "type": "object",

     

       35
       35
       +
             "required": ["lang", "file"],

     

       36
       36
       +
             "properties": {

     

       37
       37
       +
               "lang": {

     

       38
       38
       +
                 "type": "string",

     

       39
       39
       +
                 "format": "language"

     

       40
       40
       +
               },

     

       41
       41
       +
               "file": {

     

       42
       42
       +
                 "type": "blob",

     

       43
       43
       +
                 "accept": ["text/vtt"],

     

       44
       44
       +
                 "maxSize": 20000

     

       45
       45
       +
               }

     

       46
       46
       +
             }

     

       47
       47
       +
           },

     

       48
       48
       +
           "view": {

     

       49
       49
       +
             "type": "object",

     

       50
       50
       +
             "required": ["cid", "playlist"],

     

       51
       51
       +
             "properties": {

     

       52
       52
       +
               "cid": { "type": "string", "format": "cid" },

     

       53
       53
       +
               "playlist": { "type": "string", "format": "uri" },

     

       54
       54
       +
               "thumbnail": { "type": "string", "format": "uri" },

     

       55
       55
       +
               "alt": {

     

       56
       56
       +
                 "type": "string",

     

       57
       57
       +
                 "maxGraphemes": 1000,

     

       58
       58
       +
                 "maxLength": 10000

     

       59
       59
       +
               },

     

       60
       60
       +
               "aspectRatio": {

     

       61
       61
       +
                 "type": "ref",

     

       62
       62
       +
                 "ref": "app.bsky.embed.defs#aspectRatio"

     

       63
       63
       +
               }

     

       64
       64
       +
             }

     

       65
       65
       +
           }

     

       66
       66
       +
         }

     

       67
       67
       +
       }