commit f3945760935c37cf1b159f4fedc36da7fdd66a0d · zbrox.com/jacquard

+9 -1

CHANGELOG.md

···

       4
       4
        
       

     

       5
       5
        
       ### Added

     

       6
       6
        
       

     

       7
       7
       +
       **Value type deserialization** (`jacquard-common`)

     

       8
       8
       +
       - `from_json_value()`: Deserialize typed data directly from `serde_json::Value` without borrowing

     

       9
       9
       +
       - `from_data_owned()`, `from_raw_data_owned()`: Owned deserialization helpers

     

       10
       10
       +
       - `Data::from_json_owned()`: Parse JSON into owned `Data<'static>`

     

       11
       11
       +
       - `IntoStatic` implementation for `RawData` enabling owned conversions

     

       12
       12
       +
       - Re-exported value types from crate root for easier imports

     

       13
       13
       +
       - `Deserializer` trait implementations for `Data<'static>` and `RawData<'static>`

     

       14
       14
       +
       - Owned deserializer helpers: `OwnedArrayDeserializer`, `OwnedObjectDeserializer`, `OwnedBlobDeserializer`

     

       15
       15
       +
       

     

       7
       16
        
       **Service Auth** (`jacquard-axum`, `jacquard-common`)

     

       8
       17
        
       - Full service authentication implementation for inter-service JWT verification

     

       9
       18
        
       - `ExtractServiceAuth` Axum extractor for validating service auth tokens

     
···

       11
       20
        
       - Service auth claims validation (issuer, audience, expiration, method binding)

     

       12
       21
        
       - DID document resolution for signing key verification

     

       13
       22
        
       - Optional replay protection via `ReplayTracker` trait

     

       14
       14
       -
       - See CLAUDE.md for detailed implementation notes

     

       15
       23
        
       

     

       16
       24
        
       **XrpcRequest derive macro** (`jacquard-derive`)

     

       17
       25
        
       - `#[derive(XrpcRequest)]` for custom XRPC endpoints

crates/jacquard-common/src/lib.rs

···

       221
       221
        
       // XRPC protocol types and traits

     

       222
       222
        
       pub mod xrpc;

     

       223
       223
        
       

     

       224
       224
       +
       pub use types::value::*;

     

       225
       225
       +
       

     

       224
       226
        
       /// Authorization token types for XRPC requests.

     

       225
       227
        
       #[derive(Debug, Clone)]

     

       226
       228
        
       pub enum AuthorizationToken<'s> {

+62 -4

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

···

       112
       112
        
               })

     

       113
       113
        
           }

     

       114
       114
        
       

     

       115
       115
       +
           /// Parse a Data value from a JSON value (owned)

     

       116
       116
       +
           pub fn from_json_owned(json: serde_json::Value) -> Result<Data<'static>, AtDataError> {

     

       117
       117
       +
               Data::from_json(&json).map(|data| data.into_static())

     

       118
       118
       +
           }

     

       119
       119
       +
       

     

       115
       120
        
           /// Parse a Data value from an IPLD value (CBOR)

     

       116
       121
        
           pub fn from_cbor(cbor: &'s Ipld) -> Result<Self, AtDataError> {

     

       117
       122
        
               Ok(match cbor {

     
···

       352
       357
        
           InvalidData(Bytes),

     

       353
       358
        
       }

     

       354
       359
        
       

     

       360
       360
       +
       impl IntoStatic for RawData<'_> {

     

       361
       361
       +
           type Output = RawData<'static>;

     

       362
       362
       +
       

     

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

     

       364
       364
       +
               match self {

     

       365
       365
       +
                   RawData::Null => RawData::Null,

     

       366
       366
       +
                   RawData::Boolean(b) => RawData::Boolean(b),

     

       367
       367
       +
                   RawData::SignedInt(i) => RawData::SignedInt(i),

     

       368
       368
       +
                   RawData::UnsignedInt(u) => RawData::UnsignedInt(u),

     

       369
       369
       +
                   RawData::String(s) => RawData::String(s.into_static()),

     

       370
       370
       +
                   RawData::Bytes(b) => RawData::Bytes(b.into_static()),

     

       371
       371
       +
                   RawData::CidLink(c) => RawData::CidLink(c.into_static()),

     

       372
       372
       +
                   RawData::Array(a) => RawData::Array(a.into_static()),

     

       373
       373
       +
                   RawData::Object(o) => RawData::Object(o.into_static()),

     

       374
       374
       +
                   RawData::Blob(b) => RawData::Blob(b.into_static()),

     

       375
       375
       +
                   RawData::InvalidBlob(b) => RawData::InvalidBlob(b.into_static()),

     

       376
       376
       +
                   RawData::InvalidNumber(b) => RawData::InvalidNumber(b.into_static()),

     

       377
       377
       +
                   RawData::InvalidData(b) => RawData::InvalidData(b.into_static()),

     

       378
       378
       +
               }

     

       379
       379
       +
           }

     

       380
       380
       +
       }

     

       381
       381
       +
       

     

       355
       382
        
       /// Deserialize a typed value from a `Data` value

     

       356
       383
        
       ///

     

       357
       384
        
       /// Allows extracting strongly-typed structures from untyped `Data` values,

     
···

       384
       411
        
           T::deserialize(data)

     

       385
       412
        
       }

     

       386
       413
        
       

     

       414
       414
       +
       /// Deserialize a typed value from a `Data` value

     

       415
       415
       +
       ///

     

       416
       416
       +
       /// Takes ownership rather than borrows. Will allocate.

     

       417
       417
       +
       pub fn from_data_owned<'de, T>(data: Data<'_>) -> Result<T, DataDeserializerError>

     

       418
       418
       +
       where

     

       419
       419
       +
           T: serde::Deserialize<'de>,

     

       420
       420
       +
       {

     

       421
       421
       +
           T::deserialize(data.into_static())

     

       422
       422
       +
       }

     

       423
       423
       +
       

     

       424
       424
       +
       /// Deserialize a typed value from a `serde_json::Value`

     

       425
       425
       +
       ///

     

       426
       426
       +
       /// Returns an owned version, will allocate

     

       427
       427
       +
       pub fn from_json_value<'de, T>(

     

       428
       428
       +
           json: serde_json::Value,

     

       429
       429
       +
       ) -> Result<<T as IntoStatic>::Output, serde_json::Error>

     

       430
       430
       +
       where

     

       431
       431
       +
           T: serde::Deserialize<'de> + IntoStatic,

     

       432
       432
       +
       {

     

       433
       433
       +
           T::deserialize(json).map(IntoStatic::into_static)

     

       434
       434
       +
       }

     

       435
       435
       +
       

     

       387
       436
        
       /// Deserialize a typed value from a `RawData` value

     

       388
       437
        
       ///

     

       389
       438
        
       /// Allows extracting strongly-typed structures from untyped `RawData` values.

     
···

       411
       460
        
           T: serde::Deserialize<'de>,

     

       412
       461
        
       {

     

       413
       462
        
           T::deserialize(data)

     

       463
       463
       +
       }

     

       464
       464
       +
       

     

       465
       465
       +
       /// Deserialize a typed value from a `RawData` value

     

       466
       466
       +
       ///

     

       467
       467
       +
       /// Takes ownership rather than borrows. Will allocate.

     

       468
       468
       +
       pub fn from_raw_data_owned<'de, T>(data: RawData<'_>) -> Result<T, DataDeserializerError>

     

       469
       469
       +
       where

     

       470
       470
       +
           T: serde::Deserialize<'de>,

     

       471
       471
       +
       {

     

       472
       472
       +
           T::deserialize(data.into_static())

     

       414
       473
        
       }

     

       415
       474
        
       

     

       416
       475
        
       /// Serialize a typed value into a `RawData` value

     
···

       469
       528
        
       where

     

       470
       529
        
           T: serde::Serialize,

     

       471
       530
        
       {

     

       472
       472
       -
           let raw = to_raw_data(value)

     

       473
       473
       -
               .map_err(|e| convert::ConversionError::InvalidRawData {

     

       474
       474
       -
                   message: e.to_string()

     

       475
       475
       -
               })?;

     

       531
       531
       +
           let raw = to_raw_data(value).map_err(|e| convert::ConversionError::InvalidRawData {

     

       532
       532
       +
               message: e.to_string(),

     

       533
       533
       +
           })?;

     

       476
       534
        
           raw.try_into()

     

       477
       535
        
       }

+276

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

···

       843
       843
        
           }

     

       844
       844
        
       }

     

       845
       845
        
       

     

       846
       846
       +
       // Deserializer implementation for &Data<'de> - allows deserializing typed data from Data values

     

       847
       847
       +
       impl<'de> serde::Deserializer<'de> for Data<'static> {

     

       848
       848
       +
           type Error = DataDeserializerError;

     

       849
       849
       +
       

     

       850
       850
       +
           fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>

     

       851
       851
       +
           where

     

       852
       852
       +
               V: serde::de::Visitor<'de>,

     

       853
       853
       +
           {

     

       854
       854
       +
               match self {

     

       855
       855
       +
                   Data::Null => visitor.visit_unit(),

     

       856
       856
       +
                   Data::Boolean(b) => visitor.visit_bool(b),

     

       857
       857
       +
                   Data::Integer(i) => visitor.visit_i64(i),

     

       858
       858
       +
                   Data::String(s) => visitor.visit_str(s.as_str()),

     

       859
       859
       +
                   Data::Bytes(b) => visitor.visit_bytes(b.as_ref()),

     

       860
       860
       +
                   Data::CidLink(cid) => visitor.visit_str(cid.as_str()),

     

       861
       861
       +
                   Data::Array(arr) => visitor.visit_seq(OwnedArrayDeserializer::new(arr.0)),

     

       862
       862
       +
                   Data::Object(obj) => visitor.visit_map(OwnedObjectDeserializer::new(obj.0)),

     

       863
       863
       +
                   Data::Blob(blob) => {

     

       864
       864
       +
                       // Blob is a root type - deserialize as the Blob itself via map representation

     

       865
       865
       +
                       visitor.visit_map(OwnedBlobDeserializer::new(blob))

     

       866
       866
       +
                   }

     

       867
       867
       +
               }

     

       868
       868
       +
           }

     

       869
       869
       +
       

     

       870
       870
       +
           serde::forward_to_deserialize_any! {

     

       871
       871
       +
               bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string

     

       872
       872
       +
               bytes byte_buf option unit unit_struct newtype_struct seq tuple

     

       873
       873
       +
               tuple_struct map struct enum identifier ignored_any

     

       874
       874
       +
           }

     

       875
       875
       +
       }

     

       876
       876
       +
       

     

       846
       877
        
       // Deserializer implementation for &RawData<'de>

     

       847
       878
        
       impl<'de> serde::Deserializer<'de> for &'de RawData<'de> {

     

       848
       879
        
           type Error = DataDeserializerError;

     
···

       878
       909
        
           }

     

       879
       910
        
       }

     

       880
       911
        
       

     

       912
       912
       +
       // Deserializer implementation for &RawData<'de>

     

       913
       913
       +
       impl<'de> serde::Deserializer<'de> for RawData<'static> {

     

       914
       914
       +
           type Error = DataDeserializerError;

     

       915
       915
       +
       

     

       916
       916
       +
           fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>

     

       917
       917
       +
           where

     

       918
       918
       +
               V: serde::de::Visitor<'de>,

     

       919
       919
       +
           {

     

       920
       920
       +
               match self {

     

       921
       921
       +
                   RawData::Null => visitor.visit_unit(),

     

       922
       922
       +
                   RawData::Boolean(b) => visitor.visit_bool(b),

     

       923
       923
       +
                   RawData::SignedInt(i) => visitor.visit_i64(i),

     

       924
       924
       +
                   RawData::UnsignedInt(u) => visitor.visit_u64(u),

     

       925
       925
       +
                   RawData::String(cow) => match cow {

     

       926
       926
       +
                       CowStr::Borrowed(s) => visitor.visit_borrowed_str(s),

     

       927
       927
       +
                       CowStr::Owned(_) => visitor.visit_str(cow.as_ref()),

     

       928
       928
       +
                   },

     

       929
       929
       +
                   RawData::Bytes(b) => visitor.visit_bytes(b.as_ref()),

     

       930
       930
       +
                   RawData::CidLink(cid) => visitor.visit_str(cid.as_str()),

     

       931
       931
       +
                   RawData::Array(arr) => visitor.visit_seq(RawOwnedArrayDeserializer::new(arr)),

     

       932
       932
       +
                   RawData::Object(obj) => visitor.visit_map(RawOwnedObjectDeserializer::new(obj)),

     

       933
       933
       +
                   RawData::Blob(blob) => visitor.visit_map(OwnedBlobDeserializer::new(blob)),

     

       934
       934
       +
                   RawData::InvalidBlob(data) => data.deserialize_any(visitor),

     

       935
       935
       +
                   RawData::InvalidNumber(bytes) => visitor.visit_bytes(bytes.as_ref()),

     

       936
       936
       +
                   RawData::InvalidData(bytes) => visitor.visit_bytes(bytes.as_ref()),

     

       937
       937
       +
               }

     

       938
       938
       +
           }

     

       939
       939
       +
       

     

       940
       940
       +
           serde::forward_to_deserialize_any! {

     

       941
       941
       +
               bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string

     

       942
       942
       +
               bytes byte_buf option unit unit_struct newtype_struct seq tuple

     

       943
       943
       +
               tuple_struct map struct enum identifier ignored_any

     

       944
       944
       +
           }

     

       945
       945
       +
       }

     

       946
       946
       +
       

     

       881
       947
        
       /// Error type for Data/RawData deserializer

     

       882
       948
        
       #[derive(Debug, Clone, thiserror::Error)]

     

       883
       949
        
       pub enum DataDeserializerError {

     
···

       955
       1021
        
           }

     

       956
       1022
        
       }

     

       957
       1023
        
       

     

       1024
       1024
       +
       struct OwnedBlobDeserializer {

     

       1025
       1025
       +
           blob: Blob<'static>,

     

       1026
       1026
       +
           field_index: usize,

     

       1027
       1027
       +
       }

     

       1028
       1028
       +
       

     

       1029
       1029
       +
       impl OwnedBlobDeserializer {

     

       1030
       1030
       +
           fn new(blob: Blob<'_>) -> Self {

     

       1031
       1031
       +
               Self {

     

       1032
       1032
       +
                   blob: blob.into_static(),

     

       1033
       1033
       +
                   field_index: 0,

     

       1034
       1034
       +
               }

     

       1035
       1035
       +
           }

     

       1036
       1036
       +
       }

     

       1037
       1037
       +
       

     

       1038
       1038
       +
       impl<'de> serde::de::MapAccess<'de> for OwnedBlobDeserializer {

     

       1039
       1039
       +
           type Error = DataDeserializerError;

     

       1040
       1040
       +
       

     

       1041
       1041
       +
           fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>

     

       1042
       1042
       +
           where

     

       1043
       1043
       +
               K: serde::de::DeserializeSeed<'de>,

     

       1044
       1044
       +
           {

     

       1045
       1045
       +
               let key = match self.field_index {

     

       1046
       1046
       +
                   0 => "$type",

     

       1047
       1047
       +
                   1 => "ref",

     

       1048
       1048
       +
                   2 => "mimeType",

     

       1049
       1049
       +
                   3 => "size",

     

       1050
       1050
       +
                   _ => return Ok(None),

     

       1051
       1051
       +
               };

     

       1052
       1052
       +
               self.field_index += 1;

     

       1053
       1053
       +
               seed.deserialize(BorrowedStrDeserializer(key)).map(Some)

     

       1054
       1054
       +
           }

     

       1055
       1055
       +
       

     

       1056
       1056
       +
           fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>

     

       1057
       1057
       +
           where

     

       1058
       1058
       +
               V: serde::de::DeserializeSeed<'de>,

     

       1059
       1059
       +
           {

     

       1060
       1060
       +
               match self.field_index - 1 {

     

       1061
       1061
       +
                   0 => seed.deserialize(OwnedStrDeserializer("blob".into())),

     

       1062
       1062
       +
                   1 => seed.deserialize(OwnedStrDeserializer(self.blob.r#ref.to_smolstr())),

     

       1063
       1063
       +
                   2 => seed.deserialize(OwnedStrDeserializer(self.blob.mime_type.to_smolstr())),

     

       1064
       1064
       +
                   3 => seed.deserialize(I64Deserializer(self.blob.size as i64)),

     

       1065
       1065
       +
                   _ => Err(DataDeserializerError::Message(

     

       1066
       1066
       +
                       "invalid field index".to_string(),

     

       1067
       1067
       +
                   )),

     

       1068
       1068
       +
               }

     

       1069
       1069
       +
           }

     

       1070
       1070
       +
       }

     

       1071
       1071
       +
       

     

       958
       1072
        
       // Helper deserializer for borrowed strings

     

       959
       1073
        
       struct BorrowedStrDeserializer<'de>(&'de str);

     

       960
       1074
        
       

     
···

       966
       1080
        
               V: serde::de::Visitor<'de>,

     

       967
       1081
        
           {

     

       968
       1082
        
               visitor.visit_borrowed_str(self.0)

     

       1083
       1083
       +
           }

     

       1084
       1084
       +
       

     

       1085
       1085
       +
           serde::forward_to_deserialize_any! {

     

       1086
       1086
       +
               bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string

     

       1087
       1087
       +
               bytes byte_buf option unit unit_struct newtype_struct seq tuple

     

       1088
       1088
       +
               tuple_struct map struct enum identifier ignored_any

     

       1089
       1089
       +
           }

     

       1090
       1090
       +
       }

     

       1091
       1091
       +
       

     

       1092
       1092
       +
       // Helper deserializer for borrowed strings

     

       1093
       1093
       +
       struct OwnedStrDeserializer(SmolStr);

     

       1094
       1094
       +
       

     

       1095
       1095
       +
       impl<'de> serde::Deserializer<'de> for OwnedStrDeserializer {

     

       1096
       1096
       +
           type Error = DataDeserializerError;

     

       1097
       1097
       +
       

     

       1098
       1098
       +
           fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>

     

       1099
       1099
       +
           where

     

       1100
       1100
       +
               V: serde::de::Visitor<'de>,

     

       1101
       1101
       +
           {

     

       1102
       1102
       +
               visitor.visit_str(&self.0)

     

       969
       1103
        
           }

     

       970
       1104
        
       

     

       971
       1105
        
           serde::forward_to_deserialize_any! {

     
···

       1020
       1154
        
           }

     

       1021
       1155
        
       }

     

       1022
       1156
        
       

     

       1157
       1157
       +
       // SeqAccess implementation for Data::Array

     

       1158
       1158
       +
       struct OwnedArrayDeserializer {

     

       1159
       1159
       +
           iter: std::vec::IntoIter<Data<'static>>,

     

       1160
       1160
       +
       }

     

       1161
       1161
       +
       

     

       1162
       1162
       +
       impl OwnedArrayDeserializer {

     

       1163
       1163
       +
           fn new(slice: Vec<Data<'static>>) -> Self {

     

       1164
       1164
       +
               Self {

     

       1165
       1165
       +
                   iter: slice.into_iter(),

     

       1166
       1166
       +
               }

     

       1167
       1167
       +
           }

     

       1168
       1168
       +
       }

     

       1169
       1169
       +
       

     

       1170
       1170
       +
       impl<'de> serde::de::SeqAccess<'de> for OwnedArrayDeserializer {

     

       1171
       1171
       +
           type Error = DataDeserializerError;

     

       1172
       1172
       +
       

     

       1173
       1173
       +
           fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>

     

       1174
       1174
       +
           where

     

       1175
       1175
       +
               T: serde::de::DeserializeSeed<'de>,

     

       1176
       1176
       +
           {

     

       1177
       1177
       +
               match self.iter.next() {

     

       1178
       1178
       +
                   Some(value) => seed.deserialize(value).map(Some),

     

       1179
       1179
       +
                   None => Ok(None),

     

       1180
       1180
       +
               }

     

       1181
       1181
       +
           }

     

       1182
       1182
       +
       }

     

       1183
       1183
       +
       

     

       1023
       1184
        
       // MapAccess implementation for Data::Object

     

       1024
       1185
        
       struct ObjectDeserializer<'de> {

     

       1025
       1186
        
           iter: std::collections::btree_map::Iter<'de, SmolStr, Data<'de>>,

     
···

       1065
       1226
        
           }

     

       1066
       1227
        
       }

     

       1067
       1228
        
       

     

       1229
       1229
       +
       // MapAccess implementation for Data::Object

     

       1230
       1230
       +
       struct OwnedObjectDeserializer {

     

       1231
       1231
       +
           iter: std::collections::btree_map::IntoIter<SmolStr, Data<'static>>,

     

       1232
       1232
       +
           value: Option<Data<'static>>,

     

       1233
       1233
       +
       }

     

       1234
       1234
       +
       

     

       1235
       1235
       +
       impl OwnedObjectDeserializer {

     

       1236
       1236
       +
           fn new(map: BTreeMap<SmolStr, Data<'static>>) -> Self {

     

       1237
       1237
       +
               Self {

     

       1238
       1238
       +
                   iter: map.into_iter(),

     

       1239
       1239
       +
                   value: None,

     

       1240
       1240
       +
               }

     

       1241
       1241
       +
           }

     

       1242
       1242
       +
       }

     

       1243
       1243
       +
       

     

       1244
       1244
       +
       impl<'de> serde::de::MapAccess<'de> for OwnedObjectDeserializer {

     

       1245
       1245
       +
           type Error = DataDeserializerError;

     

       1246
       1246
       +
       

     

       1247
       1247
       +
           fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>

     

       1248
       1248
       +
           where

     

       1249
       1249
       +
               K: serde::de::DeserializeSeed<'de>,

     

       1250
       1250
       +
           {

     

       1251
       1251
       +
               match self.iter.next() {

     

       1252
       1252
       +
                   Some((key, value)) => {

     

       1253
       1253
       +
                       self.value = Some(value);

     

       1254
       1254
       +
                       seed.deserialize(OwnedStrDeserializer(key)).map(Some)

     

       1255
       1255
       +
                   }

     

       1256
       1256
       +
                   None => Ok(None),

     

       1257
       1257
       +
               }

     

       1258
       1258
       +
           }

     

       1259
       1259
       +
       

     

       1260
       1260
       +
           fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>

     

       1261
       1261
       +
           where

     

       1262
       1262
       +
               V: serde::de::DeserializeSeed<'de>,

     

       1263
       1263
       +
           {

     

       1264
       1264
       +
               match self.value.take() {

     

       1265
       1265
       +
                   Some(value) => seed.deserialize(value),

     

       1266
       1266
       +
                   None => Err(DataDeserializerError::Message(

     

       1267
       1267
       +
                       "value is missing".to_string(),

     

       1268
       1268
       +
                   )),

     

       1269
       1269
       +
               }

     

       1270
       1270
       +
           }

     

       1271
       1271
       +
       }

     

       1272
       1272
       +
       

     

       1068
       1273
        
       // SeqAccess implementation for RawData::Array

     

       1069
       1274
        
       struct RawArrayDeserializer<'de> {

     

       1070
       1275
        
           iter: std::slice::Iter<'de, RawData<'de>>,

     
···

       1090
       1295
        
           }

     

       1091
       1296
        
       }

     

       1092
       1297
        
       

     

       1298
       1298
       +
       // SeqAccess implementation for RawData::Array

     

       1299
       1299
       +
       struct RawOwnedArrayDeserializer<'de> {

     

       1300
       1300
       +
           iter: std::vec::IntoIter<RawData<'de>>,

     

       1301
       1301
       +
       }

     

       1302
       1302
       +
       

     

       1303
       1303
       +
       impl<'de> RawOwnedArrayDeserializer<'de> {

     

       1304
       1304
       +
           fn new(data: Vec<RawData<'de>>) -> Self {

     

       1305
       1305
       +
               Self {

     

       1306
       1306
       +
                   iter: data.into_iter(),

     

       1307
       1307
       +
               }

     

       1308
       1308
       +
           }

     

       1309
       1309
       +
       }

     

       1310
       1310
       +
       

     

       1311
       1311
       +
       impl<'de> serde::de::SeqAccess<'de> for RawOwnedArrayDeserializer<'de> {

     

       1312
       1312
       +
           type Error = DataDeserializerError;

     

       1313
       1313
       +
       

     

       1314
       1314
       +
           fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>

     

       1315
       1315
       +
           where

     

       1316
       1316
       +
               T: serde::de::DeserializeSeed<'de>,

     

       1317
       1317
       +
           {

     

       1318
       1318
       +
               match self.iter.next() {

     

       1319
       1319
       +
                   Some(value) => seed.deserialize(value.into_static()).map(Some),

     

       1320
       1320
       +
                   None => Ok(None),

     

       1321
       1321
       +
               }

     

       1322
       1322
       +
           }

     

       1323
       1323
       +
       }

     

       1324
       1324
       +
       

     

       1093
       1325
        
       // MapAccess implementation for RawData::Object

     

       1094
       1326
        
       struct RawObjectDeserializer<'de> {

     

       1095
       1327
        
           iter: std::collections::btree_map::Iter<'de, SmolStr, RawData<'de>>,

     
···

       1128
       1360
        
           {

     

       1129
       1361
        
               match self.value.take() {

     

       1130
       1362
        
                   Some(value) => seed.deserialize(value),

     

       1363
       1363
       +
                   None => Err(DataDeserializerError::Message(

     

       1364
       1364
       +
                       "value is missing".to_string(),

     

       1365
       1365
       +
                   )),

     

       1366
       1366
       +
               }

     

       1367
       1367
       +
           }

     

       1368
       1368
       +
       }

     

       1369
       1369
       +
       

     

       1370
       1370
       +
       // MapAccess implementation for RawData::Object

     

       1371
       1371
       +
       struct RawOwnedObjectDeserializer<'de> {

     

       1372
       1372
       +
           iter: std::collections::btree_map::IntoIter<SmolStr, RawData<'de>>,

     

       1373
       1373
       +
           value: Option<RawData<'de>>,

     

       1374
       1374
       +
       }

     

       1375
       1375
       +
       

     

       1376
       1376
       +
       impl<'de> RawOwnedObjectDeserializer<'de> {

     

       1377
       1377
       +
           fn new(map: BTreeMap<SmolStr, RawData<'de>>) -> Self {

     

       1378
       1378
       +
               Self {

     

       1379
       1379
       +
                   iter: map.into_iter(),

     

       1380
       1380
       +
                   value: None,

     

       1381
       1381
       +
               }

     

       1382
       1382
       +
           }

     

       1383
       1383
       +
       }

     

       1384
       1384
       +
       

     

       1385
       1385
       +
       impl<'de> serde::de::MapAccess<'de> for RawOwnedObjectDeserializer<'de> {

     

       1386
       1386
       +
           type Error = DataDeserializerError;

     

       1387
       1387
       +
       

     

       1388
       1388
       +
           fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>

     

       1389
       1389
       +
           where

     

       1390
       1390
       +
               K: serde::de::DeserializeSeed<'de>,

     

       1391
       1391
       +
           {

     

       1392
       1392
       +
               match self.iter.next() {

     

       1393
       1393
       +
                   Some((key, value)) => {

     

       1394
       1394
       +
                       self.value = Some(value);

     

       1395
       1395
       +
                       seed.deserialize(OwnedStrDeserializer(key)).map(Some)

     

       1396
       1396
       +
                   }

     

       1397
       1397
       +
                   None => Ok(None),

     

       1398
       1398
       +
               }

     

       1399
       1399
       +
           }

     

       1400
       1400
       +
       

     

       1401
       1401
       +
           fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>

     

       1402
       1402
       +
           where

     

       1403
       1403
       +
               V: serde::de::DeserializeSeed<'de>,

     

       1404
       1404
       +
           {

     

       1405
       1405
       +
               match self.value.take() {

     

       1406
       1406
       +
                   Some(value) => seed.deserialize(value.into_static()),

     

       1131
       1407
        
                   None => Err(DataDeserializerError::Message(

     

       1132
       1408
        
                       "value is missing".to_string(),

     

       1133
       1409
        
                   )),

+26

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

···

       646
       646
        
       }

     

       647
       647
        
       

     

       648
       648
        
       #[test]

     

       649
       649
       +
       fn test_json_value_deser() {

     

       650
       650
       +
           // if this compiles, it works.

     

       651
       651
       +
           let json = serde_json::json!({"name": "alice", "age": 30, "active": true});

     

       652
       652
       +
           #[derive(Debug, serde::Deserialize)]

     

       653
       653
       +
           struct TestStruct<'a> {

     

       654
       654
       +
               #[serde(borrow)]

     

       655
       655
       +
               name: CowStr<'a>,

     

       656
       656
       +
               age: i64,

     

       657
       657
       +
               active: bool,

     

       658
       658
       +
           }

     

       659
       659
       +
       

     

       660
       660
       +
           impl IntoStatic for TestStruct<'_> {

     

       661
       661
       +
               type Output = TestStruct<'static>;

     

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

     

       663
       663
       +
                   TestStruct {

     

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

     

       665
       665
       +
                       age: self.age,

     

       666
       666
       +
                       active: self.active,

     

       667
       667
       +
                   }

     

       668
       668
       +
               }

     

       669
       669
       +
           }

     

       670
       670
       +
       

     

       671
       671
       +
           let _result = from_json_value::<TestStruct>(json).expect("should be right struct");

     

       672
       672
       +
       }

     

       673
       673
       +
       

     

       674
       674
       +
       #[test]

     

       649
       675
        
       fn test_to_raw_data() {

     

       650
       676
        
           use serde::Serialize;

     

       651
       677

+1 -1

crates/jacquard-identity/Cargo.toml

···

       21
       21
        
       bon.workspace = true

     

       22
       22
        
       bytes.workspace = true

     

       23
       23
        
       jacquard-common = { version = "0.5", path = "../jacquard-common", features = ["reqwest-client"] }

     

       24
       24
       -
       jacquard-api = {  version = "0.5", path = "../jacquard-api" }

     

       24
       24
       +
       jacquard-api = {  version = "0.5", path = "../jacquard-api", default-features = false, features = ["minimal"] }

     

       25
       25
        
       percent-encoding.workspace = true

     

       26
       26
        
       reqwest.workspace = true

     

       27
       27
        
       url.workspace = true

+1 -1

crates/jacquard/Cargo.toml

···

       15
       15
        
       default = ["api_full", "dns", "loopback", "derive"]

     

       16
       16
        
       derive = ["dep:jacquard-derive"]

     

       17
       17
        
       # Minimal API bindings

     

       18
       18
       -
       api = ["jacquard-api/com_atproto", "jacquard-api/com_bad_example" ]

     

       18
       18
       +
       api = ["jacquard-api/minimal"]

     

       19
       19
        
       # Bluesky API bindings

     

       20
       20
        
       api_bluesky = ["api", "jacquard-api/bluesky" ]

     

       21
       21
        
       # Bluesky API bindings, plus a curated selection of community lexicons

+15 -10

crates/jacquard/src/client.rs

···

       24
       24
        
       pub mod vec_update;

     

       25
       25
        
       

     

       26
       26
        
       use core::future::Future;

     

       27
       27
       -
       

     

       28
       28
       -
       use jacquard_api::com_atproto::repo::create_record::CreateRecordOutput;

     

       29
       29
       -
       use jacquard_api::com_atproto::repo::delete_record::DeleteRecordOutput;

     

       30
       30
       -
       use jacquard_api::com_atproto::repo::get_record::GetRecordResponse;

     

       31
       31
       -
       use jacquard_api::com_atproto::repo::put_record::PutRecordOutput;

     

       32
       32
       -
       use jacquard_api::com_atproto::repo::upload_blob::UploadBlobResponse;

     

       33
       33
       -
       use jacquard_api::com_atproto::server::create_session::CreateSessionOutput;

     

       34
       34
       -
       use jacquard_api::com_atproto::server::refresh_session::RefreshSessionOutput;

     

       35
       27
        
       use jacquard_common::error::TransportError;

     

       36
       28
        
       pub use jacquard_common::error::{ClientError, XrpcResult};

     

       37
       29
        
       use jacquard_common::http_client::HttpClient;

     
···

       323
       315
        
           }

     

       324
       316
        
       }

     

       325
       317
        
       

     

       318
       318
       +
       #[cfg(feature = "api")]

     

       319
       319
       +
       use jacquard_api::com_atproto::{

     

       320
       320
       +
           repo::{

     

       321
       321
       +
               create_record::CreateRecordOutput, delete_record::DeleteRecordOutput,

     

       322
       322
       +
               get_record::GetRecordResponse, put_record::PutRecordOutput,

     

       323
       323
       +
               upload_blob::UploadBlobResponse,

     

       324
       324
       +
           },

     

       325
       325
       +
           server::{create_session::CreateSessionOutput, refresh_session::RefreshSessionOutput},

     

       326
       326
       +
       };

     

       327
       327
       +
       

     

       326
       328
        
       /// Extension trait providing convenience methods for common repository operations.

     

       327
       329
        
       ///

     

       328
       330
        
       /// This trait is automatically implemented for any type that implements both

     
···

       365
       367
        
       /// # Ok(())

     

       366
       368
        
       /// # }

     

       367
       369
        
       /// ```

     

       370
       370
       +
       #[cfg(feature = "api")]

     

       368
       371
        
       pub trait AgentSessionExt: AgentSession + IdentityResolver {

     

       369
       372
        
           /// Create a new record in the repository.

     

       370
       373
        
           ///

     
···

       477
       480
        
           {

     

       478
       481
        
               async move {

     

       479
       482
        
                   #[cfg(feature = "tracing")]

     

       480
       480
       -
                   let _span = tracing::debug_span!("get_record", collection = %R::nsid(), uri = %uri).entered();

     

       483
       483
       +
                   let _span =

     

       484
       484
       +
                       tracing::debug_span!("get_record", collection = %R::nsid(), uri = %uri).entered();

     

       481
       485
        
       

     

       482
       486
        
                   // Validate that URI's collection matches the expected type

     

       483
       487
        
                   if let Some(uri_collection) = uri.collection() {

     
···

       575
       579
        
           {

     

       576
       580
        
               async move {

     

       577
       581
        
                   #[cfg(feature = "tracing")]

     

       578
       578
       -
                   let _span = tracing::debug_span!("update_record", collection = %R::nsid(), uri = %uri).entered();

     

       582
       582
       +
                   let _span = tracing::debug_span!("update_record", collection = %R::nsid(), uri = %uri)

     

       583
       583
       +
                       .entered();

     

       579
       584
        
       

     

       580
       585
        
                   // Fetch the record - Response<R::Record> where R::Record::Output<'de> = R<'de>

     

       581
       586
        
                   let response = self.get_record::<R>(uri.clone()).await?;

+2 -2

justfile

···

       48
       48
        
       example NAME *ARGS:

     

       49
       49
        
           #!/usr/bin/env bash

     

       50
       50
        
           if [ -f "examples/{{NAME}}.rs" ]; then

     

       51
       51
       -
               cargo run -p jacquard --example {{NAME}} -- {{ARGS}}

     

       51
       51
       +
               cargo run -p jacquard --features=api_bluesky --example {{NAME}} -- {{ARGS}}

     

       52
       52
        
           elif cargo metadata --format-version=1 --no-deps | \

     

       53
       53
        
                jq -e '.packages[] | select(.name == "jacquard-axum") | .targets[] | select(.kind[] == "example" and .name == "{{NAME}}")' > /dev/null; then

     

       54
       54
       -
               cargo run -p jacquard-axum --example {{NAME}} --features api_bluesky -- {{ARGS}}

     

       54
       54
       +
               cargo run -p jacquard-axum --example {{NAME}}  -- {{ARGS}}

     

       55
       55
        
           else

     

       56
       56
        
               echo "Example '{{NAME}}' not found."

     

       57
       57
        
               echo ""