commit aa87f30d21f0a72b628e093168cd3ace89aa3d8a · zbrox.com/jacquard

+2 -3

crates/jacquard-api/src/app_bsky/feed/get_suggested_feeds.rs

···

       50
       50
        
       

     

       51
       51
        
       impl jacquard_common::types::xrpc::XrpcRequest for GetSuggestedFeeds<'_> {

     

       52
       52
        
           const NSID: &'static str = "app.bsky.feed.getSuggestedFeeds";

     

       53
       53
       -
           const METHOD: jacquard_common::types::xrpc::XrpcMethod =

     

       54
       54
       -
               jacquard_common::types::xrpc::XrpcMethod::Query;

     

       53
       53
       +
           const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;

     

       55
       54
        
           const OUTPUT_ENCODING: &'static str = "application/json";

     

       56
       55
        
           type Output<'de> = GetSuggestedFeedsOutput<'de>;

     

       57
       56
        
           type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;

     

       58
       58
       -
       }

     

       57
       57
       +
       }

+2 -3

crates/jacquard-api/src/app_bsky/unspecced/get_onboarding_suggested_starter_packs.rs

···

       40
       40
        
       

     

       41
       41
        
       impl jacquard_common::types::xrpc::XrpcRequest for GetOnboardingSuggestedStarterPacks {

     

       42
       42
        
           const NSID: &'static str = "app.bsky.unspecced.getOnboardingSuggestedStarterPacks";

     

       43
       43
       -
           const METHOD: jacquard_common::types::xrpc::XrpcMethod =

     

       44
       44
       -
               jacquard_common::types::xrpc::XrpcMethod::Query;

     

       43
       43
       +
           const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;

     

       45
       44
        
           const OUTPUT_ENCODING: &'static str = "application/json";

     

       46
       45
        
           type Output<'de> = GetOnboardingSuggestedStarterPacksOutput<'de>;

     

       47
       46
        
           type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;

     

       48
       48
       -
       }

     

       47
       47
       +
       }

+11 -8

crates/jacquard-api/src/app_bsky/video/upload_video.rs

···

       5
       5
        
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
        
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
        
       

     

       8
       8
       -
       #[jacquard_derive::lexicon]

     

       9
       8
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       10
       9
        
       #[serde(rename_all = "camelCase")]

     

       11
       11
       -
       pub struct UploadVideo<'a> {}

     

       12
       12
       -
       impl jacquard_common::IntoStatic for UploadVideo<'_> {

     

       13
       13
       -
           type Output = UploadVideo<'static>;

     

       10
       10
       +
       pub struct UploadVideo {

     

       11
       11
       +
           pub body: bytes::Bytes,

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       impl jacquard_common::IntoStatic for UploadVideo {

     

       15
       15
       +
           type Output = UploadVideo;

     

       14
       16
        
           fn into_static(self) -> Self::Output {

     

       15
       15
       -
               UploadVideo {

     

       16
       16
       -
                   extra_data: self.extra_data.into_static(),

     

       17
       17
       -
               }

     

       17
       17
       +
               self

     

       18
       18
        
           }

     

       19
       19
        
       }

     

       20
       20
        
       

     
···

       36
       36
        
           }

     

       37
       37
        
       }

     

       38
       38
        
       

     

       39
       39
       -
       impl jacquard_common::types::xrpc::XrpcRequest for UploadVideo<'_> {

     

       39
       39
       +
       impl jacquard_common::types::xrpc::XrpcRequest for UploadVideo {

     

       40
       40
        
           const NSID: &'static str = "app.bsky.video.uploadVideo";

     

       41
       41
        
           const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(

     

       42
       42
        
               "video/mp4",

     
···

       44
       44
        
           const OUTPUT_ENCODING: &'static str = "application/json";

     

       45
       45
        
           type Output<'de> = UploadVideoOutput<'de>;

     

       46
       46
        
           type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;

     

       47
       47
       +
           fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::types::xrpc::EncodeError> {

     

       48
       48
       +
               Ok(self.body.to_vec())

     

       49
       49
       +
           }

     

       47
       50
        
       }

+11 -8

crates/jacquard-api/src/com_atproto/repo/import_repo.rs

···

       5
       5
        
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
        
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
        
       

     

       8
       8
       -
       #[jacquard_derive::lexicon]

     

       9
       8
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       10
       9
        
       #[serde(rename_all = "camelCase")]

     

       11
       11
       -
       pub struct ImportRepo<'a> {}

     

       12
       12
       -
       impl jacquard_common::IntoStatic for ImportRepo<'_> {

     

       13
       13
       -
           type Output = ImportRepo<'static>;

     

       10
       10
       +
       pub struct ImportRepo {

     

       11
       11
       +
           pub body: bytes::Bytes,

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       impl jacquard_common::IntoStatic for ImportRepo {

     

       15
       15
       +
           type Output = ImportRepo;

     

       14
       16
        
           fn into_static(self) -> Self::Output {

     

       15
       15
       -
               ImportRepo {

     

       16
       16
       -
                   extra_data: self.extra_data.into_static(),

     

       17
       17
       -
               }

     

       17
       17
       +
               self

     

       18
       18
        
           }

     

       19
       19
        
       }

     

       20
       20
        
       

     

       21
       21
       -
       impl jacquard_common::types::xrpc::XrpcRequest for ImportRepo<'_> {

     

       21
       21
       +
       impl jacquard_common::types::xrpc::XrpcRequest for ImportRepo {

     

       22
       22
        
           const NSID: &'static str = "com.atproto.repo.importRepo";

     

       23
       23
        
           const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(

     

       24
       24
        
               "application/vnd.ipld.car",

     
···

       26
       26
        
           const OUTPUT_ENCODING: &'static str = "application/json";

     

       27
       27
        
           type Output<'de> = ();

     

       28
       28
        
           type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;

     

       29
       29
       +
           fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::types::xrpc::EncodeError> {

     

       30
       30
       +
               Ok(self.body.to_vec())

     

       31
       31
       +
           }

     

       29
       32
        
       }

+11 -8

crates/jacquard-api/src/com_atproto/repo/upload_blob.rs

···

       5
       5
        
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
        
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
        
       

     

       8
       8
       -
       #[jacquard_derive::lexicon]

     

       9
       8
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       10
       9
        
       #[serde(rename_all = "camelCase")]

     

       11
       11
       -
       pub struct UploadBlob<'a> {}

     

       12
       12
       -
       impl jacquard_common::IntoStatic for UploadBlob<'_> {

     

       13
       13
       -
           type Output = UploadBlob<'static>;

     

       10
       10
       +
       pub struct UploadBlob {

     

       11
       11
       +
           pub body: bytes::Bytes,

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       impl jacquard_common::IntoStatic for UploadBlob {

     

       15
       15
       +
           type Output = UploadBlob;

     

       14
       16
        
           fn into_static(self) -> Self::Output {

     

       15
       15
       -
               UploadBlob {

     

       16
       16
       -
                   extra_data: self.extra_data.into_static(),

     

       17
       17
       -
               }

     

       17
       17
       +
               self

     

       18
       18
        
           }

     

       19
       19
        
       }

     

       20
       20
        
       

     
···

       36
       36
        
           }

     

       37
       37
        
       }

     

       38
       38
        
       

     

       39
       39
       -
       impl jacquard_common::types::xrpc::XrpcRequest for UploadBlob<'_> {

     

       39
       39
       +
       impl jacquard_common::types::xrpc::XrpcRequest for UploadBlob {

     

       40
       40
        
           const NSID: &'static str = "com.atproto.repo.uploadBlob";

     

       41
       41
        
           const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(

     

       42
       42
        
               "*/*",

     
···

       44
       44
        
           const OUTPUT_ENCODING: &'static str = "application/json";

     

       45
       45
        
           type Output<'de> = UploadBlobOutput<'de>;

     

       46
       46
        
           type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;

     

       47
       47
       +
           fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::types::xrpc::EncodeError> {

     

       48
       48
       +
               Ok(self.body.to_vec())

     

       49
       49
       +
           }

     

       47
       50
        
       }

+29 -1

crates/jacquard-common/src/types/xrpc.rs

···

       1
       1
       -
       use serde::de::DeserializeOwned;

     

       2
       1
        
       use serde::{Deserialize, Serialize};

     

       3
       2
        
       use std::error::Error;

     

       4
       3
        
       use std::fmt::{self, Debug};

     

       5
       4
        
       

     

       6
       5
        
       use crate::IntoStatic;

     

       7
       6
        
       use crate::types::value::Data;

     

       7
       7
       +
       

     

       8
       8
       +
       /// Error type for encoding XRPC requests

     

       9
       9
       +
       #[derive(Debug, thiserror::Error, miette::Diagnostic)]

     

       10
       10
       +
       pub enum EncodeError {

     

       11
       11
       +
           /// Failed to serialize query parameters

     

       12
       12
       +
           #[error("Failed to serialize query: {0}")]

     

       13
       13
       +
           Query(

     

       14
       14
       +
               #[from]

     

       15
       15
       +
               #[source]

     

       16
       16
       +
               serde_html_form::ser::Error,

     

       17
       17
       +
           ),

     

       18
       18
       +
           /// Failed to serialize JSON body

     

       19
       19
       +
           #[error("Failed to serialize JSON: {0}")]

     

       20
       20
       +
           Json(

     

       21
       21
       +
               #[from]

     

       22
       22
       +
               #[source]

     

       23
       23
       +
               serde_json::Error,

     

       24
       24
       +
           ),

     

       25
       25
       +
           /// Other encoding error

     

       26
       26
       +
           #[error("Encoding error: {0}")]

     

       27
       27
       +
           Other(String),

     

       28
       28
       +
       }

     

       8
       29
        
       

     

       9
       30
        
       /// XRPC method type

     

       10
       31
        
       #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

     
···

       53
       74
        
       

     

       54
       75
        
           /// Error type for this request

     

       55
       76
        
           type Err<'de>: Error + Deserialize<'de> + IntoStatic;

     

       77
       77
       +
       

     

       78
       78
       +
           /// Encode the request body for procedures.

     

       79
       79
       +
           ///

     

       80
       80
       +
           /// Default implementation serializes to JSON. Override for non-JSON encodings.

     

       81
       81
       +
           fn encode_body(&self) -> Result<Vec<u8>, EncodeError> {

     

       82
       82
       +
               Ok(serde_json::to_vec(self)?)

     

       83
       83
       +
           }

     

       56
       84
        
       }

     

       57
       85
        
       

     

       58
       86
        
       /// Error type for XRPC endpoints that don't define any errors

+79 -26

crates/jacquard-lexicon/src/codegen.rs

···

       662
       662
        
                   params_has_lifetime,

     

       663
       663
        
                   has_output,

     

       664
       664
        
                   has_errors,

     

       665
       665
       +
                   false, // queries never have binary inputs

     

       665
       666
        
               )?;

     

       666
       667
        
               output.push(xrpc_impl);

     

       667
       668
        
       

     
···

       680
       681
        
               let type_base = self.def_to_type_name(nsid, def_name);

     

       681
       682
        
               let mut output = Vec::new();

     

       682
       683
        
       

     

       683
       683
       -
               // Input bodies always have lifetimes (they get #[lexicon] attribute)

     

       684
       684
       -
               let params_has_lifetime = proc.input.is_some();

     

       684
       684
       +
               // Check if input is a binary body (no schema)

     

       685
       685
       +
               let is_binary_input = proc

     

       686
       686
       +
                   .input

     

       687
       687
       +
                   .as_ref()

     

       688
       688
       +
                   .map(|i| i.schema.is_none())

     

       689
       689
       +
                   .unwrap_or(false);

     

       690
       690
       +
       

     

       691
       691
       +
               // Input bodies with schemas have lifetimes (they get #[lexicon] attribute)

     

       692
       692
       +
               // Binary inputs don't have lifetimes

     

       693
       693
       +
               let params_has_lifetime = proc.input.is_some() && !is_binary_input;

     

       685
       694
        
               let has_input = proc.input.is_some();

     

       686
       695
        
               let has_output = proc.output.is_some();

     

       687
       696
        
               let has_errors = proc.errors.is_some();

     
···

       726
       735
        
                   params_has_lifetime,

     

       727
       736
        
                   has_output,

     

       728
       737
        
                   has_errors,

     

       738
       738
       +
                   is_binary_input,

     

       729
       739
        
               )?;

     

       730
       740
        
               output.push(xrpc_impl);

     

       731
       741
        
       

     
···

       1424
       1434
        
           ) -> Result<TokenStream> {

     

       1425
       1435
        
               let ident = syn::Ident::new(type_base, proc_macro2::Span::call_site());

     

       1426
       1436
        
       

     

       1437
       1437
       +
               // Check if this is a binary body (no schema, just raw bytes)

     

       1438
       1438
       +
               let is_binary_body = body.schema.is_none();

     

       1439
       1439
       +
       

     

       1427
       1440
        
               let fields = if let Some(schema) = &body.schema {

     

       1428
       1441
        
                   self.generate_body_fields("", type_base, schema)?

     

       1429
       1442
        
               } else {

     

       1430
       1430
       -
                   quote! {}

     

       1443
       1443
       +
                   // Binary body: just a bytes field

     

       1444
       1444
       +
                   quote! {

     

       1445
       1445
       +
                       pub body: bytes::Bytes,

     

       1446
       1446
       +
                   }

     

       1431
       1447
        
               };

     

       1432
       1448
        
       

     

       1433
       1449
        
               let doc = self.generate_doc_comment(body.description.as_ref());

     

       1434
       1450
        
       

     

       1435
       1435
       -
               // Input structs always get a lifetime since they have the #[lexicon] attribute

     

       1436
       1436
       -
               // which adds extra_data: BTreeMap<..., Data<'a>>

     

       1437
       1437
       -
               let struct_def = quote! {

     

       1438
       1438
       -
                   #doc

     

       1439
       1439
       -
                   #[jacquard_derive::lexicon]

     

       1440
       1440
       -
                   #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       1441
       1441
       -
                   #[serde(rename_all = "camelCase")]

     

       1442
       1442
       -
                   pub struct #ident<'a> {

     

       1443
       1443
       -
                       #fields

     

       1451
       1451
       +
               // Binary bodies don't need #[lexicon] attribute or lifetime

     

       1452
       1452
       +
               let struct_def = if is_binary_body {

     

       1453
       1453
       +
                   quote! {

     

       1454
       1454
       +
                       #doc

     

       1455
       1455
       +
                       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       1456
       1456
       +
                       #[serde(rename_all = "camelCase")]

     

       1457
       1457
       +
                       pub struct #ident {

     

       1458
       1458
       +
                           #fields

     

       1459
       1459
       +
                       }

     

       1460
       1460
       +
                   }

     

       1461
       1461
       +
               } else {

     

       1462
       1462
       +
                   // Input structs with schemas get a lifetime since they have the #[lexicon] attribute

     

       1463
       1463
       +
                   // which adds extra_data: BTreeMap<..., Data<'a>>

     

       1464
       1464
       +
                   quote! {

     

       1465
       1465
       +
                       #doc

     

       1466
       1466
       +
                       #[jacquard_derive::lexicon]

     

       1467
       1467
       +
                       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       1468
       1468
       +
                       #[serde(rename_all = "camelCase")]

     

       1469
       1469
       +
                       pub struct #ident<'a> {

     

       1470
       1470
       +
                           #fields

     

       1471
       1471
       +
                       }

     

       1444
       1472
        
                   }

     

       1445
       1473
        
               };

     

       1446
       1474
        
       

     
···

       1458
       1486
        
               }

     

       1459
       1487
        
       

     

       1460
       1488
        
               // Generate IntoStatic impl

     

       1461
       1461
       -
               let field_names: Vec<&str> = match &body.schema {

     

       1462
       1462
       -
                   Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) => {

     

       1463
       1463
       -
                       obj.properties.keys().map(|k| k.as_str()).collect()

     

       1464
       1464
       -
                   }

     

       1465
       1465
       -
                   Some(_) => {

     

       1466
       1466
       -
                       // For Ref or Union schemas, there's just a single flattened field

     

       1467
       1467
       -
                       vec!["value"]

     

       1468
       1468
       -
                   }

     

       1469
       1469
       -
                   None => {

     

       1470
       1470
       -
                       // No schema means no fields, just extra_data

     

       1471
       1471
       -
                       vec![]

     

       1489
       1489
       +
               let into_static_impl = if is_binary_body {

     

       1490
       1490
       +
                   // Binary bodies: simple clone of the Bytes field

     

       1491
       1491
       +
                   quote! {

     

       1492
       1492
       +
                       impl jacquard_common::IntoStatic for #ident {

     

       1493
       1493
       +
                           type Output = #ident;

     

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

     

       1495
       1495
       +
                               self

     

       1496
       1496
       +
                           }

     

       1497
       1497
       +
                       }

     

       1472
       1498
        
                   }

     

       1499
       1499
       +
               } else {

     

       1500
       1500
       +
                   let field_names: Vec<&str> = match &body.schema {

     

       1501
       1501
       +
                       Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) => {

     

       1502
       1502
       +
                           obj.properties.keys().map(|k| k.as_str()).collect()

     

       1503
       1503
       +
                       }

     

       1504
       1504
       +
                       Some(_) => {

     

       1505
       1505
       +
                           // For Ref or Union schemas, there's just a single flattened field

     

       1506
       1506
       +
                           vec!["value"]

     

       1507
       1507
       +
                       }

     

       1508
       1508
       +
                       None => {

     

       1509
       1509
       +
                           // No schema means no fields, just extra_data

     

       1510
       1510
       +
                           vec![]

     

       1511
       1511
       +
                       }

     

       1512
       1512
       +
                   };

     

       1513
       1513
       +
                   self.generate_into_static_for_struct(type_base, &field_names, true, true)

     

       1473
       1514
        
               };

     

       1474
       1474
       -
               let into_static_impl =

     

       1475
       1475
       -
                   self.generate_into_static_for_struct(type_base, &field_names, true, true);

     

       1476
       1515
        
       

     

       1477
       1516
        
               Ok(quote! {

     

       1478
       1517
        
                   #struct_def

     
···

       1923
       1962
        
               params_has_lifetime: bool,

     

       1924
       1963
        
               has_output: bool,

     

       1925
       1964
        
               has_errors: bool,

     

       1965
       1965
       +
               is_binary_input: bool,

     

       1926
       1966
        
           ) -> Result<TokenStream> {

     

       1927
       1967
        
               let output_type = if has_output {

     

       1928
       1968
        
                   let output_ident = syn::Ident::new(

     
···

       1944
       1984
        
                   quote! { jacquard_common::types::xrpc::GenericError<'de> }

     

       1945
       1985
        
               };

     

       1946
       1986
        
       

     

       1987
       1987
       +
               // Generate encode_body() method for binary inputs

     

       1988
       1988
       +
               let encode_body_method = if is_binary_input {

     

       1989
       1989
       +
                   quote! {

     

       1990
       1990
       +
                       fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::types::xrpc::EncodeError> {

     

       1991
       1991
       +
                           Ok(self.body.to_vec())

     

       1992
       1992
       +
                       }

     

       1993
       1993
       +
                   }

     

       1994
       1994
       +
               } else {

     

       1995
       1995
       +
                   quote! {}

     

       1996
       1996
       +
               };

     

       1997
       1997
       +
       

     

       1947
       1998
        
               if has_params {

     

       1948
       1999
        
                   // Implement on the params/input struct itself

     

       1949
       2000
        
                   let request_ident = syn::Ident::new(type_base, proc_macro2::Span::call_site());

     
···

       1961
       2012
        
       

     

       1962
       2013
        
                           type Output<'de> = #output_type;

     

       1963
       2014
        
                           type Err<'de> = #error_type;

     

       2015
       2015
       +
       

     

       2016
       2016
       +
                           #encode_body_method

     

       1964
       2017
        
                       }

     

       1965
       2018
        
                   })

     

       1966
       2019
        
               } else {

     
···

       2311
       2364
        
               println!("\n{}\n", formatted);

     

       2312
       2365
        
       

     

       2313
       2366
        
               // Check structure

     

       2314
       2314
       -
               assert!(formatted.contains("struct GetAuthorFeedParams"));

     

       2367
       2367
       +
               assert!(formatted.contains("struct GetAuthorFeed"));

     

       2315
       2368
        
               assert!(formatted.contains("struct GetAuthorFeedOutput"));

     

       2316
       2369
        
               assert!(formatted.contains("enum GetAuthorFeedError"));

     

       2317
       2370
        
               assert!(formatted.contains("pub actor"));

+6 -1

crates/jacquard-lexicon/target/test_codegen_output/app_bsky.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       1
       6
        
       pub mod embed;

     

       2
       7
        
       pub mod feed;

     

       3
       3
       -
       pub mod richtext;

     

       8
       8
       +
       pub mod richtext;

+6 -1

crates/jacquard-lexicon/target/test_codegen_output/app_bsky/embed.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       1
       6
        
       pub mod external;

     

       2
       7
        
       pub mod images;

     

       3
       8
        
       pub mod record;

     

       4
       9
        
       pub mod record_with_media;

     

       5
       5
       -
       pub mod video;

     

       10
       10
       +
       pub mod video;

+77 -7

crates/jacquard-lexicon/target/test_codegen_output/app_bsky/embed/external.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.bsky.embed.external

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       1
       9
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       2
       10
        
       #[serde(rename_all = "camelCase")]

     

       3
       11
        
       pub struct External<'a> {

     

       12
       12
       +
           #[serde(borrow)]

     

       4
       13
        
           pub description: jacquard_common::CowStr<'a>,

     

       5
       5
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       6
       6
       -
           pub thumb: Option<jacquard_common::types::blob::Blob<'a>>,

     

       14
       14
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       15
       15
       +
           #[serde(borrow)]

     

       16
       16
       +
           pub thumb: std::option::Option<jacquard_common::types::blob::Blob<'a>>,

     

       17
       17
       +
           #[serde(borrow)]

     

       7
       18
        
           pub title: jacquard_common::CowStr<'a>,

     

       19
       19
       +
           #[serde(borrow)]

     

       8
       20
        
           pub uri: jacquard_common::types::string::Uri<'a>,

     

       9
       21
        
       }

     

       22
       22
       +
       

     

       23
       23
       +
       impl jacquard_common::IntoStatic for External<'_> {

     

       24
       24
       +
           type Output = External<'static>;

     

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

     

       26
       26
       +
               External {

     

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

     

       28
       28
       +
                   thumb: self.thumb.into_static(),

     

       29
       29
       +
                   title: self.title.into_static(),

     

       30
       30
       +
                   uri: self.uri.into_static(),

     

       31
       31
       +
                   extra_data: self.extra_data.into_static(),

     

       32
       32
       +
               }

     

       33
       33
       +
           }

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       10
       36
        
       ///A representation of some externally linked content (eg, a URL and 'card'), embedded in a Bluesky record (eg, a post).

     

       37
       37
       +
       #[jacquard_derive::lexicon]

     

       11
       38
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       12
       39
        
       #[serde(rename_all = "camelCase")]

     

       13
       13
       -
       pub struct External<'a> {

     

       14
       14
       -
           pub external: jacquard_common::types::value::Data<'a>,

     

       40
       40
       +
       pub struct ExternalRecord<'a> {

     

       41
       41
       +
           #[serde(borrow)]

     

       42
       42
       +
           pub external: test_generated::app_bsky::embed::external::External<'a>,

     

       15
       43
        
       }

     

       44
       44
       +
       

     

       45
       45
       +
       impl jacquard_common::IntoStatic for ExternalRecord<'_> {

     

       46
       46
       +
           type Output = ExternalRecord<'static>;

     

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

     

       48
       48
       +
               ExternalRecord {

     

       49
       49
       +
                   external: self.external.into_static(),

     

       50
       50
       +
                   extra_data: self.extra_data.into_static(),

     

       51
       51
       +
               }

     

       52
       52
       +
           }

     

       53
       53
       +
       }

     

       54
       54
       +
       

     

       55
       55
       +
       #[jacquard_derive::lexicon]

     

       16
       56
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       17
       57
        
       #[serde(rename_all = "camelCase")]

     

       18
       58
        
       pub struct View<'a> {

     

       19
       19
       -
           pub external: jacquard_common::types::value::Data<'a>,

     

       59
       59
       +
           #[serde(borrow)]

     

       60
       60
       +
           pub external: test_generated::app_bsky::embed::external::ViewExternal<'a>,

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       impl jacquard_common::IntoStatic for View<'_> {

     

       64
       64
       +
           type Output = View<'static>;

     

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

     

       66
       66
       +
               View {

     

       67
       67
       +
                   external: self.external.into_static(),

     

       68
       68
       +
                   extra_data: self.extra_data.into_static(),

     

       69
       69
       +
               }

     

       70
       70
       +
           }

     

       20
       71
        
       }

     

       72
       72
       +
       

     

       73
       73
       +
       #[jacquard_derive::lexicon]

     

       21
       74
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       22
       75
        
       #[serde(rename_all = "camelCase")]

     

       23
       76
        
       pub struct ViewExternal<'a> {

     

       77
       77
       +
           #[serde(borrow)]

     

       24
       78
        
           pub description: jacquard_common::CowStr<'a>,

     

       25
       25
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       26
       26
       -
           pub thumb: Option<jacquard_common::types::string::Uri<'a>>,

     

       79
       79
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       80
       80
       +
           #[serde(borrow)]

     

       81
       81
       +
           pub thumb: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       82
       82
       +
           #[serde(borrow)]

     

       27
       83
        
           pub title: jacquard_common::CowStr<'a>,

     

       84
       84
       +
           #[serde(borrow)]

     

       28
       85
        
           pub uri: jacquard_common::types::string::Uri<'a>,

     

       29
       86
        
       }

     

       87
       87
       +
       

     

       88
       88
       +
       impl jacquard_common::IntoStatic for ViewExternal<'_> {

     

       89
       89
       +
           type Output = ViewExternal<'static>;

     

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

     

       91
       91
       +
               ViewExternal {

     

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

     

       93
       93
       +
                   thumb: self.thumb.into_static(),

     

       94
       94
       +
                   title: self.title.into_static(),

     

       95
       95
       +
                   uri: self.uri.into_static(),

     

       96
       96
       +
                   extra_data: self.extra_data.into_static(),

     

       97
       97
       +
               }

     

       98
       98
       +
           }

     

       99
       99
       +
       }

+78 -6

crates/jacquard-lexicon/target/test_codegen_output/app_bsky/embed/images.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.bsky.embed.images

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       1
       9
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       2
       10
        
       #[serde(rename_all = "camelCase")]

     

       3
       11
        
       pub struct Image<'a> {

     

       12
       12
       +
           ///Alt text description of the image, for accessibility.

     

       13
       13
       +
           #[serde(borrow)]

     

       4
       14
        
           pub alt: jacquard_common::CowStr<'a>,

     

       5
       5
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       6
       6
       -
           pub aspect_ratio: Option<jacquard_common::types::value::Data<'a>>,

     

       15
       15
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       16
       16
       +
           #[serde(borrow)]

     

       17
       17
       +
           pub aspect_ratio: std::option::Option<jacquard_common::types::value::Data<'a>>,

     

       18
       18
       +
           #[serde(borrow)]

     

       7
       19
        
           pub image: jacquard_common::types::blob::Blob<'a>,

     

       8
       20
        
       }

     

       21
       21
       +
       

     

       22
       22
       +
       impl jacquard_common::IntoStatic for Image<'_> {

     

       23
       23
       +
           type Output = Image<'static>;

     

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

     

       25
       25
       +
               Image {

     

       26
       26
       +
                   alt: self.alt.into_static(),

     

       27
       27
       +
                   aspect_ratio: self.aspect_ratio.into_static(),

     

       28
       28
       +
                   image: self.image.into_static(),

     

       29
       29
       +
                   extra_data: self.extra_data.into_static(),

     

       30
       30
       +
               }

     

       31
       31
       +
           }

     

       32
       32
       +
       }

     

       33
       33
       +
       

     

       34
       34
       +
       #[jacquard_derive::lexicon]

     

       9
       35
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       10
       36
        
       #[serde(rename_all = "camelCase")]

     

       11
       37
        
       pub struct Images<'a> {

     

       12
       12
       -
           pub images: Vec<jacquard_common::types::value::Data<'a>>,

     

       38
       38
       +
           #[serde(borrow)]

     

       39
       39
       +
           pub images: Vec<test_generated::app_bsky::embed::images::Image<'a>>,

     

       13
       40
        
       }

     

       41
       41
       +
       

     

       42
       42
       +
       impl jacquard_common::IntoStatic for Images<'_> {

     

       43
       43
       +
           type Output = Images<'static>;

     

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

     

       45
       45
       +
               Images {

     

       46
       46
       +
                   images: self.images.into_static(),

     

       47
       47
       +
                   extra_data: self.extra_data.into_static(),

     

       48
       48
       +
               }

     

       49
       49
       +
           }

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       #[jacquard_derive::lexicon]

     

       14
       53
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       15
       54
        
       #[serde(rename_all = "camelCase")]

     

       16
       55
        
       pub struct View<'a> {

     

       17
       17
       -
           pub images: Vec<jacquard_common::types::value::Data<'a>>,

     

       56
       56
       +
           #[serde(borrow)]

     

       57
       57
       +
           pub images: Vec<test_generated::app_bsky::embed::images::ViewImage<'a>>,

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       impl jacquard_common::IntoStatic for View<'_> {

     

       61
       61
       +
           type Output = View<'static>;

     

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

     

       63
       63
       +
               View {

     

       64
       64
       +
                   images: self.images.into_static(),

     

       65
       65
       +
                   extra_data: self.extra_data.into_static(),

     

       66
       66
       +
               }

     

       67
       67
       +
           }

     

       18
       68
        
       }

     

       69
       69
       +
       

     

       70
       70
       +
       #[jacquard_derive::lexicon]

     

       19
       71
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       20
       72
        
       #[serde(rename_all = "camelCase")]

     

       21
       73
        
       pub struct ViewImage<'a> {

     

       74
       74
       +
           ///Alt text description of the image, for accessibility.

     

       75
       75
       +
           #[serde(borrow)]

     

       22
       76
        
           pub alt: jacquard_common::CowStr<'a>,

     

       23
       23
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       24
       24
       -
           pub aspect_ratio: Option<jacquard_common::types::value::Data<'a>>,

     

       77
       77
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       78
       78
       +
           #[serde(borrow)]

     

       79
       79
       +
           pub aspect_ratio: std::option::Option<jacquard_common::types::value::Data<'a>>,

     

       80
       80
       +
           ///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.

     

       81
       81
       +
           #[serde(borrow)]

     

       25
       82
        
           pub fullsize: jacquard_common::types::string::Uri<'a>,

     

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

     

       84
       84
       +
           #[serde(borrow)]

     

       26
       85
        
           pub thumb: jacquard_common::types::string::Uri<'a>,

     

       27
       86
        
       }

     

       87
       87
       +
       

     

       88
       88
       +
       impl jacquard_common::IntoStatic for ViewImage<'_> {

     

       89
       89
       +
           type Output = ViewImage<'static>;

     

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

     

       91
       91
       +
               ViewImage {

     

       92
       92
       +
                   alt: self.alt.into_static(),

     

       93
       93
       +
                   aspect_ratio: self.aspect_ratio.into_static(),

     

       94
       94
       +
                   fullsize: self.fullsize.into_static(),

     

       95
       95
       +
                   thumb: self.thumb.into_static(),

     

       96
       96
       +
                   extra_data: self.extra_data.into_static(),

     

       97
       97
       +
               }

     

       98
       98
       +
           }

     

       99
       99
       +
       }

+133 -14

crates/jacquard-lexicon/target/test_codegen_output/app_bsky/embed/record.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.bsky.embed.record

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       1
       9
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       2
       10
        
       #[serde(rename_all = "camelCase")]

     

       3
       11
        
       pub struct Record<'a> {

     

       4
       4
       -
           pub record: test_generated::com_atproto::repo::StrongRef<'a>,

     

       12
       12
       +
           #[serde(borrow)]

     

       13
       13
       +
           pub record: test_generated::com_atproto::repo::strong_ref::StrongRef<'a>,

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       impl jacquard_common::IntoStatic for Record<'_> {

     

       17
       17
       +
           type Output = Record<'static>;

     

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

     

       19
       19
       +
               Record {

     

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

     

       21
       21
       +
                   extra_data: self.extra_data.into_static(),

     

       22
       22
       +
               }

     

       23
       23
       +
           }

     

       5
       24
        
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       6
       27
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       7
       28
        
       #[serde(rename_all = "camelCase")]

     

       8
       29
        
       pub struct View<'a> {

     

       9
       9
       -
           pub record: RecordRecord<'a>,

     

       30
       30
       +
           #[serde(borrow)]

     

       31
       31
       +
           pub record: ViewRecordRecord<'a>,

     

       10
       32
        
       }

     

       33
       33
       +
       

     

       34
       34
       +
       #[jacquard_derive::open_union]

     

       35
       35
       +
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       36
       36
       +
       #[serde(tag = "$type")]

     

       37
       37
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       38
       38
       +
       pub enum ViewRecordRecord<'a> {}

     

       39
       39
       +
       impl jacquard_common::IntoStatic for ViewRecordRecord<'_> {

     

       40
       40
       +
           type Output = ViewRecordRecord<'static>;

     

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

     

       42
       42
       +
               match self {

     

       43
       43
       +
                   ViewRecordRecord::Unknown(v) => ViewRecordRecord::Unknown(v.into_static()),

     

       44
       44
       +
               }

     

       45
       45
       +
           }

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       impl jacquard_common::IntoStatic for View<'_> {

     

       49
       49
       +
           type Output = View<'static>;

     

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

     

       51
       51
       +
               View {

     

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

     

       53
       53
       +
                   extra_data: self.extra_data.into_static(),

     

       54
       54
       +
               }

     

       55
       55
       +
           }

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       #[jacquard_derive::lexicon]

     

       11
       59
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       12
       60
        
       #[serde(rename_all = "camelCase")]

     

       13
       61
        
       pub struct ViewBlocked<'a> {

     

       62
       62
       +
           #[serde(borrow)]

     

       14
       63
        
           pub author: jacquard_common::types::value::Data<'a>,

     

       15
       64
        
           pub blocked: bool,

     

       65
       65
       +
           #[serde(borrow)]

     

       16
       66
        
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       17
       67
        
       }

     

       68
       68
       +
       

     

       69
       69
       +
       impl jacquard_common::IntoStatic for ViewBlocked<'_> {

     

       70
       70
       +
           type Output = ViewBlocked<'static>;

     

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

     

       72
       72
       +
               ViewBlocked {

     

       73
       73
       +
                   author: self.author.into_static(),

     

       74
       74
       +
                   blocked: self.blocked.into_static(),

     

       75
       75
       +
                   uri: self.uri.into_static(),

     

       76
       76
       +
                   extra_data: self.extra_data.into_static(),

     

       77
       77
       +
               }

     

       78
       78
       +
           }

     

       79
       79
       +
       }

     

       80
       80
       +
       

     

       81
       81
       +
       #[jacquard_derive::lexicon]

     

       18
       82
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       19
       83
        
       #[serde(rename_all = "camelCase")]

     

       20
       84
        
       pub struct ViewDetached<'a> {

     

       21
       85
        
           pub detached: bool,

     

       86
       86
       +
           #[serde(borrow)]

     

       22
       87
        
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       23
       88
        
       }

     

       89
       89
       +
       

     

       90
       90
       +
       impl jacquard_common::IntoStatic for ViewDetached<'_> {

     

       91
       91
       +
           type Output = ViewDetached<'static>;

     

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

     

       93
       93
       +
               ViewDetached {

     

       94
       94
       +
                   detached: self.detached.into_static(),

     

       95
       95
       +
                   uri: self.uri.into_static(),

     

       96
       96
       +
                   extra_data: self.extra_data.into_static(),

     

       97
       97
       +
               }

     

       98
       98
       +
           }

     

       99
       99
       +
       }

     

       100
       100
       +
       

     

       101
       101
       +
       #[jacquard_derive::lexicon]

     

       24
       102
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       25
       103
        
       #[serde(rename_all = "camelCase")]

     

       26
       104
        
       pub struct ViewNotFound<'a> {

     

       27
       105
        
           pub not_found: bool,

     

       106
       106
       +
           #[serde(borrow)]

     

       28
       107
        
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       29
       108
        
       }

     

       109
       109
       +
       

     

       110
       110
       +
       impl jacquard_common::IntoStatic for ViewNotFound<'_> {

     

       111
       111
       +
           type Output = ViewNotFound<'static>;

     

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

     

       113
       113
       +
               ViewNotFound {

     

       114
       114
       +
                   not_found: self.not_found.into_static(),

     

       115
       115
       +
                   uri: self.uri.into_static(),

     

       116
       116
       +
                   extra_data: self.extra_data.into_static(),

     

       117
       117
       +
               }

     

       118
       118
       +
           }

     

       119
       119
       +
       }

     

       120
       120
       +
       

     

       121
       121
       +
       #[jacquard_derive::lexicon]

     

       30
       122
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       31
       123
        
       #[serde(rename_all = "camelCase")]

     

       32
       124
        
       pub struct ViewRecord<'a> {

     

       125
       125
       +
           #[serde(borrow)]

     

       33
       126
        
           pub author: jacquard_common::types::value::Data<'a>,

     

       127
       127
       +
           #[serde(borrow)]

     

       34
       128
        
           pub cid: jacquard_common::types::string::Cid<'a>,

     

       35
       35
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       36
       36
       -
           pub embeds: Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       129
       129
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       130
       130
       +
           #[serde(borrow)]

     

       131
       131
       +
           pub embeds: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       37
       132
        
           pub indexed_at: jacquard_common::types::string::Datetime,

     

       38
       38
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       39
       39
       -
           pub labels: Option<Vec<test_generated::com_atproto::label::Label<'a>>>,

     

       40
       40
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       41
       41
       -
           pub like_count: Option<i64>,

     

       42
       42
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       43
       43
       -
           pub quote_count: Option<i64>,

     

       44
       44
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       45
       45
       -
           pub reply_count: Option<i64>,

     

       46
       46
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       47
       47
       -
           pub repost_count: Option<i64>,

     

       133
       133
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       134
       134
       +
           #[serde(borrow)]

     

       135
       135
       +
           pub labels: std::option::Option<Vec<test_generated::com_atproto::label::Label<'a>>>,

     

       136
       136
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       137
       137
       +
           pub like_count: std::option::Option<i64>,

     

       138
       138
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       139
       139
       +
           pub quote_count: std::option::Option<i64>,

     

       140
       140
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       141
       141
       +
           pub reply_count: std::option::Option<i64>,

     

       142
       142
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       143
       143
       +
           pub repost_count: std::option::Option<i64>,

     

       144
       144
       +
           #[serde(borrow)]

     

       48
       145
        
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       146
       146
       +
           ///The record data itself.

     

       147
       147
       +
           #[serde(borrow)]

     

       49
       148
        
           pub value: jacquard_common::types::value::Data<'a>,

     

       50
       149
        
       }

     

       150
       150
       +
       

     

       151
       151
       +
       impl jacquard_common::IntoStatic for ViewRecord<'_> {

     

       152
       152
       +
           type Output = ViewRecord<'static>;

     

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

     

       154
       154
       +
               ViewRecord {

     

       155
       155
       +
                   author: self.author.into_static(),

     

       156
       156
       +
                   cid: self.cid.into_static(),

     

       157
       157
       +
                   embeds: self.embeds.into_static(),

     

       158
       158
       +
                   indexed_at: self.indexed_at.into_static(),

     

       159
       159
       +
                   labels: self.labels.into_static(),

     

       160
       160
       +
                   like_count: self.like_count.into_static(),

     

       161
       161
       +
                   quote_count: self.quote_count.into_static(),

     

       162
       162
       +
                   reply_count: self.reply_count.into_static(),

     

       163
       163
       +
                   repost_count: self.repost_count.into_static(),

     

       164
       164
       +
                   uri: self.uri.into_static(),

     

       165
       165
       +
                   value: self.value.into_static(),

     

       166
       166
       +
                   extra_data: self.extra_data.into_static(),

     

       167
       167
       +
               }

     

       168
       168
       +
           }

     

       169
       169
       +
       }

+102 -4

crates/jacquard-lexicon/target/test_codegen_output/app_bsky/embed/record_with_media.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.bsky.embed.recordWithMedia

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       1
       9
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       2
       10
        
       #[serde(rename_all = "camelCase")]

     

       3
       11
        
       pub struct RecordWithMedia<'a> {

     

       4
       4
       -
           pub media: RecordMedia<'a>,

     

       5
       5
       -
           pub record: test_generated::app_bsky::embed::Record<'a>,

     

       12
       12
       +
           #[serde(borrow)]

     

       13
       13
       +
           pub media: RecordWithMediaRecordMedia<'a>,

     

       14
       14
       +
           #[serde(borrow)]

     

       15
       15
       +
           pub record: test_generated::app_bsky::embed::record::Record<'a>,

     

       6
       16
        
       }

     

       17
       17
       +
       

     

       18
       18
       +
       #[jacquard_derive::open_union]

     

       19
       19
       +
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       20
       20
       +
       #[serde(tag = "$type")]

     

       21
       21
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       22
       22
       +
       pub enum RecordWithMediaRecordMedia<'a> {

     

       23
       23
       +
           #[serde(rename = "app.bsky.embed.images")]

     

       24
       24
       +
           Images(Box<test_generated::app_bsky::embed::images::Images<'a>>),

     

       25
       25
       +
           #[serde(rename = "app.bsky.embed.video")]

     

       26
       26
       +
           Video(Box<test_generated::app_bsky::embed::video::Video<'a>>),

     

       27
       27
       +
           #[serde(rename = "app.bsky.embed.external")]

     

       28
       28
       +
           External(Box<test_generated::app_bsky::embed::external::ExternalRecord<'a>>),

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       impl jacquard_common::IntoStatic for RecordWithMediaRecordMedia<'_> {

     

       32
       32
       +
           type Output = RecordWithMediaRecordMedia<'static>;

     

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

     

       34
       34
       +
               match self {

     

       35
       35
       +
                   RecordWithMediaRecordMedia::Images(v) => {

     

       36
       36
       +
                       RecordWithMediaRecordMedia::Images(v.into_static())

     

       37
       37
       +
                   }

     

       38
       38
       +
                   RecordWithMediaRecordMedia::Video(v) => {

     

       39
       39
       +
                       RecordWithMediaRecordMedia::Video(v.into_static())

     

       40
       40
       +
                   }

     

       41
       41
       +
                   RecordWithMediaRecordMedia::External(v) => {

     

       42
       42
       +
                       RecordWithMediaRecordMedia::External(v.into_static())

     

       43
       43
       +
                   }

     

       44
       44
       +
                   RecordWithMediaRecordMedia::Unknown(v) => {

     

       45
       45
       +
                       RecordWithMediaRecordMedia::Unknown(v.into_static())

     

       46
       46
       +
                   }

     

       47
       47
       +
               }

     

       48
       48
       +
           }

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       impl jacquard_common::IntoStatic for RecordWithMedia<'_> {

     

       52
       52
       +
           type Output = RecordWithMedia<'static>;

     

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

     

       54
       54
       +
               RecordWithMedia {

     

       55
       55
       +
                   media: self.media.into_static(),

     

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

     

       57
       57
       +
                   extra_data: self.extra_data.into_static(),

     

       58
       58
       +
               }

     

       59
       59
       +
           }

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       #[jacquard_derive::lexicon]

     

       7
       63
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       8
       64
        
       #[serde(rename_all = "camelCase")]

     

       9
       65
        
       pub struct View<'a> {

     

       10
       10
       -
           pub media: RecordMedia<'a>,

     

       11
       11
       -
           pub record: test_generated::app_bsky::embed::View<'a>,

     

       66
       66
       +
           #[serde(borrow)]

     

       67
       67
       +
           pub media: ViewRecordMedia<'a>,

     

       68
       68
       +
           #[serde(borrow)]

     

       69
       69
       +
           pub record: test_generated::app_bsky::embed::record::View<'a>,

     

       70
       70
       +
       }

     

       71
       71
       +
       

     

       72
       72
       +
       #[jacquard_derive::open_union]

     

       73
       73
       +
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       74
       74
       +
       #[serde(tag = "$type")]

     

       75
       75
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       76
       76
       +
       pub enum ViewRecordMedia<'a> {

     

       77
       77
       +
           #[serde(rename = "app.bsky.embed.images#view")]

     

       78
       78
       +
           ImagesView(Box<test_generated::app_bsky::embed::images::View<'a>>),

     

       79
       79
       +
           #[serde(rename = "app.bsky.embed.video#view")]

     

       80
       80
       +
           VideoView(Box<test_generated::app_bsky::embed::video::View<'a>>),

     

       81
       81
       +
           #[serde(rename = "app.bsky.embed.external#view")]

     

       82
       82
       +
           ExternalView(Box<test_generated::app_bsky::embed::external::View<'a>>),

     

       83
       83
       +
       }

     

       84
       84
       +
       

     

       85
       85
       +
       impl jacquard_common::IntoStatic for ViewRecordMedia<'_> {

     

       86
       86
       +
           type Output = ViewRecordMedia<'static>;

     

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

     

       88
       88
       +
               match self {

     

       89
       89
       +
                   ViewRecordMedia::ImagesView(v) => {

     

       90
       90
       +
                       ViewRecordMedia::ImagesView(v.into_static())

     

       91
       91
       +
                   }

     

       92
       92
       +
                   ViewRecordMedia::VideoView(v) => ViewRecordMedia::VideoView(v.into_static()),

     

       93
       93
       +
                   ViewRecordMedia::ExternalView(v) => {

     

       94
       94
       +
                       ViewRecordMedia::ExternalView(v.into_static())

     

       95
       95
       +
                   }

     

       96
       96
       +
                   ViewRecordMedia::Unknown(v) => ViewRecordMedia::Unknown(v.into_static()),

     

       97
       97
       +
               }

     

       98
       98
       +
           }

     

       12
       99
        
       }

     

       100
       100
       +
       

     

       101
       101
       +
       impl jacquard_common::IntoStatic for View<'_> {

     

       102
       102
       +
           type Output = View<'static>;

     

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

     

       104
       104
       +
               View {

     

       105
       105
       +
                   media: self.media.into_static(),

     

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

     

       107
       107
       +
                   extra_data: self.extra_data.into_static(),

     

       108
       108
       +
               }

     

       109
       109
       +
           }

     

       110
       110
       +
       }

+76 -12

crates/jacquard-lexicon/target/test_codegen_output/app_bsky/embed/video.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.bsky.embed.video

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       1
       9
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       2
       10
        
       #[serde(rename_all = "camelCase")]

     

       3
       11
        
       pub struct Caption<'a> {

     

       12
       12
       +
           #[serde(borrow)]

     

       4
       13
        
           pub file: jacquard_common::types::blob::Blob<'a>,

     

       5
       14
        
           pub lang: jacquard_common::types::string::Language,

     

       6
       15
        
       }

     

       16
       16
       +
       

     

       17
       17
       +
       impl jacquard_common::IntoStatic for Caption<'_> {

     

       18
       18
       +
           type Output = Caption<'static>;

     

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

     

       20
       20
       +
               Caption {

     

       21
       21
       +
                   file: self.file.into_static(),

     

       22
       22
       +
                   lang: self.lang.into_static(),

     

       23
       23
       +
                   extra_data: self.extra_data.into_static(),

     

       24
       24
       +
               }

     

       25
       25
       +
           }

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       #[jacquard_derive::lexicon]

     

       7
       29
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       8
       30
        
       #[serde(rename_all = "camelCase")]

     

       9
       31
        
       pub struct Video<'a> {

     

       10
       10
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       11
       11
       -
           pub alt: Option<jacquard_common::CowStr<'a>>,

     

       12
       12
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       13
       13
       -
           pub aspect_ratio: Option<jacquard_common::types::value::Data<'a>>,

     

       14
       14
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       15
       15
       -
           pub captions: Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       32
       32
       +
           ///Alt text description of the video, for accessibility.

     

       33
       33
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       34
       34
       +
           #[serde(borrow)]

     

       35
       35
       +
           pub alt: std::option::Option<jacquard_common::CowStr<'a>>,

     

       36
       36
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       37
       37
       +
           #[serde(borrow)]

     

       38
       38
       +
           pub aspect_ratio: std::option::Option<jacquard_common::types::value::Data<'a>>,

     

       39
       39
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       40
       40
       +
           #[serde(borrow)]

     

       41
       41
       +
           pub captions: std::option::Option<

     

       42
       42
       +
               Vec<test_generated::app_bsky::embed::video::Caption<'a>>,

     

       43
       43
       +
           >,

     

       44
       44
       +
           ///The mp4 video file. May be up to 100mb, formerly limited to 50mb.

     

       45
       45
       +
           #[serde(borrow)]

     

       16
       46
        
           pub video: jacquard_common::types::blob::Blob<'a>,

     

       17
       47
        
       }

     

       48
       48
       +
       

     

       49
       49
       +
       impl jacquard_common::IntoStatic for Video<'_> {

     

       50
       50
       +
           type Output = Video<'static>;

     

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

     

       52
       52
       +
               Video {

     

       53
       53
       +
                   alt: self.alt.into_static(),

     

       54
       54
       +
                   aspect_ratio: self.aspect_ratio.into_static(),

     

       55
       55
       +
                   captions: self.captions.into_static(),

     

       56
       56
       +
                   video: self.video.into_static(),

     

       57
       57
       +
                   extra_data: self.extra_data.into_static(),

     

       58
       58
       +
               }

     

       59
       59
       +
           }

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       #[jacquard_derive::lexicon]

     

       18
       63
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       19
       64
        
       #[serde(rename_all = "camelCase")]

     

       20
       65
        
       pub struct View<'a> {

     

       21
       21
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       22
       22
       -
           pub alt: Option<jacquard_common::CowStr<'a>>,

     

       23
       23
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       24
       24
       -
           pub aspect_ratio: Option<jacquard_common::types::value::Data<'a>>,

     

       66
       66
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       67
       67
       +
           #[serde(borrow)]

     

       68
       68
       +
           pub alt: std::option::Option<jacquard_common::CowStr<'a>>,

     

       69
       69
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       70
       70
       +
           #[serde(borrow)]

     

       71
       71
       +
           pub aspect_ratio: std::option::Option<jacquard_common::types::value::Data<'a>>,

     

       72
       72
       +
           #[serde(borrow)]

     

       25
       73
        
           pub cid: jacquard_common::types::string::Cid<'a>,

     

       74
       74
       +
           #[serde(borrow)]

     

       26
       75
        
           pub playlist: jacquard_common::types::string::Uri<'a>,

     

       27
       27
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       28
       28
       -
           pub thumbnail: Option<jacquard_common::types::string::Uri<'a>>,

     

       76
       76
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       77
       77
       +
           #[serde(borrow)]

     

       78
       78
       +
           pub thumbnail: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       29
       79
        
       }

     

       80
       80
       +
       

     

       81
       81
       +
       impl jacquard_common::IntoStatic for View<'_> {

     

       82
       82
       +
           type Output = View<'static>;

     

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

     

       84
       84
       +
               View {

     

       85
       85
       +
                   alt: self.alt.into_static(),

     

       86
       86
       +
                   aspect_ratio: self.aspect_ratio.into_static(),

     

       87
       87
       +
                   cid: self.cid.into_static(),

     

       88
       88
       +
                   playlist: self.playlist.into_static(),

     

       89
       89
       +
                   thumbnail: self.thumbnail.into_static(),

     

       90
       90
       +
                   extra_data: self.extra_data.into_static(),

     

       91
       91
       +
               }

     

       92
       92
       +
           }

     

       93
       93
       +
       }

+6 -1

crates/jacquard-lexicon/target/test_codegen_output/app_bsky/feed.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       1
       6
        
       pub mod get_author_feed;

     

       2
       2
       -
       pub mod post;

     

       7
       7
       +
       pub mod post;

+86 -15

crates/jacquard-lexicon/target/test_codegen_output/app_bsky/feed/get_author_feed.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.bsky.feed.getAuthorFeed

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       1
       8
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       2
       9
        
       #[serde(rename_all = "camelCase")]

     

       3
       3
       -
       pub struct GetAuthorFeedParams<'a> {

     

       10
       10
       +
       pub struct GetAuthorFeed<'a> {

     

       11
       11
       +
           #[serde(borrow)]

     

       4
       12
        
           pub actor: jacquard_common::types::ident::AtIdentifier<'a>,

     

       5
       5
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       6
       6
       -
           pub cursor: Option<jacquard_common::CowStr<'a>>,

     

       7
       7
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       8
       8
       -
           pub filter: Option<jacquard_common::CowStr<'a>>,

     

       9
       9
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       10
       10
       -
           pub include_pins: Option<bool>,

     

       11
       11
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       12
       12
       -
           pub limit: Option<i64>,

     

       13
       13
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       14
       14
       +
           #[serde(borrow)]

     

       15
       15
       +
           pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,

     

       16
       16
       +
           ///(default: "posts_with_replies")

     

       17
       17
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       18
       18
       +
           #[serde(borrow)]

     

       19
       19
       +
           pub filter: std::option::Option<jacquard_common::CowStr<'a>>,

     

       20
       20
       +
           ///(default: false)

     

       21
       21
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       22
       22
       +
           pub include_pins: std::option::Option<bool>,

     

       23
       23
       +
           ///(default: 50, min: 1, max: 100)

     

       24
       24
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       25
       25
       +
           pub limit: std::option::Option<i64>,

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       impl jacquard_common::IntoStatic for GetAuthorFeed<'_> {

     

       29
       29
       +
           type Output = GetAuthorFeed<'static>;

     

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

     

       31
       31
       +
               GetAuthorFeed {

     

       32
       32
       +
                   actor: self.actor.into_static(),

     

       33
       33
       +
                   cursor: self.cursor.into_static(),

     

       34
       34
       +
                   filter: self.filter.into_static(),

     

       35
       35
       +
                   include_pins: self.include_pins.into_static(),

     

       36
       36
       +
                   limit: self.limit.into_static(),

     

       37
       37
       +
               }

     

       38
       38
       +
           }

     

       13
       39
        
       }

     

       40
       40
       +
       

     

       41
       41
       +
       #[jacquard_derive::lexicon]

     

       14
       42
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       15
       43
        
       #[serde(rename_all = "camelCase")]

     

       16
       44
        
       pub struct GetAuthorFeedOutput<'a> {

     

       17
       17
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       18
       18
       -
           pub cursor: Option<jacquard_common::CowStr<'a>>,

     

       45
       45
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
       +
           #[serde(borrow)]

     

       47
       47
       +
           pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,

     

       48
       48
       +
           #[serde(borrow)]

     

       19
       49
        
           pub feed: Vec<jacquard_common::types::value::Data<'a>>,

     

       20
       50
        
       }

     

       51
       51
       +
       

     

       52
       52
       +
       impl jacquard_common::IntoStatic for GetAuthorFeedOutput<'_> {

     

       53
       53
       +
           type Output = GetAuthorFeedOutput<'static>;

     

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

     

       55
       55
       +
               GetAuthorFeedOutput {

     

       56
       56
       +
                   cursor: self.cursor.into_static(),

     

       57
       57
       +
                   feed: self.feed.into_static(),

     

       58
       58
       +
                   extra_data: self.extra_data.into_static(),

     

       59
       59
       +
               }

     

       60
       60
       +
           }

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       #[jacquard_derive::open_union]

     

       21
       64
        
       #[derive(

     

       22
       65
        
           serde::Serialize,

     

       23
       66
        
           serde::Deserialize,

     
···

       29
       72
        
           miette::Diagnostic

     

       30
       73
        
       )]

     

       31
       74
        
       #[serde(tag = "error", content = "message")]

     

       32
       32
       -
       pub enum GetAuthorFeedError {

     

       75
       75
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       76
       76
       +
       pub enum GetAuthorFeedError<'a> {

     

       33
       77
        
           #[serde(rename = "BlockedActor")]

     

       34
       34
       -
           BlockedActor(Option<jacquard_common::CowStr<'static>>),

     

       78
       78
       +
           BlockedActor(std::option::Option<String>),

     

       35
       79
        
           #[serde(rename = "BlockedByActor")]

     

       36
       36
       -
           BlockedByActor(Option<jacquard_common::CowStr<'static>>),

     

       80
       80
       +
           BlockedByActor(std::option::Option<String>),

     

       37
       81
        
       }

     

       38
       38
       -
       impl std::fmt::Display for GetAuthorFeedError {

     

       82
       82
       +
       

     

       83
       83
       +
       impl std::fmt::Display for GetAuthorFeedError<'_> {

     

       39
       84
        
           fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

     

       40
       85
        
               match self {

     

       41
       86
        
                   Self::BlockedActor(msg) => {

     
···

       52
       97
        
                       }

     

       53
       98
        
                       Ok(())

     

       54
       99
        
                   }

     

       100
       100
       +
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       55
       101
        
               }

     

       56
       102
        
           }

     

       57
       103
        
       }

     

       104
       104
       +
       

     

       105
       105
       +
       impl jacquard_common::IntoStatic for GetAuthorFeedError<'_> {

     

       106
       106
       +
           type Output = GetAuthorFeedError<'static>;

     

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

     

       108
       108
       +
               match self {

     

       109
       109
       +
                   GetAuthorFeedError::BlockedActor(v) => {

     

       110
       110
       +
                       GetAuthorFeedError::BlockedActor(v.into_static())

     

       111
       111
       +
                   }

     

       112
       112
       +
                   GetAuthorFeedError::BlockedByActor(v) => {

     

       113
       113
       +
                       GetAuthorFeedError::BlockedByActor(v.into_static())

     

       114
       114
       +
                   }

     

       115
       115
       +
                   GetAuthorFeedError::Unknown(v) => {

     

       116
       116
       +
                       GetAuthorFeedError::Unknown(v.into_static())

     

       117
       117
       +
                   }

     

       118
       118
       +
               }

     

       119
       119
       +
           }

     

       120
       120
       +
       }

     

       121
       121
       +
       

     

       122
       122
       +
       impl jacquard_common::types::xrpc::XrpcRequest for GetAuthorFeed<'_> {

     

       123
       123
       +
           const NSID: &'static str = "app.bsky.feed.getAuthorFeed";

     

       124
       124
       +
           const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;

     

       125
       125
       +
           const OUTPUT_ENCODING: &'static str = "application/json";

     

       126
       126
       +
           type Output<'de> = GetAuthorFeedOutput<'de>;

     

       127
       127
       +
           type Err<'de> = GetAuthorFeedError<'de>;

     

       128
       128
       +
       }

+152 -25

crates/jacquard-lexicon/target/test_codegen_output/app_bsky/feed/post.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.bsky.feed.post

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       1
       8
        
       ///Deprecated: use facets instead.

     

       9
       9
       +
       #[jacquard_derive::lexicon]

     

       2
       10
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       3
       11
        
       #[serde(rename_all = "camelCase")]

     

       4
       12
        
       pub struct Entity<'a> {

     

       5
       5
       -
           pub index: jacquard_common::types::value::Data<'a>,

     

       13
       13
       +
           #[serde(borrow)]

     

       14
       14
       +
           pub index: test_generated::app_bsky::feed::post::TextSlice<'a>,

     

       15
       15
       +
           ///Expected values are 'mention' and 'link'.

     

       16
       16
       +
           #[serde(borrow)]

     

       6
       17
        
           pub r#type: jacquard_common::CowStr<'a>,

     

       18
       18
       +
           #[serde(borrow)]

     

       7
       19
        
           pub value: jacquard_common::CowStr<'a>,

     

       8
       20
        
       }

     

       21
       21
       +
       

     

       22
       22
       +
       impl jacquard_common::IntoStatic for Entity<'_> {

     

       23
       23
       +
           type Output = Entity<'static>;

     

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

     

       25
       25
       +
               Entity {

     

       26
       26
       +
                   index: self.index.into_static(),

     

       27
       27
       +
                   r#type: self.r#type.into_static(),

     

       28
       28
       +
                   value: self.value.into_static(),

     

       29
       29
       +
                   extra_data: self.extra_data.into_static(),

     

       30
       30
       +
               }

     

       31
       31
       +
           }

     

       32
       32
       +
       }

     

       33
       33
       +
       

     

       9
       34
        
       ///Record containing a Bluesky post.

     

       10
       35
        
       #[jacquard_derive::lexicon]

     

       11
       36
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       12
       37
        
       #[serde(rename_all = "camelCase")]

     

       13
       38
        
       pub struct Post<'a> {

     

       39
       39
       +
           ///Client-declared timestamp when this post was originally created.

     

       14
       40
        
           pub created_at: jacquard_common::types::string::Datetime,

     

       15
       15
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       16
       16
       -
           pub embed: Option<RecordEmbed<'a>>,

     

       17
       17
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       18
       18
       -
           pub entities: Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       19
       19
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       20
       20
       -
           pub facets: Option<Vec<test_generated::app_bsky::richtext::Facet<'a>>>,

     

       21
       21
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       22
       22
       -
           pub labels: Option<RecordLabels<'a>>,

     

       23
       23
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       24
       24
       -
           pub langs: Option<Vec<jacquard_common::types::string::Language>>,

     

       25
       25
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       26
       26
       -
           pub reply: Option<jacquard_common::types::value::Data<'a>>,

     

       27
       27
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       28
       28
       -
           pub tags: Option<Vec<jacquard_common::CowStr<'a>>>,

     

       41
       41
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       42
       42
       +
           #[serde(borrow)]

     

       43
       43
       +
           pub embed: std::option::Option<PostRecordEmbed<'a>>,

     

       44
       44
       +
           ///DEPRECATED: replaced by app.bsky.richtext.facet.

     

       45
       45
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
       +
           #[serde(borrow)]

     

       47
       47
       +
           pub entities: std::option::Option<

     

       48
       48
       +
               Vec<test_generated::app_bsky::feed::post::Entity<'a>>,

     

       49
       49
       +
           >,

     

       50
       50
       +
           ///Annotations of text (mentions, URLs, hashtags, etc)

     

       51
       51
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       52
       52
       +
           #[serde(borrow)]

     

       53
       53
       +
           pub facets: std::option::Option<

     

       54
       54
       +
               Vec<test_generated::app_bsky::richtext::facet::Facet<'a>>,

     

       55
       55
       +
           >,

     

       56
       56
       +
           ///Self-label values for this post. Effectively content warnings.

     

       57
       57
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       58
       58
       +
           #[serde(borrow)]

     

       59
       59
       +
           pub labels: std::option::Option<PostRecordLabels<'a>>,

     

       60
       60
       +
           ///Indicates human language of post primary text content.

     

       61
       61
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       62
       62
       +
           pub langs: std::option::Option<Vec<jacquard_common::types::string::Language>>,

     

       63
       63
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       64
       64
       +
           #[serde(borrow)]

     

       65
       65
       +
           pub reply: std::option::Option<test_generated::app_bsky::feed::post::ReplyRef<'a>>,

     

       66
       66
       +
           ///Additional hashtags, in addition to any included in post text and facets.

     

       67
       67
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       68
       68
       +
           #[serde(borrow)]

     

       69
       69
       +
           pub tags: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,

     

       70
       70
       +
           ///The primary post content. May be an empty string, if there are embeds.

     

       71
       71
       +
           #[serde(borrow)]

     

       29
       72
        
           pub text: jacquard_common::CowStr<'a>,

     

       30
       73
        
       }

     

       74
       74
       +
       

     

       31
       75
        
       #[jacquard_derive::open_union]

     

       32
       76
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       33
       77
        
       #[serde(tag = "$type")]

     

       34
       34
       -
       pub enum RecordEmbed<'a> {

     

       78
       78
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       79
       79
       +
       pub enum PostRecordEmbed<'a> {

     

       35
       80
        
           #[serde(rename = "app.bsky.embed.images")]

     

       36
       36
       -
           Images(Box<test_generated::app_bsky::embed::Images<'a>>),

     

       81
       81
       +
           Images(Box<test_generated::app_bsky::embed::images::Images<'a>>),

     

       37
       82
        
           #[serde(rename = "app.bsky.embed.video")]

     

       38
       38
       -
           Video(Box<test_generated::app_bsky::embed::Video<'a>>),

     

       83
       83
       +
           Video(Box<test_generated::app_bsky::embed::video::Video<'a>>),

     

       39
       84
        
           #[serde(rename = "app.bsky.embed.external")]

     

       40
       40
       -
           External(Box<test_generated::app_bsky::embed::External<'a>>),

     

       85
       85
       +
           External(Box<test_generated::app_bsky::embed::external::ExternalRecord<'a>>),

     

       41
       86
        
           #[serde(rename = "app.bsky.embed.record")]

     

       42
       42
       -
           Record(Box<test_generated::app_bsky::embed::Record<'a>>),

     

       87
       87
       +
           Record(Box<test_generated::app_bsky::embed::record::Record<'a>>),

     

       43
       88
        
           #[serde(rename = "app.bsky.embed.recordWithMedia")]

     

       44
       44
       -
           RecordWithMedia(Box<test_generated::app_bsky::embed::RecordWithMedia<'a>>),

     

       89
       89
       +
           RecordWithMedia(

     

       90
       90
       +
               Box<test_generated::app_bsky::embed::record_with_media::RecordWithMedia<'a>>,

     

       91
       91
       +
           ),

     

       92
       92
       +
       }

     

       93
       93
       +
       

     

       94
       94
       +
       impl jacquard_common::IntoStatic for PostRecordEmbed<'_> {

     

       95
       95
       +
           type Output = PostRecordEmbed<'static>;

     

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

     

       97
       97
       +
               match self {

     

       98
       98
       +
                   PostRecordEmbed::Images(v) => PostRecordEmbed::Images(v.into_static()),

     

       99
       99
       +
                   PostRecordEmbed::Video(v) => PostRecordEmbed::Video(v.into_static()),

     

       100
       100
       +
                   PostRecordEmbed::External(v) => PostRecordEmbed::External(v.into_static()),

     

       101
       101
       +
                   PostRecordEmbed::Record(v) => PostRecordEmbed::Record(v.into_static()),

     

       102
       102
       +
                   PostRecordEmbed::RecordWithMedia(v) => {

     

       103
       103
       +
                       PostRecordEmbed::RecordWithMedia(v.into_static())

     

       104
       104
       +
                   }

     

       105
       105
       +
                   PostRecordEmbed::Unknown(v) => PostRecordEmbed::Unknown(v.into_static()),

     

       106
       106
       +
               }

     

       107
       107
       +
           }

     

       45
       108
        
       }

     

       109
       109
       +
       

     

       46
       110
        
       #[jacquard_derive::open_union]

     

       47
       111
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       48
       112
        
       #[serde(tag = "$type")]

     

       49
       49
       -
       pub enum RecordLabels<'a> {

     

       113
       113
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       114
       114
       +
       pub enum PostRecordLabels<'a> {

     

       50
       115
        
           #[serde(rename = "com.atproto.label.defs#selfLabels")]

     

       51
       51
       -
           SelfLabels(Box<test_generated::com_atproto::label::SelfLabels<'a>>),

     

       116
       116
       +
           DefsSelfLabels(Box<test_generated::com_atproto::label::SelfLabels<'a>>),

     

       52
       117
        
       }

     

       118
       118
       +
       

     

       119
       119
       +
       impl jacquard_common::IntoStatic for PostRecordLabels<'_> {

     

       120
       120
       +
           type Output = PostRecordLabels<'static>;

     

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

     

       122
       122
       +
               match self {

     

       123
       123
       +
                   PostRecordLabels::DefsSelfLabels(v) => {

     

       124
       124
       +
                       PostRecordLabels::DefsSelfLabels(v.into_static())

     

       125
       125
       +
                   }

     

       126
       126
       +
                   PostRecordLabels::Unknown(v) => PostRecordLabels::Unknown(v.into_static()),

     

       127
       127
       +
               }

     

       128
       128
       +
           }

     

       129
       129
       +
       }

     

       130
       130
       +
       

     

       131
       131
       +
       impl jacquard_common::types::collection::Collection for Post<'_> {

     

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

     

       133
       133
       +
       }

     

       134
       134
       +
       

     

       135
       135
       +
       impl jacquard_common::IntoStatic for Post<'_> {

     

       136
       136
       +
           type Output = Post<'static>;

     

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

     

       138
       138
       +
               Post {

     

       139
       139
       +
                   created_at: self.created_at.into_static(),

     

       140
       140
       +
                   embed: self.embed.into_static(),

     

       141
       141
       +
                   entities: self.entities.into_static(),

     

       142
       142
       +
                   facets: self.facets.into_static(),

     

       143
       143
       +
                   labels: self.labels.into_static(),

     

       144
       144
       +
                   langs: self.langs.into_static(),

     

       145
       145
       +
                   reply: self.reply.into_static(),

     

       146
       146
       +
                   tags: self.tags.into_static(),

     

       147
       147
       +
                   text: self.text.into_static(),

     

       148
       148
       +
                   extra_data: self.extra_data.into_static(),

     

       149
       149
       +
               }

     

       150
       150
       +
           }

     

       151
       151
       +
       }

     

       152
       152
       +
       

     

       153
       153
       +
       #[jacquard_derive::lexicon]

     

       53
       154
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       54
       155
        
       #[serde(rename_all = "camelCase")]

     

       55
       156
        
       pub struct ReplyRef<'a> {

     

       56
       56
       -
           pub parent: test_generated::com_atproto::repo::StrongRef<'a>,

     

       57
       57
       -
           pub root: test_generated::com_atproto::repo::StrongRef<'a>,

     

       157
       157
       +
           #[serde(borrow)]

     

       158
       158
       +
           pub parent: test_generated::com_atproto::repo::strong_ref::StrongRef<'a>,

     

       159
       159
       +
           #[serde(borrow)]

     

       160
       160
       +
           pub root: test_generated::com_atproto::repo::strong_ref::StrongRef<'a>,

     

       58
       161
        
       }

     

       162
       162
       +
       

     

       163
       163
       +
       impl jacquard_common::IntoStatic for ReplyRef<'_> {

     

       164
       164
       +
           type Output = ReplyRef<'static>;

     

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

     

       166
       166
       +
               ReplyRef {

     

       167
       167
       +
                   parent: self.parent.into_static(),

     

       168
       168
       +
                   root: self.root.into_static(),

     

       169
       169
       +
                   extra_data: self.extra_data.into_static(),

     

       170
       170
       +
               }

     

       171
       171
       +
           }

     

       172
       172
       +
       }

     

       173
       173
       +
       

     

       59
       174
        
       ///Deprecated. Use app.bsky.richtext instead -- A text segment. Start is inclusive, end is exclusive. Indices are for utf16-encoded strings.

     

       175
       175
       +
       #[jacquard_derive::lexicon]

     

       60
       176
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       61
       177
        
       #[serde(rename_all = "camelCase")]

     

       62
       178
        
       pub struct TextSlice<'a> {

     

       63
       179
        
           pub end: i64,

     

       64
       180
        
           pub start: i64,

     

       65
       181
        
       }

     

       182
       182
       +
       

     

       183
       183
       +
       impl jacquard_common::IntoStatic for TextSlice<'_> {

     

       184
       184
       +
           type Output = TextSlice<'static>;

     

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

     

       186
       186
       +
               TextSlice {

     

       187
       187
       +
                   end: self.end.into_static(),

     

       188
       188
       +
                   start: self.start.into_static(),

     

       189
       189
       +
                   extra_data: self.extra_data.into_static(),

     

       190
       190
       +
               }

     

       191
       191
       +
           }

     

       192
       192
       +
       }

+6 -1

crates/jacquard-lexicon/target/test_codegen_output/app_bsky/richtext.rs

···

       1
       1
       -
       pub mod facet;

     

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       6
       6
       +
       pub mod facet;

+74 -1

crates/jacquard-lexicon/target/test_codegen_output/app_bsky/richtext/facet.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.bsky.richtext.facet

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       1
       8
        
       ///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.

     

       9
       9
       +
       #[jacquard_derive::lexicon]

     

       2
       10
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       3
       11
        
       #[serde(rename_all = "camelCase")]

     

       4
       12
        
       pub struct ByteSlice<'a> {

     

       5
       13
        
           pub byte_end: i64,

     

       6
       14
        
           pub byte_start: i64,

     

       7
       15
        
       }

     

       16
       16
       +
       

     

       17
       17
       +
       impl jacquard_common::IntoStatic for ByteSlice<'_> {

     

       18
       18
       +
           type Output = ByteSlice<'static>;

     

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

     

       20
       20
       +
               ByteSlice {

     

       21
       21
       +
                   byte_end: self.byte_end.into_static(),

     

       22
       22
       +
                   byte_start: self.byte_start.into_static(),

     

       23
       23
       +
                   extra_data: self.extra_data.into_static(),

     

       24
       24
       +
               }

     

       25
       25
       +
           }

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       8
       28
        
       ///Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.

     

       29
       29
       +
       #[jacquard_derive::lexicon]

     

       9
       30
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       10
       31
        
       #[serde(rename_all = "camelCase")]

     

       11
       32
        
       pub struct Link<'a> {

     

       33
       33
       +
           #[serde(borrow)]

     

       12
       34
        
           pub uri: jacquard_common::types::string::Uri<'a>,

     

       13
       35
        
       }

     

       36
       36
       +
       

     

       37
       37
       +
       impl jacquard_common::IntoStatic for Link<'_> {

     

       38
       38
       +
           type Output = Link<'static>;

     

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

     

       40
       40
       +
               Link {

     

       41
       41
       +
                   uri: self.uri.into_static(),

     

       42
       42
       +
                   extra_data: self.extra_data.into_static(),

     

       43
       43
       +
               }

     

       44
       44
       +
           }

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       14
       47
        
       ///Annotation of a sub-string within rich text.

     

       48
       48
       +
       #[jacquard_derive::lexicon]

     

       15
       49
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       16
       50
        
       #[serde(rename_all = "camelCase")]

     

       17
       51
        
       pub struct Facet<'a> {

     

       52
       52
       +
           #[serde(borrow)]

     

       18
       53
        
           pub features: Vec<jacquard_common::types::value::Data<'a>>,

     

       19
       19
       -
           pub index: jacquard_common::types::value::Data<'a>,

     

       54
       54
       +
           #[serde(borrow)]

     

       55
       55
       +
           pub index: test_generated::app_bsky::richtext::facet::ByteSlice<'a>,

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       impl jacquard_common::IntoStatic for Facet<'_> {

     

       59
       59
       +
           type Output = Facet<'static>;

     

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

     

       61
       61
       +
               Facet {

     

       62
       62
       +
                   features: self.features.into_static(),

     

       63
       63
       +
                   index: self.index.into_static(),

     

       64
       64
       +
                   extra_data: self.extra_data.into_static(),

     

       65
       65
       +
               }

     

       66
       66
       +
           }

     

       20
       67
        
       }

     

       68
       68
       +
       

     

       21
       69
        
       ///Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID.

     

       70
       70
       +
       #[jacquard_derive::lexicon]

     

       22
       71
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       23
       72
        
       #[serde(rename_all = "camelCase")]

     

       24
       73
        
       pub struct Mention<'a> {

     

       74
       74
       +
           #[serde(borrow)]

     

       25
       75
        
           pub did: jacquard_common::types::string::Did<'a>,

     

       26
       76
        
       }

     

       77
       77
       +
       

     

       78
       78
       +
       impl jacquard_common::IntoStatic for Mention<'_> {

     

       79
       79
       +
           type Output = Mention<'static>;

     

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

     

       81
       81
       +
               Mention {

     

       82
       82
       +
                   did: self.did.into_static(),

     

       83
       83
       +
                   extra_data: self.extra_data.into_static(),

     

       84
       84
       +
               }

     

       85
       85
       +
           }

     

       86
       86
       +
       }

     

       87
       87
       +
       

     

       27
       88
        
       ///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').

     

       89
       89
       +
       #[jacquard_derive::lexicon]

     

       28
       90
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       29
       91
        
       #[serde(rename_all = "camelCase")]

     

       30
       92
        
       pub struct Tag<'a> {

     

       93
       93
       +
           #[serde(borrow)]

     

       31
       94
        
           pub tag: jacquard_common::CowStr<'a>,

     

       32
       95
        
       }

     

       96
       96
       +
       

     

       97
       97
       +
       impl jacquard_common::IntoStatic for Tag<'_> {

     

       98
       98
       +
           type Output = Tag<'static>;

     

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

     

       100
       100
       +
               Tag {

     

       101
       101
       +
                   tag: self.tag.into_static(),

     

       102
       102
       +
                   extra_data: self.extra_data.into_static(),

     

       103
       103
       +
               }

     

       104
       104
       +
           }

     

       105
       105
       +
       }

+6 -1

crates/jacquard-lexicon/target/test_codegen_output/com_atproto.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       1
       6
        
       pub mod label;

     

       2
       2
       -
       pub mod repo;

     

       7
       7
       +
       pub mod repo;

+157 -28

crates/jacquard-lexicon/target/test_codegen_output/com_atproto/label.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: com.atproto.label.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       1
       8
        
       ///Metadata tag on an atproto resource (eg, repo or record).

     

       9
       9
       +
       #[jacquard_derive::lexicon]

     

       2
       10
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       3
       11
        
       #[serde(rename_all = "camelCase")]

     

       4
       12
        
       pub struct Label<'a> {

     

       5
       5
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       6
       6
       -
           pub cid: Option<jacquard_common::types::string::Cid<'a>>,

     

       13
       13
       +
           ///Optionally, CID specifying the specific version of 'uri' resource this label applies to.

     

       14
       14
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       15
       15
       +
           #[serde(borrow)]

     

       16
       16
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       17
       17
       +
           ///Timestamp when this label was created.

     

       7
       18
        
           pub cts: jacquard_common::types::string::Datetime,

     

       8
       8
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       9
       9
       -
           pub exp: Option<jacquard_common::types::string::Datetime>,

     

       10
       10
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       11
       11
       -
           pub neg: Option<bool>,

     

       12
       12
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       13
       13
       -
           pub sig: Option<jacquard_common::types::value::Bytes>,

     

       19
       19
       +
           ///Timestamp at which this label expires (no longer applies).

     

       20
       20
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       21
       21
       +
           pub exp: std::option::Option<jacquard_common::types::string::Datetime>,

     

       22
       22
       +
           ///If true, this is a negation label, overwriting a previous label.

     

       23
       23
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       24
       24
       +
           pub neg: std::option::Option<bool>,

     

       25
       25
       +
           ///Signature of dag-cbor encoded label.

     

       26
       26
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       27
       27
       +
           pub sig: std::option::Option<bytes::Bytes>,

     

       28
       28
       +
           ///DID of the actor who created this label.

     

       29
       29
       +
           #[serde(borrow)]

     

       14
       30
        
           pub src: jacquard_common::types::string::Did<'a>,

     

       31
       31
       +
           ///AT URI of the record, repository (account), or other resource that this label applies to.

     

       32
       32
       +
           #[serde(borrow)]

     

       15
       33
        
           pub uri: jacquard_common::types::string::Uri<'a>,

     

       34
       34
       +
           ///The short string name of the value or type of this label.

     

       35
       35
       +
           #[serde(borrow)]

     

       16
       36
        
           pub val: jacquard_common::CowStr<'a>,

     

       17
       17
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       18
       18
       -
           pub ver: Option<i64>,

     

       37
       37
       +
           ///The AT Protocol version of the label object.

     

       38
       38
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       39
       39
       +
           pub ver: std::option::Option<i64>,

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       impl jacquard_common::IntoStatic for Label<'_> {

     

       43
       43
       +
           type Output = Label<'static>;

     

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

     

       45
       45
       +
               Label {

     

       46
       46
       +
                   cid: self.cid.into_static(),

     

       47
       47
       +
                   cts: self.cts.into_static(),

     

       48
       48
       +
                   exp: self.exp.into_static(),

     

       49
       49
       +
                   neg: self.neg.into_static(),

     

       50
       50
       +
                   sig: self.sig.into_static(),

     

       51
       51
       +
                   src: self.src.into_static(),

     

       52
       52
       +
                   uri: self.uri.into_static(),

     

       53
       53
       +
                   val: self.val.into_static(),

     

       54
       54
       +
                   ver: self.ver.into_static(),

     

       55
       55
       +
                   extra_data: self.extra_data.into_static(),

     

       56
       56
       +
               }

     

       57
       57
       +
           }

     

       19
       58
        
       }

     

       59
       59
       +
       

     

       20
       60
        
       #[derive(Debug, Clone, PartialEq, Eq, Hash)]

     

       21
       61
        
       pub enum LabelValue<'a> {

     

       22
       22
       -
           #[serde(rename = "!hide")]

     

       23
       62
        
           Hide,

     

       24
       24
       -
           #[serde(rename = "!no-promote")]

     

       25
       63
        
           NoPromote,

     

       26
       26
       -
           #[serde(rename = "!warn")]

     

       27
       64
        
           Warn,

     

       28
       28
       -
           #[serde(rename = "!no-unauthenticated")]

     

       29
       65
        
           NoUnauthenticated,

     

       30
       30
       -
           #[serde(rename = "dmca-violation")]

     

       31
       66
        
           DmcaViolation,

     

       32
       32
       -
           #[serde(rename = "doxxing")]

     

       33
       67
        
           Doxxing,

     

       34
       34
       -
           #[serde(rename = "porn")]

     

       35
       68
        
           Porn,

     

       36
       36
       -
           #[serde(rename = "sexual")]

     

       37
       69
        
           Sexual,

     

       38
       38
       -
           #[serde(rename = "nudity")]

     

       39
       70
        
           Nudity,

     

       40
       40
       -
           #[serde(rename = "nsfl")]

     

       41
       71
        
           Nsfl,

     

       42
       42
       -
           #[serde(rename = "gore")]

     

       43
       72
        
           Gore,

     

       44
       44
       -
           #[serde(untagged)]

     

       45
       73
        
           Other(jacquard_common::CowStr<'a>),

     

       46
       74
        
       }

     

       75
       75
       +
       

     

       47
       76
        
       impl<'a> LabelValue<'a> {

     

       48
       77
        
           pub fn as_str(&self) -> &str {

     

       49
       78
        
               match self {

     
···

       62
       91
        
               }

     

       63
       92
        
           }

     

       64
       93
        
       }

     

       94
       94
       +
       

     

       65
       95
        
       impl<'a> From<&'a str> for LabelValue<'a> {

     

       66
       96
        
           fn from(s: &'a str) -> Self {

     

       67
       97
        
               match s {

     
···

       80
       110
        
               }

     

       81
       111
        
           }

     

       82
       112
        
       }

     

       113
       113
       +
       

     

       83
       114
        
       impl<'a> From<String> for LabelValue<'a> {

     

       84
       115
        
           fn from(s: String) -> Self {

     

       85
       116
        
               match s.as_str() {

     
···

       98
       129
        
               }

     

       99
       130
        
           }

     

       100
       131
        
       }

     

       132
       132
       +
       

     

       101
       133
        
       impl<'a> AsRef<str> for LabelValue<'a> {

     

       102
       134
        
           fn as_ref(&self) -> &str {

     

       103
       135
        
               self.as_str()

     

       104
       136
        
           }

     

       105
       137
        
       }

     

       138
       138
       +
       

     

       106
       139
        
       impl<'a> serde::Serialize for LabelValue<'a> {

     

       107
       140
        
           fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

     

       108
       141
        
           where

     
···

       111
       144
        
               serializer.serialize_str(self.as_str())

     

       112
       145
        
           }

     

       113
       146
        
       }

     

       147
       147
       +
       

     

       114
       148
        
       impl<'de, 'a> serde::Deserialize<'de> for LabelValue<'a>

     

       115
       149
        
       where

     

       116
       150
        
           'de: 'a,

     
···

       123
       157
        
               Ok(Self::from(s))

     

       124
       158
        
           }

     

       125
       159
        
       }

     

       160
       160
       +
       

     

       161
       161
       +
       impl jacquard_common::IntoStatic for LabelValue<'_> {

     

       162
       162
       +
           type Output = LabelValue<'static>;

     

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

     

       164
       164
       +
               match self {

     

       165
       165
       +
                   LabelValue::Hide => LabelValue::Hide,

     

       166
       166
       +
                   LabelValue::NoPromote => LabelValue::NoPromote,

     

       167
       167
       +
                   LabelValue::Warn => LabelValue::Warn,

     

       168
       168
       +
                   LabelValue::NoUnauthenticated => LabelValue::NoUnauthenticated,

     

       169
       169
       +
                   LabelValue::DmcaViolation => LabelValue::DmcaViolation,

     

       170
       170
       +
                   LabelValue::Doxxing => LabelValue::Doxxing,

     

       171
       171
       +
                   LabelValue::Porn => LabelValue::Porn,

     

       172
       172
       +
                   LabelValue::Sexual => LabelValue::Sexual,

     

       173
       173
       +
                   LabelValue::Nudity => LabelValue::Nudity,

     

       174
       174
       +
                   LabelValue::Nsfl => LabelValue::Nsfl,

     

       175
       175
       +
                   LabelValue::Gore => LabelValue::Gore,

     

       176
       176
       +
                   LabelValue::Other(v) => LabelValue::Other(v.into_static()),

     

       177
       177
       +
               }

     

       178
       178
       +
           }

     

       179
       179
       +
       }

     

       180
       180
       +
       

     

       126
       181
        
       ///Declares a label value and its expected interpretations and behaviors.

     

       182
       182
       +
       #[jacquard_derive::lexicon]

     

       127
       183
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       128
       184
        
       #[serde(rename_all = "camelCase")]

     

       129
       185
        
       pub struct LabelValueDefinition<'a> {

     

       130
       130
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       131
       131
       -
           pub adult_only: Option<bool>,

     

       186
       186
       +
           ///Does the user need to have adult content enabled in order to configure this label?

     

       187
       187
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       188
       188
       +
           pub adult_only: std::option::Option<bool>,

     

       189
       189
       +
           ///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.

     

       190
       190
       +
           #[serde(borrow)]

     

       132
       191
        
           pub blurs: jacquard_common::CowStr<'a>,

     

       133
       133
       -
           #[serde(skip_serializing_if = "Option::is_none")]

     

       134
       134
       -
           pub default_setting: Option<jacquard_common::CowStr<'a>>,

     

       192
       192
       +
           ///The default setting for this label.

     

       193
       193
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       194
       194
       +
           #[serde(borrow)]

     

       195
       195
       +
           pub default_setting: std::option::Option<jacquard_common::CowStr<'a>>,

     

       196
       196
       +
           ///The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+).

     

       197
       197
       +
           #[serde(borrow)]

     

       135
       198
        
           pub identifier: jacquard_common::CowStr<'a>,

     

       136
       136
       -
           pub locales: Vec<jacquard_common::types::value::Data<'a>>,

     

       199
       199
       +
           #[serde(borrow)]

     

       200
       200
       +
           pub locales: Vec<

     

       201
       201
       +
               test_generated::com_atproto::label::LabelValueDefinitionStrings<'a>,

     

       202
       202
       +
           >,

     

       203
       203
       +
           ///How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing.

     

       204
       204
       +
           #[serde(borrow)]

     

       137
       205
        
           pub severity: jacquard_common::CowStr<'a>,

     

       138
       206
        
       }

     

       207
       207
       +
       

     

       208
       208
       +
       impl jacquard_common::IntoStatic for LabelValueDefinition<'_> {

     

       209
       209
       +
           type Output = LabelValueDefinition<'static>;

     

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

     

       211
       211
       +
               LabelValueDefinition {

     

       212
       212
       +
                   adult_only: self.adult_only.into_static(),

     

       213
       213
       +
                   blurs: self.blurs.into_static(),

     

       214
       214
       +
                   default_setting: self.default_setting.into_static(),

     

       215
       215
       +
                   identifier: self.identifier.into_static(),

     

       216
       216
       +
                   locales: self.locales.into_static(),

     

       217
       217
       +
                   severity: self.severity.into_static(),

     

       218
       218
       +
                   extra_data: self.extra_data.into_static(),

     

       219
       219
       +
               }

     

       220
       220
       +
           }

     

       221
       221
       +
       }

     

       222
       222
       +
       

     

       139
       223
        
       ///Strings which describe the label in the UI, localized into a specific language.

     

       224
       224
       +
       #[jacquard_derive::lexicon]

     

       140
       225
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       141
       226
        
       #[serde(rename_all = "camelCase")]

     

       142
       227
        
       pub struct LabelValueDefinitionStrings<'a> {

     

       228
       228
       +
           ///A longer description of what the label means and why it might be applied.

     

       229
       229
       +
           #[serde(borrow)]

     

       143
       230
        
           pub description: jacquard_common::CowStr<'a>,

     

       231
       231
       +
           ///The code of the language these strings are written in.

     

       144
       232
        
           pub lang: jacquard_common::types::string::Language,

     

       233
       233
       +
           ///A short human-readable name for the label.

     

       234
       234
       +
           #[serde(borrow)]

     

       145
       235
        
           pub name: jacquard_common::CowStr<'a>,

     

       146
       236
        
       }

     

       237
       237
       +
       

     

       238
       238
       +
       impl jacquard_common::IntoStatic for LabelValueDefinitionStrings<'_> {

     

       239
       239
       +
           type Output = LabelValueDefinitionStrings<'static>;

     

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

     

       241
       241
       +
               LabelValueDefinitionStrings {

     

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

     

       243
       243
       +
                   lang: self.lang.into_static(),

     

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

     

       245
       245
       +
                   extra_data: self.extra_data.into_static(),

     

       246
       246
       +
               }

     

       247
       247
       +
           }

     

       248
       248
       +
       }

     

       249
       249
       +
       

     

       147
       250
        
       ///Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel.

     

       251
       251
       +
       #[jacquard_derive::lexicon]

     

       148
       252
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       149
       253
        
       #[serde(rename_all = "camelCase")]

     

       150
       254
        
       pub struct SelfLabel<'a> {

     

       255
       255
       +
           ///The short string name of the value or type of this label.

     

       256
       256
       +
           #[serde(borrow)]

     

       151
       257
        
           pub val: jacquard_common::CowStr<'a>,

     

       152
       258
        
       }

     

       259
       259
       +
       

     

       260
       260
       +
       impl jacquard_common::IntoStatic for SelfLabel<'_> {

     

       261
       261
       +
           type Output = SelfLabel<'static>;

     

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

     

       263
       263
       +
               SelfLabel {

     

       264
       264
       +
                   val: self.val.into_static(),

     

       265
       265
       +
                   extra_data: self.extra_data.into_static(),

     

       266
       266
       +
               }

     

       267
       267
       +
           }

     

       268
       268
       +
       }

     

       269
       269
       +
       

     

       153
       270
        
       ///Metadata tags on an atproto record, published by the author within the record.

     

       271
       271
       +
       #[jacquard_derive::lexicon]

     

       154
       272
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       155
       273
        
       #[serde(rename_all = "camelCase")]

     

       156
       274
        
       pub struct SelfLabels<'a> {

     

       157
       157
       -
           pub values: Vec<jacquard_common::types::value::Data<'a>>,

     

       275
       275
       +
           #[serde(borrow)]

     

       276
       276
       +
           pub values: Vec<test_generated::com_atproto::label::SelfLabel<'a>>,

     

       158
       277
        
       }

     

       278
       278
       +
       

     

       279
       279
       +
       impl jacquard_common::IntoStatic for SelfLabels<'_> {

     

       280
       280
       +
           type Output = SelfLabels<'static>;

     

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

     

       282
       282
       +
               SelfLabels {

     

       283
       283
       +
                   values: self.values.into_static(),

     

       284
       284
       +
                   extra_data: self.extra_data.into_static(),

     

       285
       285
       +
               }

     

       286
       286
       +
           }

     

       287
       287
       +
       }

+6 -1

crates/jacquard-lexicon/target/test_codegen_output/com_atproto/repo.rs

···

       1
       1
       -
       pub mod strong_ref;

     

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       6
       6
       +
       pub mod strong_ref;

+21

crates/jacquard-lexicon/target/test_codegen_output/com_atproto/repo/strong_ref.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: com.atproto.repo.strongRef

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       1
       9
        
       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

     

       2
       10
        
       #[serde(rename_all = "camelCase")]

     

       3
       11
        
       pub struct StrongRef<'a> {

     

       12
       12
       +
           #[serde(borrow)]

     

       4
       13
        
           pub cid: jacquard_common::types::string::Cid<'a>,

     

       14
       14
       +
           #[serde(borrow)]

     

       5
       15
        
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       6
       16
        
       }

     

       17
       17
       +
       

     

       18
       18
       +
       impl jacquard_common::IntoStatic for StrongRef<'_> {

     

       19
       19
       +
           type Output = StrongRef<'static>;

     

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

     

       21
       21
       +
               StrongRef {

     

       22
       22
       +
                   cid: self.cid.into_static(),

     

       23
       23
       +
                   uri: self.uri.into_static(),

     

       24
       24
       +
                   extra_data: self.extra_data.into_static(),

     

       25
       25
       +
               }

     

       26
       26
       +
           }

     

       27
       27
       +
       }

+6 -1

crates/jacquard-lexicon/target/test_codegen_output/lib.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       1
       6
        
       pub mod app_bsky;

     

       2
       2
       -
       pub mod com_atproto;

     

       7
       7
       +
       pub mod com_atproto;

+149 -25

crates/jacquard/src/client.rs

···

       4
       4
        
       use std::fmt::Display;

     

       5
       5
        
       use std::future::Future;

     

       6
       6
        
       

     

       7
       7
       -
       pub use error::{ClientError, Result};

     

       8
       7
        
       use bytes::Bytes;

     

       8
       8
       +
       pub use error::{ClientError, Result};

     

       9
       9
        
       use http::{

     

       10
       10
        
           HeaderName, HeaderValue, Request,

     

       11
       11
        
           header::{AUTHORIZATION, CONTENT_TYPE, InvalidHeaderValue},

     

       12
       12
        
       };

     

       13
       13
        
       pub use response::Response;

     

       14
       14
       -
       use serde::Serialize;

     

       14
       14
       +
       

     

       15
       15
       +
       use jacquard_common::{

     

       16
       16
       +
           CowStr, IntoStatic,

     

       17
       17
       +
           types::{

     

       18
       18
       +
               string::{Did, Handle},

     

       19
       19
       +
               xrpc::{XrpcMethod, XrpcRequest},

     

       20
       20
       +
           },

     

       21
       21
       +
       };

     

       22
       22
       +
       

     

       23
       23
       +
       /// Implement HttpClient for reqwest::Client

     

       24
       24
       +
       impl HttpClient for reqwest::Client {

     

       25
       25
       +
           type Error = reqwest::Error;

     

       26
       26
       +
       

     

       27
       27
       +
           async fn send_http(

     

       28
       28
       +
               &self,

     

       29
       29
       +
               request: Request<Vec<u8>>,

     

       30
       30
       +
           ) -> core::result::Result<http::Response<Vec<u8>>, Self::Error> {

     

       31
       31
       +
               // Convert http::Request to reqwest::Request

     

       32
       32
       +
               let (parts, body) = request.into_parts();

     

       15
       33
        
       

     

       16
       16
       -
       use jacquard_common::{CowStr, types::xrpc::{XrpcMethod, XrpcRequest}};

     

       34
       34
       +
               let mut req = self.request(parts.method, parts.uri.to_string()).body(body);

     

       35
       35
       +
       

     

       36
       36
       +
               // Copy headers

     

       37
       37
       +
               for (name, value) in parts.headers.iter() {

     

       38
       38
       +
                   req = req.header(name.as_str(), value.as_bytes());

     

       39
       39
       +
               }

     

       40
       40
       +
       

     

       41
       41
       +
               // Send request

     

       42
       42
       +
               let resp = req.send().await?;

     

       43
       43
       +
       

     

       44
       44
       +
               // Convert reqwest::Response to http::Response

     

       45
       45
       +
               let mut builder = http::Response::builder().status(resp.status());

     

       46
       46
       +
       

     

       47
       47
       +
               // Copy headers

     

       48
       48
       +
               for (name, value) in resp.headers().iter() {

     

       49
       49
       +
                   builder = builder.header(name.as_str(), value.as_bytes());

     

       50
       50
       +
               }

     

       51
       51
       +
       

     

       52
       52
       +
               // Read body

     

       53
       53
       +
               let body = resp.bytes().await?.to_vec();

     

       54
       54
       +
       

     

       55
       55
       +
               Ok(builder.body(body).expect("Failed to build response"))

     

       56
       56
       +
           }

     

       57
       57
       +
       }

     

       17
       58
        
       

     

       18
       59
        
       pub trait HttpClient {

     

       19
       60
        
           type Error: std::error::Error + Display + Send + Sync + 'static;

     
···

       98
       139
        
       

     

       99
       140
        
           // Add query parameters for Query methods

     

       100
       141
        
           if let XrpcMethod::Query = R::METHOD {

     

       101
       101
       -
               if let Ok(qs) = serde_html_form::to_string(&request) {

     

       102
       102
       -
                   if !qs.is_empty() {

     

       103
       103
       -
                       uri.push('?');

     

       104
       104
       -
                       uri.push_str(&qs);

     

       105
       105
       -
                   }

     

       142
       142
       +
               let qs = serde_html_form::to_string(&request).map_err(error::EncodeError::from)?;

     

       143
       143
       +
               if !qs.is_empty() {

     

       144
       144
       +
                   uri.push('?');

     

       145
       145
       +
                   uri.push_str(&qs);

     

       106
       146
        
               }

     

       107
       147
        
           }

     

       108
       148
        
       

     
···

       139
       179
        
           }

     

       140
       180
        
       

     

       141
       181
        
           // Serialize body for procedures

     

       142
       142
       -
           let body = if let XrpcMethod::Procedure(encoding) = R::METHOD {

     

       143
       143
       -
               if encoding == "application/json" {

     

       144
       144
       -
                   serde_json::to_vec(&request).map_err(error::EncodeError::Json)?

     

       145
       145
       -
               } else {

     

       146
       146
       -
                   // For other encodings, we'd need different serialization

     

       147
       147
       -
                   vec![]

     

       148
       148
       -
               }

     

       182
       182
       +
           let body = if let XrpcMethod::Procedure(_) = R::METHOD {

     

       183
       183
       +
               request.encode_body()?

     

       149
       184
        
           } else {

     

       150
       185
        
               vec![]

     

       151
       186
        
           };

     

       152
       187
        
       

     

       188
       188
       +
           // TODO: make this not panic

     

       153
       189
        
           let http_request = builder.body(body).expect("Failed to build HTTP request");

     

       154
       190
        
       

     

       155
       191
        
           // Send HTTP request

     

       156
       156
       -
           let http_response = client.send_http(http_request).await.map_err(|e| {

     

       157
       157
       -
               error::TransportError::Other(Box::new(e))

     

       158
       158
       -
           })?;

     

       192
       192
       +
           let http_response = client

     

       193
       193
       +
               .send_http(http_request)

     

       194
       194
       +
               .await

     

       195
       195
       +
               .map_err(|e| error::TransportError::Other(Box::new(e)))?;

     

       196
       196
       +
       

     

       197
       197
       +
           let status = http_response.status();

     

       198
       198
       +
           let buffer = Bytes::from(http_response.into_body());

     

       159
       199
        
       

     

       160
       160
       -
           // Check status

     

       161
       161
       -
           if !http_response.status().is_success() {

     

       200
       200
       +
           // XRPC errors come as 400/401 with structured error bodies

     

       201
       201
       +
           // Other error status codes (404, 500, etc.) are generic HTTP errors

     

       202
       202
       +
           if !status.is_success() && !matches!(status.as_u16(), 400 | 401) {

     

       162
       203
        
               return Err(ClientError::Http(error::HttpError {

     

       163
       163
       -
                   status: http_response.status(),

     

       164
       164
       -
                   body: Some(Bytes::from(http_response.body().clone())),

     

       204
       204
       +
                   status,

     

       205
       205
       +
                   body: Some(buffer),

     

       165
       206
        
               }));

     

       166
       207
        
           }

     

       167
       208
        
       

     

       168
       168
       -
           // Convert to Response

     

       169
       169
       -
           let buffer = Bytes::from(http_response.into_body());

     

       170
       170
       -
           Ok(Response::new(buffer))

     

       209
       209
       +
           // Response will parse XRPC errors for 400/401, or output for 2xx

     

       210
       210
       +
           Ok(Response::new(buffer, status))

     

       211
       211
       +
       }

     

       212
       212
       +
       

     

       213
       213
       +
       /// Session information from createSession

     

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

     

       215
       215
       +
       pub struct Session {

     

       216
       216
       +
           pub access_jwt: CowStr<'static>,

     

       217
       217
       +
           pub refresh_jwt: CowStr<'static>,

     

       218
       218
       +
           pub did: Did<'static>,

     

       219
       219
       +
           pub handle: Handle<'static>,

     

       220
       220
       +
       }

     

       221
       221
       +
       

     

       222
       222
       +
       impl From<jacquard_api::com_atproto::server::create_session::CreateSessionOutput<'_>> for Session {

     

       223
       223
       +
           fn from(

     

       224
       224
       +
               output: jacquard_api::com_atproto::server::create_session::CreateSessionOutput<'_>,

     

       225
       225
       +
           ) -> Self {

     

       226
       226
       +
               Self {

     

       227
       227
       +
                   access_jwt: output.access_jwt.into_static(),

     

       228
       228
       +
                   refresh_jwt: output.refresh_jwt.into_static(),

     

       229
       229
       +
                   did: output.did.into_static(),

     

       230
       230
       +
                   handle: output.handle.into_static(),

     

       231
       231
       +
               }

     

       232
       232
       +
           }

     

       233
       233
       +
       }

     

       234
       234
       +
       

     

       235
       235
       +
       /// Authenticated XRPC client that includes session tokens

     

       236
       236
       +
       pub struct AuthenticatedClient<C> {

     

       237
       237
       +
           client: C,

     

       238
       238
       +
           base_uri: CowStr<'static>,

     

       239
       239
       +
           session: Option<Session>,

     

       240
       240
       +
       }

     

       241
       241
       +
       

     

       242
       242
       +
       impl<C> AuthenticatedClient<C> {

     

       243
       243
       +
           /// Create a new authenticated client with a base URI

     

       244
       244
       +
           pub fn new(client: C, base_uri: CowStr<'static>) -> Self {

     

       245
       245
       +
               Self {

     

       246
       246
       +
                   client,

     

       247
       247
       +
                   base_uri: base_uri,

     

       248
       248
       +
                   session: None,

     

       249
       249
       +
               }

     

       250
       250
       +
           }

     

       251
       251
       +
       

     

       252
       252
       +
           /// Set the session

     

       253
       253
       +
           pub fn set_session(&mut self, session: Session) {

     

       254
       254
       +
               self.session = Some(session);

     

       255
       255
       +
           }

     

       256
       256
       +
       

     

       257
       257
       +
           /// Get the current session

     

       258
       258
       +
           pub fn session(&self) -> Option<&Session> {

     

       259
       259
       +
               self.session.as_ref()

     

       260
       260
       +
           }

     

       261
       261
       +
       

     

       262
       262
       +
           /// Clear the session

     

       263
       263
       +
           pub fn clear_session(&mut self) {

     

       264
       264
       +
               self.session = None;

     

       265
       265
       +
           }

     

       266
       266
       +
       }

     

       267
       267
       +
       

     

       268
       268
       +
       impl<C: HttpClient> HttpClient for AuthenticatedClient<C> {

     

       269
       269
       +
           type Error = C::Error;

     

       270
       270
       +
       

     

       271
       271
       +
           fn send_http(

     

       272
       272
       +
               &self,

     

       273
       273
       +
               request: Request<Vec<u8>>,

     

       274
       274
       +
           ) -> impl Future<Output = core::result::Result<http::Response<Vec<u8>>, Self::Error>> {

     

       275
       275
       +
               self.client.send_http(request)

     

       276
       276
       +
           }

     

       277
       277
       +
       }

     

       278
       278
       +
       

     

       279
       279
       +
       impl<C: HttpClient> XrpcClient for AuthenticatedClient<C> {

     

       280
       280
       +
           fn base_uri(&self) -> CowStr<'_> {

     

       281
       281
       +
               self.base_uri.clone()

     

       282
       282
       +
           }

     

       283
       283
       +
       

     

       284
       284
       +
           async fn authorization_token(&self, is_refresh: bool) -> Option<AuthorizationToken<'_>> {

     

       285
       285
       +
               if is_refresh {

     

       286
       286
       +
                   self.session

     

       287
       287
       +
                       .as_ref()

     

       288
       288
       +
                       .map(|s| AuthorizationToken::Bearer(s.refresh_jwt.clone()))

     

       289
       289
       +
               } else {

     

       290
       290
       +
                   self.session

     

       291
       291
       +
                       .as_ref()

     

       292
       292
       +
                       .map(|s| AuthorizationToken::Bearer(s.access_jwt.clone()))

     

       293
       293
       +
               }

     

       294
       294
       +
           }

     

       171
       295
        
       }

+2 -15

crates/jacquard/src/client/error.rs

···

       59
       59
        
           Other(Box<dyn std::error::Error + Send + Sync>),

     

       60
       60
        
       }

     

       61
       61
        
       

     

       62
       62
       -
       #[derive(Debug, thiserror::Error, miette::Diagnostic)]

     

       63
       63
       -
       pub enum EncodeError {

     

       64
       64
       -
           #[error("Failed to serialize query: {0}")]

     

       65
       65
       -
           Query(

     

       66
       66
       -
               #[from]

     

       67
       67
       -
               #[source]

     

       68
       68
       -
               serde_html_form::ser::Error,

     

       69
       69
       -
           ),

     

       70
       70
       -
           #[error("Failed to serialize JSON: {0}")]

     

       71
       71
       -
           Json(

     

       72
       72
       -
               #[from]

     

       73
       73
       -
               #[source]

     

       74
       74
       -
               serde_json::Error,

     

       75
       75
       -
           ),

     

       76
       76
       -
       }

     

       62
       62
       +
       // Re-export EncodeError from common

     

       63
       63
       +
       pub use jacquard_common::types::xrpc::EncodeError;

     

       77
       64
        
       

     

       78
       65
        
       #[derive(Debug, thiserror::Error, miette::Diagnostic)]

     

       79
       66
        
       pub enum DecodeError {

+109 -12

crates/jacquard/src/client/response.rs

···

       1
       1
        
       use bytes::Bytes;

     

       2
       2
       +
       use http::StatusCode;

     

       2
       3
        
       use jacquard_common::IntoStatic;

     

       3
       4
        
       use jacquard_common::types::xrpc::XrpcRequest;

     

       5
       5
       +
       use serde::Deserialize;

     

       4
       6
        
       use std::marker::PhantomData;

     

       7
       7
       +
       

     

       8
       8
       +
       use super::error::AuthError;

     

       5
       9
        
       

     

       6
       10
        
       /// XRPC response wrapper that owns the response buffer

     

       7
       11
        
       ///

     

       8
       12
        
       /// Allows borrowing from the buffer when parsing to avoid unnecessary allocations.

     

       9
       13
        
       pub struct Response<R: XrpcRequest> {

     

       10
       14
        
           buffer: Bytes,

     

       15
       15
       +
           status: StatusCode,

     

       11
       16
        
           _marker: PhantomData<R>,

     

       12
       17
        
       }

     

       13
       18
        
       

     

       14
       19
        
       impl<R: XrpcRequest> Response<R> {

     

       15
       15
       -
           /// Create a new response from a buffer

     

       16
       16
       -
           pub fn new(buffer: Bytes) -> Self {

     

       20
       20
       +
           /// Create a new response from a buffer and status code

     

       21
       21
       +
           pub fn new(buffer: Bytes, status: StatusCode) -> Self {

     

       17
       22
        
               Self {

     

       18
       23
        
                   buffer,

     

       24
       24
       +
                   status,

     

       19
       25
        
                   _marker: PhantomData,

     

       20
       26
        
               }

     

       27
       27
       +
           }

     

       28
       28
       +
       

     

       29
       29
       +
           /// Get the HTTP status code

     

       30
       30
       +
           pub fn status(&self) -> StatusCode {

     

       31
       31
       +
               self.status

     

       21
       32
        
           }

     

       22
       33
        
       

     

       23
       34
        
           /// Parse the response, borrowing from the internal buffer

     
···

       35
       46
        
                   serde_json::from_slice(buffer)

     

       36
       47
        
               }

     

       37
       48
        
       

     

       38
       38
       -
               let output = parse_output::<R>(&self.buffer);

     

       39
       39
       -
               if let Ok(output) = output {

     

       40
       40
       -
                   Ok(output)

     

       41
       41
       -
               } else {

     

       42
       42
       -
                   // Try to parse as error

     

       49
       49
       +
               // 200: parse as output

     

       50
       50
       +
               if self.status.is_success() {

     

       51
       51
       +
                   match parse_output::<R>(&self.buffer) {

     

       52
       52
       +
                       Ok(output) => Ok(output),

     

       53
       53
       +
                       Err(e) => Err(XrpcError::Decode(e)),

     

       54
       54
       +
                   }

     

       55
       55
       +
               // 400: try typed XRPC error, fallback to generic error

     

       56
       56
       +
               } else if self.status.as_u16() == 400 {

     

       43
       57
        
                   match parse_error::<R>(&self.buffer) {

     

       44
       58
        
                       Ok(error) => Err(XrpcError::Xrpc(error)),

     

       59
       59
       +
                       Err(_) => {

     

       60
       60
       +
                           // Fallback to generic error (InvalidRequest, ExpiredToken, etc.)

     

       61
       61
       +
                           match serde_json::from_slice::<GenericXrpcError>(&self.buffer) {

     

       62
       62
       +
                               Ok(generic) => {

     

       63
       63
       +
                                   // Map auth-related errors to AuthError

     

       64
       64
       +
                                   match generic.error.as_str() {

     

       65
       65
       +
                                       "ExpiredToken" => Err(XrpcError::Auth(AuthError::TokenExpired)),

     

       66
       66
       +
                                       "InvalidToken" => Err(XrpcError::Auth(AuthError::InvalidToken)),

     

       67
       67
       +
                                       _ => Err(XrpcError::Generic(generic)),

     

       68
       68
       +
                                   }

     

       69
       69
       +
                               }

     

       70
       70
       +
                               Err(e) => Err(XrpcError::Decode(e)),

     

       71
       71
       +
                           }

     

       72
       72
       +
                       }

     

       73
       73
       +
                   }

     

       74
       74
       +
               // 401: always auth error

     

       75
       75
       +
               } else {

     

       76
       76
       +
                   match serde_json::from_slice::<GenericXrpcError>(&self.buffer) {

     

       77
       77
       +
                       Ok(generic) => {

     

       78
       78
       +
                           match generic.error.as_str() {

     

       79
       79
       +
                               "ExpiredToken" => Err(XrpcError::Auth(AuthError::TokenExpired)),

     

       80
       80
       +
                               "InvalidToken" => Err(XrpcError::Auth(AuthError::InvalidToken)),

     

       81
       81
       +
                               _ => Err(XrpcError::Auth(AuthError::NotAuthenticated)),

     

       82
       82
       +
                           }

     

       83
       83
       +
                       }

     

       45
       84
        
                       Err(e) => Err(XrpcError::Decode(e)),

     

       46
       85
        
                   }

     

       47
       86
        
               }

     
···

       66
       105
        
                   serde_json::from_slice(buffer)

     

       67
       106
        
               }

     

       68
       107
        
       

     

       69
       69
       -
               let output = parse_output::<R>(&self.buffer);

     

       70
       70
       -
               if let Ok(output) = output {

     

       71
       71
       -
                   Ok(output.into_static())

     

       72
       72
       -
               } else {

     

       73
       73
       -
                   // Try to parse as error

     

       108
       108
       +
               // 200: parse as output

     

       109
       109
       +
               if self.status.is_success() {

     

       110
       110
       +
                   match parse_output::<R>(&self.buffer) {

     

       111
       111
       +
                       Ok(output) => Ok(output.into_static()),

     

       112
       112
       +
                       Err(e) => Err(XrpcError::Decode(e)),

     

       113
       113
       +
                   }

     

       114
       114
       +
               // 400: try typed XRPC error, fallback to generic error

     

       115
       115
       +
               } else if self.status.as_u16() == 400 {

     

       74
       116
        
                   match parse_error::<R>(&self.buffer) {

     

       75
       117
        
                       Ok(error) => Err(XrpcError::Xrpc(error.into_static())),

     

       118
       118
       +
                       Err(_) => {

     

       119
       119
       +
                           // Fallback to generic error (InvalidRequest, ExpiredToken, etc.)

     

       120
       120
       +
                           match serde_json::from_slice::<GenericXrpcError>(&self.buffer) {

     

       121
       121
       +
                               Ok(generic) => {

     

       122
       122
       +
                                   // Map auth-related errors to AuthError

     

       123
       123
       +
                                   match generic.error.as_str() {

     

       124
       124
       +
                                       "ExpiredToken" => Err(XrpcError::Auth(AuthError::TokenExpired)),

     

       125
       125
       +
                                       "InvalidToken" => Err(XrpcError::Auth(AuthError::InvalidToken)),

     

       126
       126
       +
                                       _ => Err(XrpcError::Generic(generic)),

     

       127
       127
       +
                                   }

     

       128
       128
       +
                               }

     

       129
       129
       +
                               Err(e) => Err(XrpcError::Decode(e)),

     

       130
       130
       +
                           }

     

       131
       131
       +
                       }

     

       132
       132
       +
                   }

     

       133
       133
       +
               // 401: always auth error

     

       134
       134
       +
               } else {

     

       135
       135
       +
                   match serde_json::from_slice::<GenericXrpcError>(&self.buffer) {

     

       136
       136
       +
                       Ok(generic) => {

     

       137
       137
       +
                           match generic.error.as_str() {

     

       138
       138
       +
                               "ExpiredToken" => Err(XrpcError::Auth(AuthError::TokenExpired)),

     

       139
       139
       +
                               "InvalidToken" => Err(XrpcError::Auth(AuthError::InvalidToken)),

     

       140
       140
       +
                               _ => Err(XrpcError::Auth(AuthError::NotAuthenticated)),

     

       141
       141
       +
                           }

     

       142
       142
       +
                       }

     

       76
       143
        
                       Err(e) => Err(XrpcError::Decode(e)),

     

       77
       144
        
                   }

     

       78
       145
        
               }

     
···

       84
       151
        
           }

     

       85
       152
        
       }

     

       86
       153
        
       

     

       154
       154
       +
       /// Generic XRPC error format (for InvalidRequest, etc.)

     

       155
       155
       +
       #[derive(Debug, Clone, Deserialize)]

     

       156
       156
       +
       pub struct GenericXrpcError {

     

       157
       157
       +
           pub error: String,

     

       158
       158
       +
           pub message: Option<String>,

     

       159
       159
       +
       }

     

       160
       160
       +
       

     

       161
       161
       +
       impl std::fmt::Display for GenericXrpcError {

     

       162
       162
       +
           fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

     

       163
       163
       +
               if let Some(msg) = &self.message {

     

       164
       164
       +
                   write!(f, "{}: {}", self.error, msg)

     

       165
       165
       +
               } else {

     

       166
       166
       +
                   write!(f, "{}", self.error)

     

       167
       167
       +
               }

     

       168
       168
       +
           }

     

       169
       169
       +
       }

     

       170
       170
       +
       

     

       171
       171
       +
       impl std::error::Error for GenericXrpcError {}

     

       172
       172
       +
       

     

       87
       173
        
       #[derive(Debug, thiserror::Error, miette::Diagnostic)]

     

       88
       174
        
       pub enum XrpcError<E: std::error::Error + IntoStatic> {

     

       175
       175
       +
           /// Typed XRPC error from the endpoint's error enum

     

       89
       176
        
           #[error("XRPC error: {0}")]

     

       90
       177
        
           Xrpc(E),

     

       178
       178
       +
       

     

       179
       179
       +
           /// Authentication error (ExpiredToken, InvalidToken, etc.)

     

       180
       180
       +
           #[error("Authentication error: {0}")]

     

       181
       181
       +
           Auth(#[from] AuthError),

     

       182
       182
       +
       

     

       183
       183
       +
           /// Generic XRPC error (InvalidRequest, etc.)

     

       184
       184
       +
           #[error("XRPC error: {0}")]

     

       185
       185
       +
           Generic(GenericXrpcError),

     

       186
       186
       +
       

     

       187
       187
       +
           /// Failed to decode response

     

       91
       188
        
           #[error("Failed to decode response: {0}")]

     

       92
       189
        
           Decode(#[from] serde_json::Error),

     

       93
       190
        
       }