+62

Cargo.lock

··· 91 91 "core2", 92 92 "multibase", 93 93 "multihash", 94 94 + "serde", 95 95 + "serde_bytes", 94 96 "unsigned-varint", 95 97 ] 96 98 ··· 220 222 dependencies = [ 221 223 "cid", 222 224 "compact_str", 225 225 + "miette", 223 226 "multibase", 224 227 "multihash", 225 228 "regex", 226 229 "serde", 230 230 + "thiserror", 227 231 ] 228 232 229 233 [[package]] ··· 233 237 checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" 234 238 235 239 [[package]] 240 240 + name = "miette" 241 241 + version = "7.6.0" 242 242 + source = "registry+https://github.com/rust-lang/crates.io-index" 243 243 + checksum = "5f98efec8807c63c752b5bd61f862c165c115b0a35685bdcfd9238c7aeb592b7" 244 244 + dependencies = [ 245 245 + "cfg-if", 246 246 + "miette-derive", 247 247 + "unicode-width", 248 248 + ] 249 249 + 250 250 + [[package]] 251 251 + name = "miette-derive" 252 252 + version = "7.6.0" 253 253 + source = "registry+https://github.com/rust-lang/crates.io-index" 254 254 + checksum = "db5b29714e950dbb20d5e6f74f9dcec4edbcc1067bb7f8ed198c097b8c1a818b" 255 255 + dependencies = [ 256 256 + "proc-macro2", 257 257 + "quote", 258 258 + "syn", 259 259 + ] 260 260 + 261 261 + [[package]] 236 262 name = "multibase" 237 263 version = "0.9.1" 238 264 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 250 276 checksum = "6b430e7953c29dd6a09afc29ff0bb69c6e306329ee6794700aee27b76a1aea8d" 251 277 dependencies = [ 252 278 "core2", 279 279 + "serde", 253 280 "unsigned-varint", 254 281 ] 255 282 ··· 329 356 ] 330 357 331 358 [[package]] 359 359 + name = "serde_bytes" 360 360 + version = "0.11.17" 361 361 + source = "registry+https://github.com/rust-lang/crates.io-index" 362 362 + checksum = "8437fd221bde2d4ca316d61b90e337e9e702b3820b87d63caa9ba6c02bd06d96" 363 363 + dependencies = [ 364 364 + "serde", 365 365 + ] 366 366 + 367 367 + [[package]] 332 368 name = "serde_core" 333 369 version = "1.0.227" 334 370 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 372 408 ] 373 409 374 410 [[package]] 411 411 + name = "thiserror" 412 412 + version = "2.0.16" 413 413 + source = "registry+https://github.com/rust-lang/crates.io-index" 414 414 + checksum = "3467d614147380f2e4e374161426ff399c91084acd2363eaf549172b3d5e60c0" 415 415 + dependencies = [ 416 416 + "thiserror-impl", 417 417 + ] 418 418 + 419 419 + [[package]] 420 420 + name = "thiserror-impl" 421 421 + version = "2.0.16" 422 422 + source = "registry+https://github.com/rust-lang/crates.io-index" 423 423 + checksum = "6c5e1be1c48b9172ee610da68fd9cd2770e7a4056cb3fc98710ee6906f0c7960" 424 424 + dependencies = [ 425 425 + "proc-macro2", 426 426 + "quote", 427 427 + "syn", 428 428 + ] 429 429 + 430 430 + [[package]] 375 431 name = "unicode-ident" 376 432 version = "1.0.19" 377 433 source = "registry+https://github.com/rust-lang/crates.io-index" 378 434 checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d" 435 435 + 436 436 + [[package]] 437 437 + name = "unicode-width" 438 438 + version = "0.1.14" 439 439 + source = "registry+https://github.com/rust-lang/crates.io-index" 440 440 + checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af" 379 441 380 442 [[package]] 381 443 name = "unsigned-varint"

+3 -1

crates/jacquard-common/Cargo.toml

··· 6 6 description.workspace = true 7 7 8 8 [dependencies] 9 9 - cid = "0.11.1" 9 9 + cid = { version = "0.11.1", features = ["serde", "std"] } 10 10 compact_str = "0.9.0" 11 11 + miette = "7.6.0" 11 12 multibase = "0.9.1" 12 13 multihash = "0.19.3" 13 14 regex = "1.11.3" 14 15 serde = { version = "1.0.227", features = ["derive"] } 16 16 + thiserror = "2.0.16"

+129 -2

crates/jacquard-common/src/blob.rs

··· 1 1 - use crate::CowStr; 1 1 + use crate::{CowStr, cid::Cid}; 2 2 + use compact_str::ToCompactString; 3 3 + #[allow(unused)] 4 4 + use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error}; 5 5 + #[allow(unused)] 6 6 + use std::{ 7 7 + borrow::Cow, 8 8 + fmt, 9 9 + hash::{Hash, Hasher}, 10 10 + ops::Deref, 11 11 + str::FromStr, 12 12 + }; 13 13 + 14 14 + #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)] 15 15 + #[serde(rename_all = "camelCase")] 16 16 + pub struct Blob<'b> { 17 17 + pub r#ref: Cid<'b>, 18 18 + #[serde(borrow)] 19 19 + pub mime_type: MimeType<'b>, 20 20 + pub size: usize, 21 21 + } 22 22 + 23 23 + impl<'r> BlobRef<'r> { 24 24 + pub fn blob(&self) -> &Blob<'r> { 25 25 + match self { 26 26 + BlobRef::Blob(blob) => blob, 27 27 + } 28 28 + } 29 29 + } 30 30 + 31 31 + /// Current, typed blob reference. 32 32 + #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)] 33 33 + #[serde(tag = "$type", rename_all = "lowercase")] 34 34 + pub enum BlobRef<'r> { 35 35 + #[serde(borrow)] 36 36 + Blob(Blob<'r>), 37 37 + } 2 38 3 39 /// Wrapper for file type 4 4 - #[derive(serde::Serialize, serde::Deserialize, Debug, Clone)] 40 40 + #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)] 41 41 + #[serde(transparent)] 5 42 pub struct MimeType<'m>(pub CowStr<'m>); 43 43 + 44 44 + impl<'m> MimeType<'m> { 45 45 + /// Fallible constructor, validates, borrows from input 46 46 + pub fn new(mime_type: &'m str) -> Result<MimeType<'m>, &'static str> { 47 47 + Ok(Self(CowStr::Borrowed(mime_type))) 48 48 + } 49 49 + 50 50 + /// Fallible constructor from an existing CowStr, borrows 51 51 + pub fn from_cowstr(mime_type: CowStr<'m>) -> Result<MimeType<'m>, &'static str> { 52 52 + Ok(Self(mime_type)) 53 53 + } 54 54 + 55 55 + /// Infallible constructor 56 56 + pub fn raw(mime_type: &'m str) -> Self { 57 57 + Self(CowStr::Borrowed(mime_type)) 58 58 + } 59 59 + 60 60 + pub fn as_str(&self) -> &str { 61 61 + { 62 62 + let this = &self.0; 63 63 + this 64 64 + } 65 65 + } 66 66 + } 67 67 + 68 68 + impl FromStr for MimeType<'_> { 69 69 + type Err = &'static str; 70 70 + 71 71 + /// Has to take ownership due to the lifetime constraints of the FromStr trait. 72 72 + fn from_str(s: &str) -> Result<Self, Self::Err> { 73 73 + Self::from_cowstr(CowStr::Owned(s.to_compact_string())) 74 74 + } 75 75 + } 76 76 + 77 77 + impl<'de, 'b> Deserialize<'de> for MimeType<'b> 78 78 + where 79 79 + 'de: 'b, 80 80 + { 81 81 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 82 82 + where 83 83 + D: Deserializer<'de>, 84 84 + { 85 85 + let value = Deserialize::deserialize(deserializer)?; 86 86 + Self::new(value).map_err(D::Error::custom) 87 87 + } 88 88 + } 89 89 + 90 90 + impl fmt::Display for MimeType<'_> { 91 91 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 92 92 + f.write_str(&self.0) 93 93 + } 94 94 + } 95 95 + 96 96 + impl<'m> From<MimeType<'m>> for String { 97 97 + fn from(value: MimeType<'m>) -> Self { 98 98 + value.0.to_string() 99 99 + } 100 100 + } 101 101 + 102 102 + impl<'m> From<MimeType<'m>> for CowStr<'m> { 103 103 + fn from(value: MimeType<'m>) -> Self { 104 104 + value.0 105 105 + } 106 106 + } 107 107 + 108 108 + impl From<String> for MimeType<'static> { 109 109 + fn from(value: String) -> Self { 110 110 + Self(CowStr::Owned(value.to_compact_string())) 111 111 + } 112 112 + } 113 113 + 114 114 + impl<'m> From<CowStr<'m>> for MimeType<'m> { 115 115 + fn from(value: CowStr<'m>) -> Self { 116 116 + Self(value) 117 117 + } 118 118 + } 119 119 + 120 120 + impl AsRef<str> for MimeType<'_> { 121 121 + fn as_ref(&self) -> &str { 122 122 + self.as_str() 123 123 + } 124 124 + } 125 125 + 126 126 + impl Deref for MimeType<'_> { 127 127 + type Target = str; 128 128 + 129 129 + fn deref(&self) -> &Self::Target { 130 130 + self.as_str() 131 131 + } 132 132 + }

+183 -8

crates/jacquard-common/src/cid.rs

··· 1 1 - use serde::{Deserialize, Serialize}; 2 2 - use std::str:: 1 1 + use std::{convert::Infallible, fmt, marker::PhantomData, ops::Deref, str::FromStr}; 2 2 + 3 3 + use compact_str::ToCompactString; 4 4 + use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Visitor}; 3 5 4 6 pub use cid::Cid as IpldCid; 5 7 8 8 + use crate::CowStr; 9 9 + 6 10 /// raw 7 11 pub const ATP_CID_CODEC: u64 = 0x55; 8 12 ··· 10 14 pub const ATP_CID_HASH: u64 = 0x12; 11 15 12 16 /// base 32 13 13 - pub const ATP_CID_BASE: multibase::Base = multibase::Base::Base32; 17 17 + pub const ATP_CID_BASE: multibase::Base = multibase::Base::Base32Lower; 18 18 + 19 19 + #[derive(Debug, Clone, PartialEq, Eq, Hash)] 20 20 + /// Either the string form of a cid or the ipld form 21 21 + /// For the IPLD form we also cache the string representation for later use. 22 22 + /// 23 23 + /// Default on deserialization matches the format (if we get bytes, we try to decode) 24 24 + pub enum Cid<'c> { 25 25 + Ipld { cid: IpldCid, s: CowStr<'c> }, 26 26 + Str(CowStr<'c>), 27 27 + } 28 28 + 29 29 + #[derive(Debug, thiserror::Error, miette::Diagnostic)] 30 30 + pub enum Error { 31 31 + #[error("Invalid IPLD CID {:?}", 0)] 32 32 + Ipld(#[from] cid::Error), 33 33 + #[error("{:?}", 0)] 34 34 + Utf8(#[from] std::str::Utf8Error), 35 35 + } 36 36 + 37 37 + impl<'c> Cid<'c> { 38 38 + pub fn new(cid: &'c [u8]) -> Result<Self, Error> { 39 39 + if let Ok(cid) = IpldCid::try_from(cid.as_ref()) { 40 40 + Ok(Self::ipld(cid)) 41 41 + } else { 42 42 + let cid_str = CowStr::from_utf8(cid)?; 43 43 + Ok(Self::Str(cid_str)) 44 44 + } 45 45 + } 46 46 + pub fn ipld(cid: IpldCid) -> Self { 47 47 + let s = CowStr::Owned( 48 48 + cid.to_string_of_base(ATP_CID_BASE) 49 49 + .unwrap_or_default() 50 50 + .to_compact_string(), 51 51 + ); 52 52 + Self::Ipld { cid, s } 53 53 + } 54 54 + 55 55 + pub fn str(cid: &'c str) -> Self { 56 56 + Self::Str(CowStr::Borrowed(cid)) 57 57 + } 58 58 + 59 59 + pub fn cow_str(cid: CowStr<'c>) -> Self { 60 60 + Self::Str(cid) 61 61 + } 62 62 + 63 63 + pub fn to_ipld(&self) -> Result<IpldCid, cid::Error> { 64 64 + match self { 65 65 + Cid::Ipld { cid, s: _ } => Ok(cid.clone()), 66 66 + Cid::Str(cow_str) => IpldCid::try_from(cow_str.as_ref()), 67 67 + } 68 68 + } 69 69 + 70 70 + pub fn as_str(&self) -> &str { 71 71 + match self { 72 72 + Cid::Ipld { cid: _, s } => s.as_ref(), 73 73 + Cid::Str(cow_str) => cow_str.as_ref(), 74 74 + } 75 75 + } 76 76 + } 77 77 + 78 78 + impl std::fmt::Display for Cid<'_> { 79 79 + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 80 80 + match self { 81 81 + Cid::Ipld { cid: _, s } => f.write_str(&s), 82 82 + Cid::Str(cow_str) => f.write_str(&cow_str), 83 83 + } 84 84 + } 85 85 + } 86 86 + 87 87 + impl FromStr for Cid<'_> { 88 88 + type Err = Infallible; 89 89 + 90 90 + /// Has to take ownership due to the lifetime constraints of the FromStr trait. 91 91 + fn from_str(s: &str) -> Result<Self, Self::Err> { 92 92 + Ok(Cid::Str(CowStr::Owned(s.to_compact_string()))) 93 93 + } 94 94 + } 95 95 + 96 96 + impl Serialize for Cid<'_> { 97 97 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 98 98 + where 99 99 + S: Serializer, 100 100 + { 101 101 + match self { 102 102 + Cid::Ipld { cid, s: _ } => cid.serialize(serializer), 103 103 + Cid::Str(cow_str) => cow_str.serialize(serializer), 104 104 + } 105 105 + } 106 106 + } 107 107 + 108 108 + // TODO: take another look at this, see if we can do more borrowed and such 109 109 + impl<'de> Deserialize<'de> for Cid<'_> { 110 110 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 111 111 + where 112 112 + D: Deserializer<'de>, 113 113 + { 114 114 + struct StringOrBytes<T>(PhantomData<fn() -> T>); 115 115 + 116 116 + impl<'de, T> Visitor<'de> for StringOrBytes<T> 117 117 + where 118 118 + T: Deserialize<'de> + FromStr<Err = Infallible> + From<IpldCid>, 119 119 + { 120 120 + type Value = T; 121 121 + 122 122 + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 123 123 + formatter.write_str("either valid IPLD CID bytes or a str") 124 124 + } 125 125 + 126 126 + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> 127 127 + where 128 128 + E: serde::de::Error, 129 129 + { 130 130 + Ok(FromStr::from_str(v).unwrap()) 131 131 + } 132 132 + 133 133 + fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> 134 134 + where 135 135 + E: serde::de::Error, 136 136 + { 137 137 + let hash = cid::multihash::Multihash::from_bytes(v).map_err(|e| E::custom(e))?; 138 138 + Ok(T::from(IpldCid::new_v1(ATP_CID_CODEC, hash))) 139 139 + } 140 140 + } 141 141 + 142 142 + deserializer.deserialize_any(StringOrBytes(PhantomData)) 143 143 + } 144 144 + } 145 145 + 146 146 + impl From<Cid<'_>> for String { 147 147 + fn from(value: Cid) -> Self { 148 148 + let cow_str = match value { 149 149 + Cid::Ipld { cid: _, s } => s, 150 150 + Cid::Str(cow_str) => cow_str, 151 151 + }; 152 152 + cow_str.to_string() 153 153 + } 154 154 + } 155 155 + 156 156 + impl<'d> From<Cid<'d>> for CowStr<'d> { 157 157 + fn from(value: Cid<'d>) -> Self { 158 158 + match value { 159 159 + Cid::Ipld { cid: _, s } => s, 160 160 + Cid::Str(cow_str) => cow_str, 161 161 + } 162 162 + } 163 163 + } 164 164 + 165 165 + impl From<String> for Cid<'_> { 166 166 + fn from(value: String) -> Self { 167 167 + Cid::Str(CowStr::Owned(value.to_compact_string())) 168 168 + } 169 169 + } 170 170 + 171 171 + impl<'d> From<CowStr<'d>> for Cid<'d> { 172 172 + fn from(value: CowStr<'d>) -> Self { 173 173 + Cid::Str(value) 174 174 + } 175 175 + } 176 176 + 177 177 + impl From<IpldCid> for Cid<'_> { 178 178 + fn from(value: IpldCid) -> Self { 179 179 + Cid::ipld(value) 180 180 + } 181 181 + } 182 182 + 183 183 + impl AsRef<str> for Cid<'_> { 184 184 + fn as_ref(&self) -> &str { 185 185 + self.as_str() 186 186 + } 187 187 + } 188 188 + 189 189 + impl Deref for Cid<'_> { 190 190 + type Target = str; 14 191 15 15 - #[derive(Serialize, Deserialize, Debug, Clone)] 16 16 - #[serde(untagged)] 17 17 - pub enum Cid { 18 18 - Cid(IpldCid), 19 19 - CidStr(CowStr<'static>), 192 192 + fn deref(&self) -> &Self::Target { 193 193 + self.as_str() 194 194 + } 20 195 }

+52 -3

crates/jacquard-common/src/cowstr.rs

··· 1 1 + use compact_str::CompactString; 2 2 + use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error}; 1 3 use std::{ 2 4 borrow::Cow, 3 5 fmt, 4 6 hash::{Hash, Hasher}, 5 7 ops::Deref, 8 8 + str::FromStr, 6 9 }; 7 7 - 8 8 - use compact_str::CompactString; 9 10 10 11 use crate::IntoStatic; 11 12 ··· 208 209 } 209 210 } 210 211 211 211 - use serde::{Deserialize, Serialize}; 212 212 + /// Common trait implementations for Lexicon string formats that are newtype wrappers 213 213 + /// around `String`. 214 214 + macro_rules! string_newtype { 215 215 + ($name:ident) => { 216 216 + impl FromStr for $name<'_> { 217 217 + type Err = &'static str; 218 218 + 219 219 + fn from_str(s: &str) -> Result<Self, Self::Err> { 220 220 + Self::new(s) 221 221 + } 222 222 + } 223 223 + 224 224 + impl<'de> Deserialize<'de> for $name<'de> { 225 225 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 226 226 + where 227 227 + D: Deserializer<'de>, 228 228 + { 229 229 + let value = Deserialize::deserialize(deserializer)?; 230 230 + Self::new(value).map_err(D::Error::custom) 231 231 + } 232 232 + } 233 233 + 234 234 + impl From<$name<'_>> for String { 235 235 + fn from(value: $name) -> Self { 236 236 + value.0.to_string() 237 237 + } 238 238 + } 239 239 + 240 240 + impl From<$name> for CowStr<'s> { 241 241 + fn from(value: $name) -> Self { 242 242 + value.0 243 243 + } 244 244 + } 245 245 + 246 246 + impl AsRef<str> for $name<'_> { 247 247 + fn as_ref(&self) -> &str { 248 248 + self.as_str() 249 249 + } 250 250 + } 251 251 + 252 252 + impl Deref for $name<'_> { 253 253 + type Target = str; 254 254 + 255 255 + fn deref(&self) -> &Self::Target { 256 256 + self.as_str() 257 257 + } 258 258 + } 259 259 + }; 260 260 + } 212 261 213 262 impl Serialize for CowStr<'_> { 214 263 #[inline]

+141 -1

crates/jacquard-common/src/did.rs

··· 1 1 - use crate::CowStr; 1 1 + use std::fmt; 2 2 + use std::sync::LazyLock; 3 3 + use std::{ops::Deref, str::FromStr}; 4 4 + 5 5 + use compact_str::ToCompactString; 6 6 + use serde::{Deserialize, Deserializer, Serialize, de::Error}; 2 7 8 8 + use crate::{CowStr, IntoStatic}; 9 9 + use regex::Regex; 10 10 + 11 11 + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Hash)] 12 12 + #[serde(transparent)] 3 13 pub struct Did<'d>(CowStr<'d>); 14 14 + 15 15 + pub static DID_REGEX: LazyLock<Regex> = 16 16 + LazyLock::new(|| Regex::new(r"^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$").unwrap()); 17 17 + 18 18 + impl<'d> Did<'d> { 19 19 + /// Fallible constructor, validates, borrows from input 20 20 + pub fn new(did: &'d str) -> Result<Self, &'static str> { 21 21 + if did.len() > 2048 { 22 22 + Err("DID too long") 23 23 + } else if !DID_REGEX.is_match(did) { 24 24 + Err("Invalid DID") 25 25 + } else { 26 26 + Ok(Self(CowStr::Borrowed(did))) 27 27 + } 28 28 + } 29 29 + 30 30 + /// Fallible constructor from an existing CowStr, clones and takes 31 31 + pub fn from_cowstr(did: CowStr<'d>) -> Result<Did<'d>, &'static str> { 32 32 + if did.len() > 2048 { 33 33 + Err("DID too long") 34 34 + } else if !DID_REGEX.is_match(&did) { 35 35 + Err("Invalid DID") 36 36 + } else { 37 37 + Ok(Self(did.into_static())) 38 38 + } 39 39 + } 40 40 + 41 41 + /// Infallible constructor for when you *know* the string is a valid DID. 42 42 + /// Will panic on invalid DIDs. If you're manually decoding atproto records 43 43 + /// or API values you know are valid (rather than using serde), this is the one to use. 44 44 + /// The From<String> and From<CowStr> impls use the same logic. 45 45 + pub fn raw(did: &'d str) -> Self { 46 46 + if did.len() > 2048 { 47 47 + panic!("DID too long") 48 48 + } else if !DID_REGEX.is_match(did) { 49 49 + panic!("Invalid DID") 50 50 + } else { 51 51 + Self(CowStr::Borrowed(did)) 52 52 + } 53 53 + } 54 54 + 55 55 + /// Infallible constructor for when you *know* the string is a valid DID. 56 56 + /// Marked unsafe because responsibility for upholding the invariant is on the developer. 57 57 + pub unsafe fn unchecked(did: &'d str) -> Self { 58 58 + Self(CowStr::Borrowed(did)) 59 59 + } 60 60 + 61 61 + pub fn as_str(&self) -> &str { 62 62 + { 63 63 + let this = &self.0; 64 64 + this 65 65 + } 66 66 + } 67 67 + } 68 68 + 69 69 + impl FromStr for Did<'_> { 70 70 + type Err = &'static str; 71 71 + 72 72 + /// Has to take ownership due to the lifetime constraints of the FromStr trait. 73 73 + /// Prefer `Did::new()` or `Did::raw` if you want to borrow. 74 74 + fn from_str(s: &str) -> Result<Self, Self::Err> { 75 75 + Self::from_cowstr(CowStr::Owned(s.to_compact_string())) 76 76 + } 77 77 + } 78 78 + 79 79 + impl<'de> Deserialize<'de> for Did<'de> { 80 80 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 81 81 + where 82 82 + D: Deserializer<'de>, 83 83 + { 84 84 + let value = Deserialize::deserialize(deserializer)?; 85 85 + Self::new(value).map_err(D::Error::custom) 86 86 + } 87 87 + } 88 88 + 89 89 + impl fmt::Display for Did<'_> { 90 90 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 91 91 + f.write_str(&self.0) 92 92 + } 93 93 + } 94 94 + 95 95 + impl<'d> From<Did<'d>> for String { 96 96 + fn from(value: Did<'d>) -> Self { 97 97 + value.0.to_string() 98 98 + } 99 99 + } 100 100 + 101 101 + impl<'d> From<Did<'d>> for CowStr<'d> { 102 102 + fn from(value: Did<'d>) -> Self { 103 103 + value.0 104 104 + } 105 105 + } 106 106 + 107 107 + impl From<String> for Did<'static> { 108 108 + fn from(value: String) -> Self { 109 109 + if value.len() > 2048 { 110 110 + panic!("DID too long") 111 111 + } else if !DID_REGEX.is_match(&value) { 112 112 + panic!("Invalid DID") 113 113 + } else { 114 114 + Self(CowStr::Owned(value.to_compact_string())) 115 115 + } 116 116 + } 117 117 + } 118 118 + 119 119 + impl<'d> From<CowStr<'d>> for Did<'d> { 120 120 + fn from(value: CowStr<'d>) -> Self { 121 121 + if value.len() > 2048 { 122 122 + panic!("DID too long") 123 123 + } else if !DID_REGEX.is_match(&value) { 124 124 + panic!("Invalid DID") 125 125 + } else { 126 126 + Self(value) 127 127 + } 128 128 + } 129 129 + } 130 130 + 131 131 + impl AsRef<str> for Did<'_> { 132 132 + fn as_ref(&self) -> &str { 133 133 + self.as_str() 134 134 + } 135 135 + } 136 136 + 137 137 + impl Deref for Did<'_> { 138 138 + type Target = str; 139 139 + 140 140 + fn deref(&self) -> &Self::Target { 141 141 + self.as_str() 142 142 + } 143 143 + }

+6

crates/jacquard-common/src/lib.rs

··· 1 1 pub mod aturi; 2 2 + #[macro_use] 2 3 pub mod cowstr; 4 4 + #[macro_use] 5 5 + pub mod blob; 6 6 + pub mod cid; 7 7 + 3 8 pub mod did; 4 9 pub mod handle; 10 10 + #[macro_use] 5 11 pub mod into_static; 6 12 pub mod link; 7 13 pub mod nsid;