+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)]

+1

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 + }