+23 -27

Cargo.lock

··· 83 83 checksum = "4cbbc9d0964165b47557570cce6c952866c2678457aca742aafc9fb771d30270" 84 84 85 85 [[package]] 86 86 - name = "bumpalo" 87 87 - version = "3.19.0" 86 86 + name = "borsh" 87 87 + version = "1.5.7" 88 88 source = "registry+https://github.com/rust-lang/crates.io-index" 89 89 - checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" 89 89 + checksum = "ad8646f98db542e39fc66e68a20b2144f6a732636df7c2354e74645faaa433ce" 90 90 + dependencies = [ 91 91 + "cfg_aliases", 92 92 + ] 90 93 91 94 [[package]] 92 92 - name = "castaway" 93 93 - version = "0.2.4" 95 95 + name = "bumpalo" 96 96 + version = "3.19.0" 94 97 source = "registry+https://github.com/rust-lang/crates.io-index" 95 95 - checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a" 96 96 - dependencies = [ 97 97 - "rustversion", 98 98 - ] 98 98 + checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" 99 99 100 100 [[package]] 101 101 name = "cc" ··· 112 112 version = "1.0.3" 113 113 source = "registry+https://github.com/rust-lang/crates.io-index" 114 114 checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9" 115 115 + 116 116 + [[package]] 117 117 + name = "cfg_aliases" 118 118 + version = "0.2.1" 119 119 + source = "registry+https://github.com/rust-lang/crates.io-index" 120 120 + checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" 115 121 116 122 [[package]] 117 123 name = "chrono" ··· 187 193 checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" 188 194 189 195 [[package]] 190 190 - name = "compact_str" 191 191 - version = "0.9.0" 192 192 - source = "registry+https://github.com/rust-lang/crates.io-index" 193 193 - checksum = "3fdb1325a1cece981e8a296ab8f0f9b63ae357bd0784a9faaf548cc7b480707a" 194 194 - dependencies = [ 195 195 - "castaway", 196 196 - "cfg-if", 197 197 - "itoa", 198 198 - "rustversion", 199 199 - "ryu", 200 200 - "static_assertions", 201 201 - ] 202 202 - 203 203 - [[package]] 204 196 name = "core-foundation-sys" 205 197 version = "0.8.7" 206 198 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 334 326 dependencies = [ 335 327 "chrono", 336 328 "cid", 337 337 - "compact_str", 338 329 "miette", 339 330 "multibase", 340 331 "multihash", ··· 342 333 "serde", 343 334 "serde_html_form", 344 335 "serde_json", 336 336 + "smol_str", 345 337 "thiserror", 346 338 ] 347 339 ··· 575 567 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" 576 568 577 569 [[package]] 578 578 - name = "static_assertions" 579 579 - version = "1.1.0" 570 570 + name = "smol_str" 571 571 + version = "0.3.2" 580 572 source = "registry+https://github.com/rust-lang/crates.io-index" 581 581 - checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" 573 573 + checksum = "9676b89cd56310a87b93dec47b11af744f34d5fc9f367b829474eec0a891350d" 574 574 + dependencies = [ 575 575 + "borsh", 576 576 + "serde", 577 577 + ] 582 578 583 579 [[package]] 584 580 name = "strsim"

+7

Cargo.toml

··· 7 7 edition = "2024" 8 8 version = "0.1.0" 9 9 authors = ["Orual <orual@nonbinary.computer>"] 10 10 + repository = "https://tangled.org/@nonbinary.computer/jacquard" 11 11 + keywords = ["atproto", "at protocol", "bluesky", "api", "client"] 12 12 + categories = ["api-bindings", "web-programming::http-client"] 13 13 + readme = "README.md" 14 14 + documentation = "https://docs.rs/jacquard" 15 15 + exclude = [".direnv"] 16 16 + 10 17 11 18 description = "A simple Rust project using Nix" 12 19

+26

README.md

··· 29 29 ``` 30 30 31 31 There's also a [`justfile`](https://just.systems/) for Makefile-esque commands to be run inside of the devShell, and you can generally `cargo ...` or `just ...` whatever just fine if you don't want to use Nix and have the prerequisites installed. 32 32 + 33 33 + 34 34 + 35 35 + ### String types 36 36 + Something of a note to self. Developing a pattern with the string types (may macro-ify at some point). Each needs: 37 37 + - new(): constructing from a string slice with the right lifetime that borrows 38 38 + - new_owned(): constructing from an impl AsRef<str>, taking ownership 39 39 + - new_static(): construction from a &'static str, using SmolStr's/CowStr's new_static() constructor to not allocate 40 40 + - raw(): same as new() but panics instead of erroring 41 41 + - unchecked(): same as new() but doesn't validate. marked unsafe. 42 42 + - as_str(): does what it says on the tin 43 43 + #### Traits: 44 44 + - Serialize + Deserialize (custom impl for latter, sometimes for former) 45 45 + - FromStr 46 46 + - Display 47 47 + - Debug, PartialEq, Eq, Hash, Clone 48 48 + - From<T> for String, CowStr, SmolStr, 49 49 + - From<String>, From<CowStr>, From<SmolStr>, or TryFrom if likely enough to fail in practice to make panics common 50 50 + - AsRef<str> 51 51 + - Deref with Target = str (usually) 52 52 + 53 53 + Use `#[repr(transparent)]` as much as possible. Main exception is at-uri type and components. 54 54 + Use SmolStr directly as the inner type if most or all of the instances will be under 24 bytes, save lifetime headaches. 55 55 + Use CowStr for longer to allow for borrowing from input. 56 56 + 57 57 + TODO: impl IntoStatic trait to take ownership of string types

+1 -1

crates/jacquard-common/Cargo.toml

··· 8 8 [dependencies] 9 9 chrono = "0.4.42" 10 10 cid = { version = "0.11.1", features = ["serde", "std"] } 11 11 - compact_str = "0.9.0" 12 11 miette = "7.6.0" 13 12 multibase = "0.9.1" 14 13 multihash = "0.19.3" ··· 16 15 serde = { version = "1.0.227", features = ["derive"] } 17 16 serde_html_form = "0.2.8" 18 17 serde_json = "1.0.145" 18 18 + smol_str = { version = "0.3.2", features = ["serde"] } 19 19 thiserror = "2.0.16"

+13 -9

crates/jacquard-common/src/cowstr.rs

··· 1 1 - use compact_str::CompactString; 2 1 use serde::{Deserialize, Serialize}; 2 2 + use smol_str::SmolStr; 3 3 use std::{ 4 4 borrow::Cow, 5 5 fmt, ··· 10 10 use crate::IntoStatic; 11 11 12 12 /// Shamelessly copied from https://github.com/bearcove/merde 13 13 - /// A copy-on-write string type that uses [`CompactString`] for 13 13 + /// A copy-on-write immutable string type that uses [`SmolStr`] for 14 14 /// the "owned" variant. 15 15 /// 16 16 /// The standard [`Cow`] type cannot be used, since 17 17 - /// `<str as ToOwned>::Owned` is `String`, and not `CompactString`. 17 17 + /// `<str as ToOwned>::Owned` is `String`, and not `SmolStr`. 18 18 #[derive(Clone)] 19 19 pub enum CowStr<'s> { 20 20 Borrowed(&'s str), 21 21 - Owned(CompactString), 21 21 + Owned(SmolStr), 22 22 } 23 23 24 24 impl CowStr<'static> { ··· 26 26 /// if the `compact_str` feature is disabled, or if the string is longer 27 27 /// than `MAX_INLINE_SIZE`. 28 28 pub fn copy_from_str(s: &str) -> Self { 29 29 - Self::Owned(CompactString::from(s)) 29 29 + Self::Owned(SmolStr::from(s)) 30 30 + } 31 31 + 32 32 + pub fn new_static(s: &'static str) -> Self { 33 33 + Self::Owned(SmolStr::new_static(s)) 30 34 } 31 35 } 32 36 ··· 38 42 39 43 #[inline] 40 44 pub fn from_utf8_owned(s: Vec<u8>) -> Result<Self, std::str::Utf8Error> { 41 41 - Ok(Self::Owned(CompactString::from_utf8(s)?)) 45 45 + Ok(Self::Owned(SmolStr::new(std::str::from_utf8(&s)?))) 42 46 } 43 47 44 48 #[inline] 45 49 pub fn from_utf8_lossy(s: &'s [u8]) -> Self { 46 46 - Self::Owned(CompactString::from_utf8_lossy(s)) 50 50 + Self::Owned(String::from_utf8_lossy(&s).into()) 47 51 } 48 52 49 53 /// # Safety ··· 51 55 /// This function is unsafe because it does not check that the bytes are valid UTF-8. 52 56 #[inline] 53 57 pub unsafe fn from_utf8_unchecked(s: &'s [u8]) -> Self { 54 54 - unsafe { Self::Owned(CompactString::from_utf8_unchecked(s)) } 58 58 + unsafe { Self::Owned(SmolStr::new(std::str::from_utf8_unchecked(s))) } 55 59 } 56 60 } 57 61 ··· 133 137 fn from(s: CowStr<'_>) -> Self { 134 138 match s { 135 139 CowStr::Borrowed(s) => s.into(), 136 136 - CowStr::Owned(s) => s.into(), 140 140 + CowStr::Owned(s) => String::from(s).into_boxed_str(), 137 141 } 138 142 } 139 143 }

+8

crates/jacquard-common/src/types.rs

··· 1 1 pub mod aturi; 2 2 pub mod blob; 3 3 pub mod cid; 4 4 + pub mod collection; 4 5 pub mod datetime; 5 6 pub mod did; 6 7 pub mod handle; ··· 8 9 pub mod integer; 9 10 pub mod link; 10 11 pub mod nsid; 12 12 + pub mod recordkey; 11 13 pub mod tid; 14 14 + 15 15 + /// Trait for a constant string literal type 16 16 + pub trait Literal: Clone + Copy + PartialEq + Eq + Send + Sync + 'static { 17 17 + /// The string literal 18 18 + const LITERAL: &'static str; 19 19 + }

+200 -73

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

··· 1 1 + use crate::CowStr; 2 2 + use crate::types::ident::AtIdentifier; 3 3 + use crate::types::nsid::Nsid; 4 4 + use crate::types::recordkey::{RecordKey, Rkey}; 5 5 + use regex::Regex; 6 6 + use serde::Serializer; 7 7 + use serde::{Deserialize, Deserializer, Serialize, de::Error}; 8 8 + use smol_str::ToSmolStr; 1 9 use std::fmt; 2 10 use std::sync::LazyLock; 3 11 use std::{ops::Deref, str::FromStr}; 4 12 5 5 - use compact_str::ToCompactString; 6 6 - use serde::{Deserialize, Deserializer, Serialize, de::Error}; 13 13 + /// at:// URI type 14 14 + /// 15 15 + /// based on the regex here: https://github.com/bluesky-social/atproto/blob/main/packages/syntax/src/aturi_validation.ts 16 16 + /// 17 17 + /// Doesn't support the query segment, but then neither does the Typescript SDK 18 18 + /// 19 19 + /// TODO: support IntoStatic on string types. For composites like this where all borrow from (present) input, 20 20 + /// perhaps use some careful unsafe to launder the lifetimes. 21 21 + #[derive(Clone, PartialEq, Eq, Hash, Debug)] 22 22 + pub struct AtUri<'u> { 23 23 + uri: CowStr<'u>, 24 24 + pub authority: AtIdentifier<'u>, 25 25 + pub path: Option<UriPath<'u>>, 26 26 + pub fragment: Option<CowStr<'u>>, 27 27 + } 7 28 8 8 - use crate::{CowStr, IntoStatic}; 9 9 - use regex::Regex; 29 29 + /// at:// URI path component (current subset) 30 30 + #[derive(Clone, PartialEq, Eq, Hash, Debug)] 31 31 + pub struct UriPath<'u> { 32 32 + pub collection: Nsid<'u>, 33 33 + pub rkey: Option<RecordKey<Rkey<'u>>>, 34 34 + } 10 35 11 11 - #[derive(Debug, Clone, PartialEq, Eq, Serialize, Hash)] 12 12 - #[serde(transparent)] 13 13 - pub struct AtUri<'a>(CowStr<'a>); 36 36 + pub type UriPathBuf = UriPath<'static>; 14 37 15 15 - pub static AT_URI_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^$").unwrap()); 38 38 + pub static ATURI_REGEX: LazyLock<Regex> = LazyLock::new(|| { 39 39 + Regex::new(r##"^at://(?<authority>[a-zA-Z0-9._:%-]+)(/(?<collection>[a-zA-Z0-9-.]+)(/(?<rkey>[a-zA-Z0-9._~:@!$&%')(*+,;=-]+))?)?(#(?<fragment>/[a-zA-Z0-9._~:@!$&%')(*+,;=-[]/\]*))?$"##).unwrap() 40 40 + }); 16 41 17 17 - impl<'a> AtUri<'a> { 42 42 + impl<'u> AtUri<'u> { 18 43 /// Fallible constructor, validates, borrows from input 19 19 - pub fn new(uri: &'a str) -> Result<Self, &'static str> { 20 20 - if uri.len() > 2048 { 21 21 - Err("AT_URI too long") 22 22 - } else if !AT_URI_REGEX.is_match(uri) { 23 23 - Err("Invalid AT_URI") 44 44 + pub fn new(uri: &'u str) -> Result<Self, &'static str> { 45 45 + if let Some(parts) = ATURI_REGEX.captures(uri) { 46 46 + if let Some(authority) = parts.name("authority") { 47 47 + let authority = AtIdentifier::new(authority.as_str())?; 48 48 + let path = if let Some(collection) = parts.name("collection") { 49 49 + let collection = Nsid::new(collection.as_str())?; 50 50 + let rkey = if let Some(rkey) = parts.name("rkey") { 51 51 + let rkey = RecordKey::from(Rkey::new(rkey.as_str())?); 52 52 + Some(rkey) 53 53 + } else { 54 54 + None 55 55 + }; 56 56 + Some(UriPath { collection, rkey }) 57 57 + } else { 58 58 + None 59 59 + }; 60 60 + let fragment = parts.name("fragment").map(|fragment| { 61 61 + let fragment = CowStr::Borrowed(fragment.as_str()); 62 62 + fragment 63 63 + }); 64 64 + Ok(AtUri { 65 65 + uri: CowStr::Borrowed(uri), 66 66 + authority, 67 67 + path, 68 68 + fragment, 69 69 + }) 70 70 + } else { 71 71 + Err("at:// URI missing authority") 72 72 + } 24 73 } else { 25 25 - Ok(Self(CowStr::Borrowed(uri))) 74 74 + Err("Invalid at:// URI via regex") 26 75 } 27 76 } 28 77 29 29 - /// Fallible constructor from an existing CowStr, clones and takes 30 30 - pub fn from_cowstr(uri: CowStr<'a>) -> Result<AtUri<'a>, &'static str> { 31 31 - if uri.len() > 2048 { 32 32 - Err("AT_URI too long") 33 33 - } else if !AT_URI_REGEX.is_match(&uri) { 34 34 - Err("Invalid AT_URI") 78 78 + pub fn new_owned(uri: impl AsRef<str>) -> Result<Self, &'static str> { 79 79 + let uri = uri.as_ref(); 80 80 + if let Some(parts) = ATURI_REGEX.captures(uri) { 81 81 + if let Some(authority) = parts.name("authority") { 82 82 + let authority = AtIdentifier::new_owned(authority.as_str())?; 83 83 + let path = if let Some(collection) = parts.name("collection") { 84 84 + let collection = Nsid::new_owned(collection.as_str())?; 85 85 + let rkey = if let Some(rkey) = parts.name("rkey") { 86 86 + let rkey = RecordKey::from(Rkey::new_owned(rkey.as_str())?); 87 87 + Some(rkey) 88 88 + } else { 89 89 + None 90 90 + }; 91 91 + Some(UriPath { collection, rkey }) 92 92 + } else { 93 93 + None 94 94 + }; 95 95 + let fragment = parts.name("fragment").map(|fragment| { 96 96 + let fragment = CowStr::Owned(fragment.as_str().to_smolstr()); 97 97 + fragment 98 98 + }); 99 99 + Ok(AtUri { 100 100 + uri: CowStr::Owned(uri.to_smolstr()), 101 101 + authority, 102 102 + path, 103 103 + fragment, 104 104 + }) 105 105 + } else { 106 106 + Err("at:// URI missing authority") 107 107 + } 35 108 } else { 36 36 - Ok(Self(uri.into_static())) 109 109 + Err("Invalid at:// URI via regex") 37 110 } 38 111 } 39 112 40 40 - /// Infallible constructor for when you *know* the string slice is a valid at:// uri. 41 41 - /// Will panic on invalid URIs. If you're manually decoding atproto records 42 42 - /// or API values you know are valid (rather than using serde), this is the one to use. 43 43 - /// The From<String> and From<CowStr> impls use the same logic. 44 44 - pub fn raw(uri: &'a str) -> Self { 45 45 - if uri.len() > 2048 { 46 46 - panic!("AT_URI too long") 47 47 - } else if !AT_URI_REGEX.is_match(uri) { 48 48 - panic!("Invalid AT_URI") 113 113 + pub fn new_static(uri: &'static str) -> Result<AtUri<'static>, &'static str> { 114 114 + let uri = uri.as_ref(); 115 115 + if let Some(parts) = ATURI_REGEX.captures(uri) { 116 116 + if let Some(authority) = parts.name("authority") { 117 117 + let authority = AtIdentifier::new_static(authority.as_str())?; 118 118 + let path = if let Some(collection) = parts.name("collection") { 119 119 + let collection = Nsid::new_static(collection.as_str())?; 120 120 + let rkey = if let Some(rkey) = parts.name("rkey") { 121 121 + let rkey = RecordKey::from(Rkey::new_static(rkey.as_str())?); 122 122 + Some(rkey) 123 123 + } else { 124 124 + None 125 125 + }; 126 126 + Some(UriPath { collection, rkey }) 127 127 + } else { 128 128 + None 129 129 + }; 130 130 + let fragment = parts.name("fragment").map(|fragment| { 131 131 + let fragment = CowStr::new_static(fragment.as_str()); 132 132 + fragment 133 133 + }); 134 134 + Ok(AtUri { 135 135 + uri: CowStr::new_static(uri), 136 136 + authority, 137 137 + path, 138 138 + fragment, 139 139 + }) 140 140 + } else { 141 141 + Err("at:// URI missing authority") 142 142 + } 49 143 } else { 50 50 - Self(CowStr::Borrowed(uri)) 144 144 + Err("Invalid at:// URI via regex") 51 145 } 52 146 } 53 147 54 54 - /// Infallible constructor for when you *know* the string is a valid AT_URI. 55 55 - /// Marked unsafe because responsibility for upholding the invariant is on the developer. 56 56 - pub unsafe fn unchecked(uri: &'a str) -> Self { 57 57 - Self(CowStr::Borrowed(uri)) 148 148 + pub unsafe fn unchecked(uri: &'u str) -> Self { 149 149 + if let Some(parts) = ATURI_REGEX.captures(uri) { 150 150 + if let Some(authority) = parts.name("authority") { 151 151 + let authority = unsafe { AtIdentifier::unchecked(authority.as_str()) }; 152 152 + let path = if let Some(collection) = parts.name("collection") { 153 153 + let collection = unsafe { Nsid::unchecked(collection.as_str()) }; 154 154 + let rkey = if let Some(rkey) = parts.name("rkey") { 155 155 + let rkey = RecordKey::from(unsafe { Rkey::unchecked(rkey.as_str()) }); 156 156 + Some(rkey) 157 157 + } else { 158 158 + None 159 159 + }; 160 160 + Some(UriPath { collection, rkey }) 161 161 + } else { 162 162 + None 163 163 + }; 164 164 + let fragment = parts.name("fragment").map(|fragment| { 165 165 + let fragment = CowStr::Borrowed(fragment.as_str()); 166 166 + fragment 167 167 + }); 168 168 + AtUri { 169 169 + uri: CowStr::Borrowed(uri), 170 170 + authority, 171 171 + path, 172 172 + fragment, 173 173 + } 174 174 + } else { 175 175 + Self { 176 176 + uri: CowStr::Borrowed(uri), 177 177 + authority: unsafe { AtIdentifier::unchecked(uri) }, 178 178 + path: None, 179 179 + fragment: None, 180 180 + } 181 181 + } 182 182 + } else { 183 183 + Self { 184 184 + uri: CowStr::Borrowed(uri), 185 185 + authority: unsafe { AtIdentifier::unchecked(uri) }, 186 186 + path: None, 187 187 + fragment: None, 188 188 + } 189 189 + } 58 190 } 59 191 60 192 pub fn as_str(&self) -> &str { 61 193 { 62 62 - let this = &self.0; 194 194 + let this = &self.uri; 63 195 this 64 196 } 65 197 } ··· 69 201 type Err = &'static str; 70 202 71 203 /// Has to take ownership due to the lifetime constraints of the FromStr trait. 72 72 - /// Prefer `AtUri::new()` or `AtUri::raw` if you want to borrow. 204 204 + /// Prefer `AtUri::new()` or `AtUri::raw()` if you want to borrow. 73 205 fn from_str(s: &str) -> Result<Self, Self::Err> { 74 74 - Self::from_cowstr(CowStr::Owned(s.to_compact_string())) 206 206 + Self::new_owned(s) 75 207 } 76 208 } 77 209 78 78 - impl<'ae> Deserialize<'ae> for AtUri<'ae> { 210 210 + impl<'de> Deserialize<'de> for AtUri<'de> { 79 211 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 80 212 where 81 81 - D: Deserializer<'ae>, 213 213 + D: Deserializer<'de>, 82 214 { 83 215 let value = Deserialize::deserialize(deserializer)?; 84 216 Self::new(value).map_err(D::Error::custom) 85 217 } 86 218 } 87 219 88 88 - impl fmt::Display for AtUri<'_> { 89 89 - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 90 90 - f.write_str(&self.0) 220 220 + impl Serialize for AtUri<'_> { 221 221 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 222 222 + where 223 223 + S: Serializer, 224 224 + { 225 225 + serializer.serialize_str(&self.uri) 91 226 } 92 227 } 93 228 94 94 - impl<'a> From<AtUri<'a>> for String { 95 95 - fn from(value: AtUri<'a>) -> Self { 96 96 - value.0.to_string() 229 229 + impl fmt::Display for AtUri<'_> { 230 230 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 231 231 + f.write_str(&self.uri) 97 232 } 98 233 } 99 234 100 100 - impl<'s> From<&'s AtUri<'_>> for &'s str { 101 101 - fn from(value: &'s AtUri<'_>) -> Self { 102 102 - value.0.as_ref() 235 235 + impl<'d> From<AtUri<'d>> for String { 236 236 + fn from(value: AtUri<'d>) -> Self { 237 237 + value.uri.to_string() 103 238 } 104 239 } 105 240 106 106 - impl<'a> From<AtUri<'a>> for CowStr<'a> { 107 107 - fn from(value: AtUri<'a>) -> Self { 108 108 - value.0 241 241 + impl<'d> From<AtUri<'d>> for CowStr<'d> { 242 242 + fn from(value: AtUri<'d>) -> Self { 243 243 + value.uri 109 244 } 110 245 } 111 246 112 112 - impl From<String> for AtUri<'static> { 113 113 - fn from(value: String) -> Self { 114 114 - if value.len() > 2048 { 115 115 - panic!("AT_URI too long") 116 116 - } else if !AT_URI_REGEX.is_match(&value) { 117 117 - panic!("Invalid AT_URI") 118 118 - } else { 119 119 - Self(CowStr::Owned(value.to_compact_string())) 120 120 - } 247 247 + impl TryFrom<String> for AtUri<'static> { 248 248 + type Error = &'static str; 249 249 + 250 250 + fn try_from(value: String) -> Result<Self, Self::Error> { 251 251 + Self::new_owned(&value) 121 252 } 122 253 } 123 254 124 124 - impl<'a> From<CowStr<'a>> for AtUri<'a> { 125 125 - fn from(value: CowStr<'a>) -> Self { 126 126 - if value.len() > 2048 { 127 127 - panic!("AT_URI too long") 128 128 - } else if !AT_URI_REGEX.is_match(&value) { 129 129 - panic!("Invalid AT_URI") 130 130 - } else { 131 131 - Self(value) 132 132 - } 255 255 + impl<'d> TryFrom<CowStr<'d>> for AtUri<'d> { 256 256 + type Error = &'static str; 257 257 + /// TODO: rewrite to avoid taking ownership/cloning 258 258 + fn try_from(value: CowStr<'d>) -> Result<Self, Self::Error> { 259 259 + Self::new_owned(value) 133 260 } 134 261 } 135 262 136 263 impl AsRef<str> for AtUri<'_> { 137 264 fn as_ref(&self) -> &str { 138 138 - self.as_str() 265 265 + &self.uri.as_ref() 139 266 } 140 267 } 141 268 ··· 143 270 type Target = str; 144 271 145 272 fn deref(&self) -> &Self::Target { 146 146 - self.as_str() 273 273 + self.uri.as_ref() 147 274 } 148 275 }

+23 -5

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

··· 1 1 - use crate::{CowStr, types::cid::Cid}; 2 2 - use compact_str::ToCompactString; 1 1 + use crate::{CowStr, IntoStatic, types::cid::Cid}; 3 2 #[allow(unused)] 4 3 use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error}; 4 4 + use smol_str::ToSmolStr; 5 5 + use std::convert::Infallible; 5 6 #[allow(unused)] 6 7 use std::{ 7 8 borrow::Cow, ··· 39 40 /// Wrapper for file type 40 41 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)] 41 42 #[serde(transparent)] 43 43 + #[repr(transparent)] 42 44 pub struct MimeType<'m>(pub CowStr<'m>); 43 45 44 46 impl<'m> MimeType<'m> { 45 47 /// Fallible constructor, validates, borrows from input 46 48 pub fn new(mime_type: &'m str) -> Result<MimeType<'m>, &'static str> { 47 49 Ok(Self(CowStr::Borrowed(mime_type))) 50 50 + } 51 51 + 52 52 + pub fn new_owned(mime_type: impl AsRef<str>) -> Self { 53 53 + Self(CowStr::Owned(mime_type.as_ref().to_smolstr())) 54 54 + } 55 55 + 56 56 + pub fn new_static(mime_type: &'static str) -> Self { 57 57 + Self(CowStr::new_static(mime_type)) 48 58 } 49 59 50 60 /// Fallible constructor from an existing CowStr, borrows ··· 66 76 } 67 77 68 78 impl FromStr for MimeType<'_> { 69 69 - type Err = &'static str; 79 79 + type Err = Infallible; 70 80 71 81 /// Has to take ownership due to the lifetime constraints of the FromStr trait. 72 82 fn from_str(s: &str) -> Result<Self, Self::Err> { 73 73 - Self::from_cowstr(CowStr::Owned(s.to_compact_string())) 83 83 + Ok(Self::new_owned(s)) 84 84 + } 85 85 + } 86 86 + 87 87 + impl IntoStatic for MimeType<'_> { 88 88 + type Output = MimeType<'static>; 89 89 + 90 90 + fn into_static(self) -> Self::Output { 91 91 + MimeType(self.0.into_static()) 74 92 } 75 93 } 76 94 ··· 107 125 108 126 impl From<String> for MimeType<'static> { 109 127 fn from(value: String) -> Self { 110 110 - Self(CowStr::Owned(value.to_compact_string())) 128 128 + Self(CowStr::Owned(value.to_smolstr())) 111 129 } 112 130 } 113 131

+21 -10

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

··· 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}; 5 5 - 1 1 + use crate::{CowStr, IntoStatic}; 6 2 pub use cid::Cid as IpldCid; 7 7 - 8 8 - use crate::CowStr; 3 3 + use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Visitor}; 4 4 + use smol_str::ToSmolStr; 5 5 + use std::{convert::Infallible, fmt, marker::PhantomData, ops::Deref, str::FromStr}; 9 6 10 7 /// raw 11 8 pub const ATP_CID_CODEC: u64 = 0x55; ··· 47 44 let s = CowStr::Owned( 48 45 cid.to_string_of_base(ATP_CID_BASE) 49 46 .unwrap_or_default() 50 50 - .to_compact_string(), 47 47 + .to_smolstr(), 51 48 ); 52 49 Self::Ipld { cid, s } 53 50 } ··· 89 86 90 87 /// Has to take ownership due to the lifetime constraints of the FromStr trait. 91 88 fn from_str(s: &str) -> Result<Self, Self::Err> { 92 92 - Ok(Cid::Str(CowStr::Owned(s.to_compact_string()))) 89 89 + Ok(Cid::Str(CowStr::Owned(s.to_smolstr()))) 90 90 + } 91 91 + } 92 92 + 93 93 + impl IntoStatic for Cid<'_> { 94 94 + type Output = Cid<'static>; 95 95 + 96 96 + fn into_static(self) -> Self::Output { 97 97 + match self { 98 98 + Cid::Ipld { cid, s } => Cid::Ipld { 99 99 + cid, 100 100 + s: s.into_static(), 101 101 + }, 102 102 + Cid::Str(cow_str) => Cid::Str(cow_str.into_static()), 103 103 + } 93 104 } 94 105 } 95 106 ··· 164 175 165 176 impl From<String> for Cid<'_> { 166 177 fn from(value: String) -> Self { 167 167 - Cid::Str(CowStr::Owned(value.to_compact_string())) 178 178 + Cid::Str(CowStr::Owned(value.to_smolstr())) 168 179 } 169 180 } 170 181

+52

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

··· 1 1 + use core::fmt; 2 2 + 3 3 + use serde::{Serialize, de}; 4 4 + 5 5 + use crate::types::{ 6 6 + aturi::UriPath, 7 7 + nsid::Nsid, 8 8 + recordkey::{RecordKey, RecordKeyType, Rkey}, 9 9 + }; 10 10 + 11 11 + /// Trait for a collection of records that can be stored in a repository. 12 12 + /// 13 13 + /// The records all have the same Lexicon schema. 14 14 + pub trait Collection: fmt::Debug { 15 15 + /// The NSID for the Lexicon that defines the schema of records in this collection. 16 16 + const NSID: &'static str; 17 17 + 18 18 + /// This collection's record type. 19 19 + type Record: fmt::Debug + de::DeserializeOwned + Serialize; 20 20 + 21 21 + /// Returns the [`Nsid`] for the Lexicon that defines the schema of records in this 22 22 + /// collection. 23 23 + /// 24 24 + /// This is a convenience method that parses [`Self::NSID`]. 25 25 + /// 26 26 + /// # Panics 27 27 + /// 28 28 + /// Panics if [`Self::NSID`] is not a valid NSID. 29 29 + /// 30 30 + /// [`Nsid`]: string::Nsid 31 31 + fn nsid() -> crate::types::nsid::Nsid<'static> { 32 32 + Nsid::new_static(Self::NSID).expect("should be valid NSID") 33 33 + } 34 34 + 35 35 + /// Returns the repo path for a record in this collection with the given record key. 36 36 + /// 37 37 + /// Per the [Repo Data Structure v3] specification: 38 38 + /// > Repo paths currently have a fixed structure of `<collection>/<record-key>`. This 39 39 + /// > means a valid, normalized [`Nsid`], followed by a `/`, followed by a valid 40 40 + /// > [`RecordKey`]. 41 41 + /// 42 42 + /// [Repo Data Structure v3]: https://atproto.com/specs/repository#repo-data-structure-v3 43 43 + /// [`Nsid`]: string::Nsid 44 44 + fn repo_path<'u, T: RecordKeyType>( 45 45 + rkey: &'u crate::types::recordkey::RecordKey<T>, 46 46 + ) -> UriPath<'u> { 47 47 + UriPath { 48 48 + collection: Self::nsid(), 49 49 + rkey: Some(RecordKey::from(Rkey::raw(rkey.as_ref()))), 50 50 + } 51 51 + } 52 52 + }

+5 -6

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

··· 1 1 - use std::sync::LazyLock; 2 2 - use std::{cmp, str::FromStr}; 3 3 - 4 1 use chrono::DurationRound; 5 5 - use compact_str::ToCompactString; 6 2 use serde::Serializer; 7 3 use serde::{Deserialize, Deserializer, Serialize, de::Error}; 4 4 + use smol_str::ToSmolStr; 5 5 + use std::sync::LazyLock; 6 6 + use std::{cmp, str::FromStr}; 8 7 9 8 use crate::{CowStr, IntoStatic}; 10 9 use regex::Regex; ··· 58 57 // This serialization format is compatible with ISO 8601. 59 58 let serialized = CowStr::Owned( 60 59 dt.to_rfc3339_opts(chrono::SecondsFormat::Micros, true) 61 61 - .to_compact_string(), 60 60 + .to_smolstr(), 62 61 ); 63 62 Self { serialized, dt } 64 63 } ··· 139 138 if ISO8601_REGEX.is_match(&value) { 140 139 let dt = chrono::DateTime::parse_from_rfc3339(&value)?; 141 140 Ok(Self { 142 142 - serialized: CowStr::Owned(value.to_compact_string()), 141 141 + serialized: CowStr::Owned(value.to_smolstr()), 143 142 dt, 144 143 }) 145 144 } else {

+53 -14

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

··· 1 1 + use crate::{CowStr, IntoStatic}; 2 2 + use regex::Regex; 3 3 + use serde::{Deserialize, Deserializer, Serialize, de::Error}; 4 4 + use smol_str::ToSmolStr; 1 5 use std::fmt; 2 6 use std::sync::LazyLock; 3 7 use std::{ops::Deref, str::FromStr}; 4 8 5 5 - use compact_str::ToCompactString; 6 6 - use serde::{Deserialize, Deserializer, Serialize, de::Error}; 7 7 - 8 8 - use crate::{CowStr, IntoStatic}; 9 9 - use regex::Regex; 10 10 - 11 11 - #[derive(Debug, Clone, PartialEq, Eq, Serialize, Hash)] 9 9 + #[derive(Clone, PartialEq, Eq, Serialize, Hash)] 12 10 #[serde(transparent)] 11 11 + #[repr(transparent)] 13 12 pub struct Did<'d>(CowStr<'d>); 14 13 15 14 pub static DID_REGEX: LazyLock<Regex> = ··· 18 17 impl<'d> Did<'d> { 19 18 /// Fallible constructor, validates, borrows from input 20 19 pub fn new(did: &'d str) -> Result<Self, &'static str> { 20 20 + let did = did.strip_prefix("at://").unwrap_or(did); 21 21 if did.len() > 2048 { 22 22 Err("DID too long") 23 23 } else if !DID_REGEX.is_match(did) { ··· 27 27 } 28 28 } 29 29 30 30 - /// Fallible constructor from an existing CowStr, takes ownership 31 31 - pub fn from_cowstr(did: CowStr<'d>) -> Result<Did<'d>, &'static str> { 30 30 + /// Fallible constructor, validates, takes ownership 31 31 + pub fn new_owned(did: impl AsRef<str>) -> Result<Self, &'static str> { 32 32 + let did = did.as_ref(); 33 33 + let did = did.strip_prefix("at://").unwrap_or(did); 32 34 if did.len() > 2048 { 33 35 Err("DID too long") 34 34 - } else if !DID_REGEX.is_match(&did) { 36 36 + } else if !DID_REGEX.is_match(did) { 37 37 + Err("Invalid DID") 38 38 + } else { 39 39 + Ok(Self(CowStr::Owned(did.to_smolstr()))) 40 40 + } 41 41 + } 42 42 + 43 43 + /// Fallible constructor, validates, doesn't allocate 44 44 + pub fn new_static(did: &'static str) -> Result<Self, &'static str> { 45 45 + let did = did.strip_prefix("at://").unwrap_or(did); 46 46 + if did.len() > 2048 { 47 47 + Err("DID too long") 48 48 + } else if !DID_REGEX.is_match(did) { 35 49 Err("Invalid DID") 36 50 } else { 37 37 - Ok(Self(did.into_static())) 51 51 + Ok(Self(CowStr::new_static(did))) 38 52 } 39 53 } 40 54 ··· 43 57 /// or API values you know are valid (rather than using serde), this is the one to use. 44 58 /// The From<String> and From<CowStr> impls use the same logic. 45 59 pub fn raw(did: &'d str) -> Self { 60 60 + let did = did.strip_prefix("at://").unwrap_or(did); 46 61 if did.len() > 2048 { 47 62 panic!("DID too long") 48 63 } else if !DID_REGEX.is_match(did) { ··· 72 87 /// Has to take ownership due to the lifetime constraints of the FromStr trait. 73 88 /// Prefer `Did::new()` or `Did::raw` if you want to borrow. 74 89 fn from_str(s: &str) -> Result<Self, Self::Err> { 75 75 - Self::from_cowstr(CowStr::Borrowed(s).into_static()) 90 90 + Self::new_owned(s) 91 91 + } 92 92 + } 93 93 + 94 94 + impl IntoStatic for Did<'_> { 95 95 + type Output = Did<'static>; 96 96 + 97 97 + fn into_static(self) -> Self::Output { 98 98 + Did(self.0.into_static()) 76 99 } 77 100 } 78 101 ··· 92 115 } 93 116 } 94 117 118 118 + impl fmt::Debug for Did<'_> { 119 119 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 120 120 + write!(f, "at://{}", self.0) 121 121 + } 122 122 + } 123 123 + 95 124 impl<'d> From<Did<'d>> for String { 96 125 fn from(value: Did<'d>) -> Self { 97 126 value.0.to_string() ··· 106 135 107 136 impl From<String> for Did<'static> { 108 137 fn from(value: String) -> Self { 138 138 + let value = if let Some(did) = value.strip_prefix("at://") { 139 139 + CowStr::Borrowed(did) 140 140 + } else { 141 141 + value.into() 142 142 + }; 109 143 if value.len() > 2048 { 110 144 panic!("DID too long") 111 145 } else if !DID_REGEX.is_match(&value) { 112 146 panic!("Invalid DID") 113 147 } else { 114 114 - Self(CowStr::Owned(value.to_compact_string())) 148 148 + Self(value.into_static()) 115 149 } 116 150 } 117 151 } 118 152 119 153 impl<'d> From<CowStr<'d>> for Did<'d> { 120 154 fn from(value: CowStr<'d>) -> Self { 155 155 + let value = if let Some(did) = value.strip_prefix("at://") { 156 156 + CowStr::Borrowed(did) 157 157 + } else { 158 158 + value 159 159 + }; 121 160 if value.len() > 2048 { 122 161 panic!("DID too long") 123 162 } else if !DID_REGEX.is_match(&value) { 124 163 panic!("Invalid DID") 125 164 } else { 126 126 - Self(value) 165 165 + Self(value.into_static()) 127 166 } 128 167 } 129 168 }

+88 -30

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

··· 1 1 + use crate::{CowStr, IntoStatic}; 2 2 + use regex::Regex; 3 3 + use serde::{Deserialize, Deserializer, Serialize, de::Error}; 4 4 + use smol_str::ToSmolStr; 1 5 use std::fmt; 2 6 use std::sync::LazyLock; 3 7 use std::{ops::Deref, str::FromStr}; 4 8 5 5 - use compact_str::ToCompactString; 6 6 - use serde::{Deserialize, Deserializer, Serialize, de::Error}; 7 7 - 8 8 - use crate::{CowStr, IntoStatic}; 9 9 - use regex::Regex; 10 10 - 11 11 - #[derive(Debug, Clone, PartialEq, Eq, Serialize, Hash)] 9 9 + #[derive(Clone, PartialEq, Eq, Serialize, Hash)] 12 10 #[serde(transparent)] 11 11 + #[repr(transparent)] 13 12 pub struct Handle<'h>(CowStr<'h>); 14 13 15 14 pub static HANDLE_REGEX: LazyLock<Regex> = LazyLock::new(|| { 16 15 Regex::new(r"^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$").unwrap() 17 16 }); 18 17 18 18 + /// AT Protocol handle 19 19 impl<'h> Handle<'h> { 20 20 /// Fallible constructor, validates, borrows from input 21 21 /// 22 22 /// Accepts (and strips) preceding '@' if present 23 23 pub fn new(handle: &'h str) -> Result<Self, &'static str> { 24 24 - let handle = handle.strip_prefix('@').unwrap_or(handle); 25 25 - if handle.len() > 2048 { 24 24 + let handle = handle 25 25 + .strip_prefix("at://") 26 26 + .unwrap_or(handle) 27 27 + .strip_prefix('@') 28 28 + .unwrap_or(handle); 29 29 + if handle.len() > 253 { 26 30 Err("handle too long") 27 31 } else if !HANDLE_REGEX.is_match(handle) { 28 32 Err("Invalid handle") ··· 31 35 } 32 36 } 33 37 34 34 - /// Fallible constructor from an existing CowStr, takes ownership 35 35 - /// 36 36 - /// Accepts (and strips) preceding '@' if present 37 37 - pub fn from_cowstr(handle: CowStr<'h>) -> Result<Handle<'h>, &'static str> { 38 38 - let handle = if let Some(handle) = handle.strip_prefix('@') { 39 39 - CowStr::Borrowed(handle) 40 40 - } else { 41 41 - handle 42 42 - }; 43 43 - if handle.len() > 2048 { 38 38 + /// Fallible constructor, validates, takes ownership 39 39 + pub fn new_owned(handle: impl AsRef<str>) -> Result<Self, &'static str> { 40 40 + let handle = handle.as_ref(); 41 41 + let handle = handle 42 42 + .strip_prefix("at://") 43 43 + .unwrap_or(handle) 44 44 + .strip_prefix('@') 45 45 + .unwrap_or(handle); 46 46 + if handle.len() > 253 { 44 47 Err("handle too long") 45 45 - } else if !HANDLE_REGEX.is_match(&handle) { 48 48 + } else if !HANDLE_REGEX.is_match(handle) { 46 49 Err("Invalid handle") 47 50 } else { 48 48 - Ok(Self(handle.into_static())) 51 51 + Ok(Self(CowStr::Owned(handle.to_smolstr()))) 49 52 } 50 53 } 51 54 55 55 + /// Fallible constructor, validates, doesn't allocate 56 56 + pub fn new_static(handle: &'static str) -> Result<Self, &'static str> { 57 57 + let handle = handle 58 58 + .strip_prefix("at://") 59 59 + .unwrap_or(handle) 60 60 + .strip_prefix('@') 61 61 + .unwrap_or(handle); 62 62 + if handle.len() > 253 { 63 63 + Err("handle too long") 64 64 + } else if !HANDLE_REGEX.is_match(handle) { 65 65 + Err("Invalid handle") 66 66 + } else { 67 67 + Ok(Self(CowStr::new_static(handle))) 68 68 + } 69 69 + } 52 70 /// Infallible constructor for when you *know* the string is a valid handle. 53 71 /// Will panic on invalid handles. If you're manually decoding atproto records 54 72 /// or API values you know are valid (rather than using serde), this is the one to use. ··· 56 74 /// 57 75 /// Accepts (and strips) preceding '@' if present 58 76 pub fn raw(handle: &'h str) -> Self { 59 59 - let handle = handle.strip_prefix('@').unwrap_or(handle); 60 60 - if handle.len() > 2048 { 77 77 + let handle = handle 78 78 + .strip_prefix("at://") 79 79 + .unwrap_or(handle) 80 80 + .strip_prefix('@') 81 81 + .unwrap_or(handle); 82 82 + if handle.len() > 253 { 61 83 panic!("handle too long") 62 84 } else if !HANDLE_REGEX.is_match(handle) { 63 85 panic!("Invalid handle") ··· 71 93 /// 72 94 /// Accepts (and strips) preceding '@' if present 73 95 pub unsafe fn unchecked(handle: &'h str) -> Self { 74 74 - let handle = handle.strip_prefix('@').unwrap_or(handle); 96 96 + let handle = handle 97 97 + .strip_prefix("at://") 98 98 + .unwrap_or(handle) 99 99 + .strip_prefix('@') 100 100 + .unwrap_or(handle); 75 101 Self(CowStr::Borrowed(handle)) 76 102 } 77 103 ··· 89 115 /// Has to take ownership due to the lifetime constraints of the FromStr trait. 90 116 /// Prefer `Handle::new()` or `Handle::raw` if you want to borrow. 91 117 fn from_str(s: &str) -> Result<Self, Self::Err> { 92 92 - Self::from_cowstr(CowStr::Borrowed(s).into_static()) 118 118 + Self::new_owned(s) 119 119 + } 120 120 + } 121 121 + 122 122 + impl IntoStatic for Handle<'_> { 123 123 + type Output = Handle<'static>; 124 124 + 125 125 + fn into_static(self) -> Self::Output { 126 126 + Handle(self.0.into_static()) 93 127 } 94 128 } 95 129 ··· 105 139 106 140 impl fmt::Display for Handle<'_> { 107 141 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 108 108 - write!(f, "@{}", self.0) 142 142 + write!(f, "{}", self.0) 143 143 + } 144 144 + } 145 145 + 146 146 + impl fmt::Debug for Handle<'_> { 147 147 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 148 148 + write!(f, "at://{}", self.0) 109 149 } 110 150 } 111 151 ··· 123 163 124 164 impl From<String> for Handle<'static> { 125 165 fn from(value: String) -> Self { 126 126 - if value.len() > 2048 { 166 166 + let value = if let Some(handle) = value 167 167 + .strip_prefix("at://") 168 168 + .unwrap_or(&value) 169 169 + .strip_prefix('@') 170 170 + { 171 171 + CowStr::Borrowed(handle) 172 172 + } else { 173 173 + value.into() 174 174 + }; 175 175 + if value.len() > 253 { 127 176 panic!("handle too long") 128 177 } else if !HANDLE_REGEX.is_match(&value) { 129 178 panic!("Invalid handle") 130 179 } else { 131 131 - Self(CowStr::Owned(value.to_compact_string())) 180 180 + Self(value.into_static()) 132 181 } 133 182 } 134 183 } 135 184 136 185 impl<'h> From<CowStr<'h>> for Handle<'h> { 137 186 fn from(value: CowStr<'h>) -> Self { 138 138 - if value.len() > 2048 { 187 187 + let value = if let Some(handle) = value 188 188 + .strip_prefix("at://") 189 189 + .unwrap_or(&value) 190 190 + .strip_prefix('@') 191 191 + { 192 192 + CowStr::Borrowed(handle) 193 193 + } else { 194 194 + value 195 195 + }; 196 196 + if value.len() > 253 { 139 197 panic!("handle too long") 140 198 } else if !HANDLE_REGEX.is_match(&value) { 141 199 panic!("Invalid handle") 142 200 } else { 143 143 - Self(value) 201 201 + Self(value.into_static()) 144 202 } 145 203 } 146 204 }

+26 -5

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

··· 1 1 - use crate::types::did::Did; 2 1 use crate::types::handle::Handle; 2 2 + use crate::{IntoStatic, types::did::Did}; 3 3 use std::fmt; 4 4 use std::str::FromStr; 5 5 ··· 26 26 } 27 27 } 28 28 29 29 - /// Fallible constructor from an existing CowStr, borrows 30 30 - pub fn from_cowstr(ident: CowStr<'i>) -> Result<AtIdentifier<'i>, &'static str> { 31 31 - if let Ok(did) = ident.parse() { 29 29 + /// Fallible constructor, validates, takes ownership 30 30 + pub fn new_owned(ident: impl AsRef<str>) -> Result<Self, &'static str> { 31 31 + let ident = ident.as_ref(); 32 32 + if let Ok(did) = Did::new_owned(ident) { 32 33 Ok(AtIdentifier::Did(did)) 33 34 } else { 34 34 - ident.parse().map(AtIdentifier::Handle) 35 35 + Ok(AtIdentifier::Handle(Handle::new_owned(ident)?)) 36 36 + } 37 37 + } 38 38 + 39 39 + /// Fallible constructor, validates, doesn't allocate 40 40 + pub fn new_static(ident: &'static str) -> Result<AtIdentifier<'static>, &'static str> { 41 41 + if let Ok(did) = Did::new_static(ident) { 42 42 + Ok(AtIdentifier::Did(did)) 43 43 + } else { 44 44 + Ok(AtIdentifier::Handle(Handle::new_static(ident)?)) 35 45 } 36 46 } 37 47 ··· 90 100 Ok(AtIdentifier::Did(did)) 91 101 } else { 92 102 s.parse().map(AtIdentifier::Handle) 103 103 + } 104 104 + } 105 105 + } 106 106 + 107 107 + impl IntoStatic for AtIdentifier<'_> { 108 108 + type Output = AtIdentifier<'static>; 109 109 + 110 110 + fn into_static(self) -> Self::Output { 111 111 + match self { 112 112 + AtIdentifier::Did(did) => AtIdentifier::Did(did.into_static()), 113 113 + AtIdentifier::Handle(handle) => AtIdentifier::Handle(handle.into_static()), 93 114 } 94 115 } 95 116 }

+209

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

··· 1 1 + use crate::types::recordkey::RecordKeyType; 2 2 + use crate::{CowStr, IntoStatic}; 3 3 + use regex::Regex; 4 4 + use serde::{Deserialize, Deserializer, Serialize, de::Error}; 5 5 + use smol_str::{SmolStr, ToSmolStr}; 6 6 + use std::fmt; 7 7 + use std::sync::LazyLock; 8 8 + use std::{ops::Deref, str::FromStr}; 1 9 10 10 + /// Namespaced Identifier (NSID) 11 11 + /// 12 12 + /// Stored as SmolStr to ease lifetime issues and because, despite the fact that NSIDs *can* be 317 characters, most are quite short 13 13 + /// TODO: consider if this should go back to CowStr, or be broken up into segments 14 14 + #[derive(Clone, PartialEq, Eq, Serialize, Hash)] 15 15 + #[serde(transparent)] 16 16 + #[repr(transparent)] 17 17 + pub struct Nsid<'n>(CowStr<'n>); 18 18 + 19 19 + pub static NSID_REGEX: LazyLock<Regex> = LazyLock::new(|| { 20 20 + Regex::new(r"^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z][a-zA-Z0-9]{0,62})$").unwrap() 21 21 + }); 22 22 + 23 23 + impl<'n> Nsid<'n> { 24 24 + /// Fallible constructor, validates, borrows from input 25 25 + pub fn new(nsid: &'n str) -> Result<Self, &'static str> { 26 26 + if nsid.len() > 317 { 27 27 + Err("NSID too long") 28 28 + } else if !NSID_REGEX.is_match(nsid) { 29 29 + Err("Invalid NSID") 30 30 + } else { 31 31 + Ok(Self(CowStr::Borrowed(nsid))) 32 32 + } 33 33 + } 34 34 + 35 35 + /// Fallible constructor, validates, borrows from input 36 36 + pub fn new_owned(nsid: impl AsRef<str>) -> Result<Self, &'static str> { 37 37 + let nsid = nsid.as_ref(); 38 38 + if nsid.len() > 317 { 39 39 + Err("NSID too long") 40 40 + } else if !NSID_REGEX.is_match(nsid) { 41 41 + Err("Invalid NSID") 42 42 + } else { 43 43 + Ok(Self(CowStr::Owned(nsid.to_smolstr()))) 44 44 + } 45 45 + } 46 46 + 47 47 + /// Fallible constructor, validates, doesn't allocate 48 48 + pub fn new_static(nsid: &'static str) -> Result<Self, &'static str> { 49 49 + if nsid.len() > 317 { 50 50 + Err("NSID too long") 51 51 + } else if !NSID_REGEX.is_match(nsid) { 52 52 + Err("Invalid NSID") 53 53 + } else { 54 54 + Ok(Self(CowStr::new_static(nsid))) 55 55 + } 56 56 + } 57 57 + 58 58 + /// Infallible constructor for when you *know* the string is a valid NSID. 59 59 + /// Will panic on invalid NSIDs. If you're manually decoding atproto records 60 60 + /// or API values you know are valid (rather than using serde), this is the one to use. 61 61 + /// The From<String> and From<CowStr> impls use the same logic. 62 62 + pub fn raw(nsid: &'n str) -> Self { 63 63 + if nsid.len() > 317 { 64 64 + panic!("NSID too long") 65 65 + } else if !NSID_REGEX.is_match(nsid) { 66 66 + panic!("Invalid NSID") 67 67 + } else { 68 68 + Self(CowStr::Borrowed(nsid)) 69 69 + } 70 70 + } 71 71 + 72 72 + /// Infallible constructor for when you *know* the string is a valid NSID. 73 73 + /// Marked unsafe because responsibility for upholding the invariant is on the developer. 74 74 + pub unsafe fn unchecked(nsid: &'n str) -> Self { 75 75 + Self(CowStr::Borrowed(nsid)) 76 76 + } 77 77 + 78 78 + /// Returns the domain authority part of the NSID. 79 79 + pub fn domain_authority(&self) -> &str { 80 80 + let split = self.0.rfind('.').expect("enforced by constructor"); 81 81 + &self.0[..split] 82 82 + } 83 83 + 84 84 + /// Returns the name segment of the NSID. 85 85 + pub fn name(&self) -> &str { 86 86 + let split = self.0.rfind('.').expect("enforced by constructor"); 87 87 + &self.0[split + 1..] 88 88 + } 89 89 + 90 90 + pub fn as_str(&self) -> &str { 91 91 + { 92 92 + let this = &self.0; 93 93 + this 94 94 + } 95 95 + } 96 96 + } 97 97 + 98 98 + impl<'n> FromStr for Nsid<'n> { 99 99 + type Err = &'static str; 100 100 + 101 101 + /// Has to take ownership due to the lifetime constraints of the FromStr trait. 102 102 + /// Prefer `Nsid::new()` or `Nsid::raw` if you want to borrow. 103 103 + fn from_str(s: &str) -> Result<Self, Self::Err> { 104 104 + Self::new_owned(s) 105 105 + } 106 106 + } 107 107 + 108 108 + impl IntoStatic for Nsid<'_> { 109 109 + type Output = Nsid<'static>; 110 110 + 111 111 + fn into_static(self) -> Self::Output { 112 112 + Nsid(self.0.into_static()) 113 113 + } 114 114 + } 115 115 + 116 116 + impl<'de> Deserialize<'de> for Nsid<'de> { 117 117 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 118 118 + where 119 119 + D: Deserializer<'de>, 120 120 + { 121 121 + let value: &str = Deserialize::deserialize(deserializer)?; 122 122 + Self::new(value).map_err(D::Error::custom) 123 123 + } 124 124 + } 125 125 + 126 126 + impl fmt::Display for Nsid<'_> { 127 127 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 128 128 + f.write_str(&self.0) 129 129 + } 130 130 + } 131 131 + 132 132 + impl fmt::Debug for Nsid<'_> { 133 133 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 134 134 + write!(f, "at://{}", self.0) 135 135 + } 136 136 + } 137 137 + 138 138 + impl<'n> From<Nsid<'n>> for String { 139 139 + fn from(value: Nsid) -> Self { 140 140 + value.0.to_string() 141 141 + } 142 142 + } 143 143 + 144 144 + impl<'n> From<Nsid<'n>> for CowStr<'n> { 145 145 + fn from(value: Nsid<'n>) -> Self { 146 146 + value.0 147 147 + } 148 148 + } 149 149 + 150 150 + impl From<Nsid<'_>> for SmolStr { 151 151 + fn from(value: Nsid) -> Self { 152 152 + value.0.to_smolstr() 153 153 + } 154 154 + } 155 155 + 156 156 + impl<'n> From<String> for Nsid<'n> { 157 157 + fn from(value: String) -> Self { 158 158 + if value.len() > 317 { 159 159 + panic!("NSID too long") 160 160 + } else if !NSID_REGEX.is_match(&value) { 161 161 + panic!("Invalid NSID") 162 162 + } else { 163 163 + Self(CowStr::Owned(value.to_smolstr())) 164 164 + } 165 165 + } 166 166 + } 167 167 + 168 168 + impl<'n> From<CowStr<'n>> for Nsid<'n> { 169 169 + fn from(value: CowStr<'n>) -> Self { 170 170 + if value.len() > 317 { 171 171 + panic!("NSID too long") 172 172 + } else if !NSID_REGEX.is_match(&value) { 173 173 + panic!("Invalid NSID") 174 174 + } else { 175 175 + Self(value) 176 176 + } 177 177 + } 178 178 + } 179 179 + 180 180 + impl From<SmolStr> for Nsid<'_> { 181 181 + fn from(value: SmolStr) -> Self { 182 182 + if value.len() > 317 { 183 183 + panic!("NSID too long") 184 184 + } else if !NSID_REGEX.is_match(&value) { 185 185 + panic!("Invalid NSID") 186 186 + } else { 187 187 + Self(CowStr::Owned(value)) 188 188 + } 189 189 + } 190 190 + } 191 191 + 192 192 + impl AsRef<str> for Nsid<'_> { 193 193 + fn as_ref(&self) -> &str { 194 194 + self.as_str() 195 195 + } 196 196 + } 197 197 + 198 198 + impl Deref for Nsid<'_> { 199 199 + type Target = str; 200 200 + 201 201 + fn deref(&self) -> &Self::Target { 202 202 + self.as_str() 203 203 + } 204 204 + } 205 205 + 206 206 + unsafe impl RecordKeyType for Nsid<'_> { 207 207 + fn as_str(&self) -> &str { 208 208 + self.as_str() 209 209 + } 210 210 + }

+402

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

··· 1 1 + use crate::types::Literal; 2 2 + use crate::{CowStr, IntoStatic}; 3 3 + use regex::Regex; 4 4 + use serde::{Deserialize, Deserializer, Serialize, de::Error}; 5 5 + use smol_str::{SmolStr, ToSmolStr}; 6 6 + use std::fmt; 7 7 + use std::marker::PhantomData; 8 8 + use std::sync::LazyLock; 9 9 + use std::{ops::Deref, str::FromStr}; 10 10 + 11 11 + /// Trait for generic typed record keys 12 12 + /// 13 13 + /// This is deliberately public (so that consumers can develop specialized record key types), 14 14 + /// but is marked as unsafe, because the implementer is expected to uphold the invariants 15 15 + /// required by this trait, namely compliance with the [spec](https://atproto.com/specs/record-key) 16 16 + /// as described by [`RKEY_REGEX`](RKEY_REGEX). 17 17 + /// 18 18 + /// This crate provides implementations for TID, NSID, literals, and generic strings 19 19 + pub unsafe trait RecordKeyType: Clone + Serialize { 20 20 + fn as_str(&self) -> &str; 21 21 + } 22 22 + 23 23 + #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Hash, Debug)] 24 24 + #[serde(transparent)] 25 25 + #[repr(transparent)] 26 26 + pub struct RecordKey<T: RecordKeyType>(pub T); 27 27 + 28 28 + impl<T> From<T> for RecordKey<Rkey<'_>> 29 29 + where 30 30 + T: RecordKeyType, 31 31 + { 32 32 + fn from(value: T) -> Self { 33 33 + RecordKey(Rkey::from_str(value.as_str()).expect("Invalid rkey")) 34 34 + } 35 35 + } 36 36 + 37 37 + impl<T> AsRef<str> for RecordKey<T> 38 38 + where 39 39 + T: RecordKeyType, 40 40 + { 41 41 + fn as_ref(&self) -> &str { 42 42 + self.0.as_str() 43 43 + } 44 44 + } 45 45 + 46 46 + impl<T> IntoStatic for RecordKey<T> 47 47 + where 48 48 + T: IntoStatic + RecordKeyType, 49 49 + T::Output: RecordKeyType, 50 50 + { 51 51 + type Output = RecordKey<T::Output>; 52 52 + 53 53 + fn into_static(self) -> Self::Output { 54 54 + RecordKey(self.0.into_static()) 55 55 + } 56 56 + } 57 57 + 58 58 + /// ATProto Record Key (type `any`) 59 59 + /// Catch-all for any string meeting the overall Record Key requirements detailed https://atproto.com/specs/record-key 60 60 + #[derive(Clone, PartialEq, Eq, Serialize, Hash)] 61 61 + #[serde(transparent)] 62 62 + #[repr(transparent)] 63 63 + pub struct Rkey<'r>(CowStr<'r>); 64 64 + 65 65 + unsafe impl<'r> RecordKeyType for Rkey<'r> { 66 66 + fn as_str(&self) -> &str { 67 67 + self.0.as_ref() 68 68 + } 69 69 + } 70 70 + 71 71 + pub static RKEY_REGEX: LazyLock<Regex> = 72 72 + LazyLock::new(|| Regex::new(r"^[a-zA-Z0-9.\-_:~]{1,512}$").unwrap()); 73 73 + 74 74 + /// AT Protocol rkey 75 75 + impl<'r> Rkey<'r> { 76 76 + /// Fallible constructor, validates, borrows from input 77 77 + pub fn new(rkey: &'r str) -> Result<Self, &'static str> { 78 78 + if [".", ".."].contains(&rkey) { 79 79 + Err("Disallowed rkey") 80 80 + } else if !RKEY_REGEX.is_match(rkey) { 81 81 + Err("Invalid rkey") 82 82 + } else { 83 83 + Ok(Self(CowStr::Borrowed(rkey))) 84 84 + } 85 85 + } 86 86 + 87 87 + /// Fallible constructor, validates, borrows from input 88 88 + pub fn new_owned(rkey: impl AsRef<str>) -> Result<Self, &'static str> { 89 89 + let rkey = rkey.as_ref(); 90 90 + if [".", ".."].contains(&rkey) { 91 91 + Err("Disallowed rkey") 92 92 + } else if !RKEY_REGEX.is_match(rkey) { 93 93 + Err("Invalid rkey") 94 94 + } else { 95 95 + Ok(Self(CowStr::Owned(rkey.to_smolstr()))) 96 96 + } 97 97 + } 98 98 + 99 99 + /// Fallible constructor, validates, doesn't allocate 100 100 + pub fn new_static(rkey: &'static str) -> Result<Self, &'static str> { 101 101 + if [".", ".."].contains(&rkey) { 102 102 + Err("Disallowed rkey") 103 103 + } else if !RKEY_REGEX.is_match(rkey) { 104 104 + Err("Invalid rkey") 105 105 + } else { 106 106 + Ok(Self(CowStr::new_static(rkey))) 107 107 + } 108 108 + } 109 109 + 110 110 + /// Infallible constructor for when you *know* the string is a valid rkey. 111 111 + /// Will panic on invalid rkeys. If you're manually decoding atproto records 112 112 + /// or API values you know are valid (rather than using serde), this is the one to use. 113 113 + /// The From impls use the same logic. 114 114 + pub fn raw(rkey: &'r str) -> Self { 115 115 + if [".", ".."].contains(&rkey) { 116 116 + panic!("Disallowed rkey") 117 117 + } else if !RKEY_REGEX.is_match(rkey) { 118 118 + panic!("Invalid rkey") 119 119 + } else { 120 120 + Self(CowStr::Borrowed(rkey)) 121 121 + } 122 122 + } 123 123 + 124 124 + /// Infallible constructor for when you *know* the string is a valid rkey. 125 125 + /// Marked unsafe because responsibility for upholding the invariant is on the developer. 126 126 + pub unsafe fn unchecked(rkey: &'r str) -> Self { 127 127 + Self(CowStr::Borrowed(rkey)) 128 128 + } 129 129 + 130 130 + pub fn as_str(&self) -> &str { 131 131 + { 132 132 + let this = &self.0; 133 133 + this 134 134 + } 135 135 + } 136 136 + } 137 137 + 138 138 + impl<'r> FromStr for Rkey<'r> { 139 139 + type Err = &'static str; 140 140 + 141 141 + fn from_str(s: &str) -> Result<Self, Self::Err> { 142 142 + if [".", ".."].contains(&s) { 143 143 + Err("Disallowed rkey") 144 144 + } else if !RKEY_REGEX.is_match(s) { 145 145 + Err("Invalid rkey") 146 146 + } else { 147 147 + Ok(Self(CowStr::Owned(s.to_smolstr()))) 148 148 + } 149 149 + } 150 150 + } 151 151 + 152 152 + impl IntoStatic for Rkey<'_> { 153 153 + type Output = Rkey<'static>; 154 154 + 155 155 + fn into_static(self) -> Self::Output { 156 156 + Rkey(self.0.into_static()) 157 157 + } 158 158 + } 159 159 + 160 160 + impl<'de> Deserialize<'de> for Rkey<'de> { 161 161 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 162 162 + where 163 163 + D: Deserializer<'de>, 164 164 + { 165 165 + let value: &str = Deserialize::deserialize(deserializer)?; 166 166 + Self::new(value).map_err(D::Error::custom) 167 167 + } 168 168 + } 169 169 + 170 170 + impl fmt::Display for Rkey<'_> { 171 171 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 172 172 + f.write_str(&self.0) 173 173 + } 174 174 + } 175 175 + 176 176 + impl fmt::Debug for Rkey<'_> { 177 177 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 178 178 + write!(f, "record-key:{}", self.0) 179 179 + } 180 180 + } 181 181 + 182 182 + impl From<Rkey<'_>> for String { 183 183 + fn from(value: Rkey<'_>) -> Self { 184 184 + value.0.to_string() 185 185 + } 186 186 + } 187 187 + 188 188 + impl<'r> From<Rkey<'r>> for CowStr<'r> { 189 189 + fn from(value: Rkey<'r>) -> Self { 190 190 + value.0 191 191 + } 192 192 + } 193 193 + 194 194 + impl<'r> From<Rkey<'r>> for SmolStr { 195 195 + fn from(value: Rkey) -> Self { 196 196 + value.0.to_smolstr() 197 197 + } 198 198 + } 199 199 + 200 200 + impl<'r> From<String> for Rkey<'r> { 201 201 + fn from(value: String) -> Self { 202 202 + if [".", ".."].contains(&value.as_str()) { 203 203 + panic!("Disallowed rkey") 204 204 + } else if !RKEY_REGEX.is_match(&value) { 205 205 + panic!("Invalid rkey") 206 206 + } else { 207 207 + Self(CowStr::Owned(value.to_smolstr())) 208 208 + } 209 209 + } 210 210 + } 211 211 + 212 212 + impl<'r> From<CowStr<'r>> for Rkey<'r> { 213 213 + fn from(value: CowStr<'r>) -> Self { 214 214 + if [".", ".."].contains(&value.as_ref()) { 215 215 + panic!("Disallowed rkey") 216 216 + } else if !RKEY_REGEX.is_match(&value) { 217 217 + panic!("Invalid rkey") 218 218 + } else { 219 219 + Self(value) 220 220 + } 221 221 + } 222 222 + } 223 223 + 224 224 + impl AsRef<str> for Rkey<'_> { 225 225 + fn as_ref(&self) -> &str { 226 226 + self.as_str() 227 227 + } 228 228 + } 229 229 + 230 230 + impl Deref for Rkey<'_> { 231 231 + type Target = str; 232 232 + 233 233 + fn deref(&self) -> &Self::Target { 234 234 + self.0.as_ref() 235 235 + } 236 236 + } 237 237 + 238 238 + /// ATProto Record Key (type `literal:<value>`) 239 239 + /// Zero-sized type, literal is associated constant of type parameter 240 240 + /// 241 241 + /// TODO: macro to construct arbitrary ones of these and the associated marker struct 242 242 + #[derive(Clone, PartialEq, Eq, Serialize, Hash)] 243 243 + pub struct LiteralKey<T: Literal = SelfRecord> { 244 244 + literal: PhantomData<T>, 245 245 + } 246 246 + 247 247 + #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] 248 248 + pub struct SelfRecord; 249 249 + 250 250 + impl Literal for SelfRecord { 251 251 + const LITERAL: &'static str = "self"; 252 252 + } 253 253 + 254 254 + unsafe impl<T: Literal> RecordKeyType for LiteralKey<T> { 255 255 + fn as_str(&self) -> &str { 256 256 + T::LITERAL 257 257 + } 258 258 + } 259 259 + 260 260 + /// AT Protocol rkey 261 261 + impl<T: Literal> LiteralKey<T> { 262 262 + /// Fallible constructor, validates, borrows from input 263 263 + pub fn new(rkey: impl AsRef<str>) -> Result<Self, &'static str> { 264 264 + let rkey = rkey.as_ref(); 265 265 + if !rkey.eq_ignore_ascii_case(T::LITERAL) { 266 266 + Err("Invalid literal rkey - does not match literal") 267 267 + } else if [".", ".."].contains(&rkey) { 268 268 + Err("Disallowed rkey") 269 269 + } else if !RKEY_REGEX.is_match(rkey) { 270 270 + Err("Invalid rkey") 271 271 + } else { 272 272 + Ok(Self { 273 273 + literal: PhantomData, 274 274 + }) 275 275 + } 276 276 + } 277 277 + 278 278 + /// Infallible constructor for when you *know* the string is a valid rkey. 279 279 + /// Will panic on invalid rkeys. If you're manually decoding atproto records 280 280 + /// or API values you know are valid (rather than using serde), this is the one to use. 281 281 + /// The From<String> and From<CowStr> impls use the same logic. 282 282 + pub fn raw(rkey: &str) -> Self { 283 283 + if !rkey.eq_ignore_ascii_case(T::LITERAL) { 284 284 + panic!( 285 285 + "Invalid literal rkey - does not match literal {}", 286 286 + T::LITERAL 287 287 + ) 288 288 + } else if [".", ".."].contains(&rkey.as_ref()) { 289 289 + panic!("Disallowed rkey") 290 290 + } else if !RKEY_REGEX.is_match(rkey) { 291 291 + panic!("Invalid rkey") 292 292 + } else { 293 293 + Self { 294 294 + literal: PhantomData, 295 295 + } 296 296 + } 297 297 + } 298 298 + 299 299 + /// Infallible type constructor 300 300 + /// 301 301 + /// # Safety 302 302 + /// Does not validate that the literal is a valid record key 303 303 + pub unsafe fn t() -> Self { 304 304 + Self { 305 305 + literal: PhantomData, 306 306 + } 307 307 + } 308 308 + 309 309 + pub fn as_str(&self) -> &str { 310 310 + T::LITERAL 311 311 + } 312 312 + } 313 313 + 314 314 + impl<T: Literal> FromStr for LiteralKey<T> { 315 315 + type Err = &'static str; 316 316 + 317 317 + fn from_str(s: &str) -> Result<Self, Self::Err> { 318 318 + Self::new(s) 319 319 + } 320 320 + } 321 321 + 322 322 + impl<'de, T: Literal> Deserialize<'de> for LiteralKey<T> { 323 323 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 324 324 + where 325 325 + D: Deserializer<'de>, 326 326 + { 327 327 + let value: &str = Deserialize::deserialize(deserializer)?; 328 328 + Self::new(value).map_err(D::Error::custom) 329 329 + } 330 330 + } 331 331 + 332 332 + impl<T: Literal> fmt::Display for LiteralKey<T> { 333 333 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 334 334 + f.write_str(T::LITERAL) 335 335 + } 336 336 + } 337 337 + 338 338 + impl<T: Literal> fmt::Debug for LiteralKey<T> { 339 339 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 340 340 + write!(f, "literal:{}", T::LITERAL) 341 341 + } 342 342 + } 343 343 + 344 344 + impl<'r, T: Literal> From<LiteralKey<T>> for String { 345 345 + fn from(_value: LiteralKey<T>) -> Self { 346 346 + T::LITERAL.to_string() 347 347 + } 348 348 + } 349 349 + 350 350 + impl<'r, T: Literal> From<LiteralKey<T>> for CowStr<'r> { 351 351 + fn from(_value: LiteralKey<T>) -> Self { 352 352 + CowStr::Borrowed(T::LITERAL) 353 353 + } 354 354 + } 355 355 + 356 356 + impl<T: Literal> TryFrom<String> for LiteralKey<T> { 357 357 + type Error = &'static str; 358 358 + fn try_from(value: String) -> Result<Self, Self::Error> { 359 359 + if !value.eq_ignore_ascii_case(T::LITERAL) { 360 360 + Err("Invalid literal rkey - does not match literal") 361 361 + } else if [".", ".."].contains(&value.as_str()) { 362 362 + Err("Disallowed rkey") 363 363 + } else if !RKEY_REGEX.is_match(&value) { 364 364 + Err("Invalid rkey") 365 365 + } else { 366 366 + Ok(Self { 367 367 + literal: PhantomData, 368 368 + }) 369 369 + } 370 370 + } 371 371 + } 372 372 + 373 373 + impl<'r, T: Literal> TryFrom<CowStr<'r>> for LiteralKey<T> { 374 374 + type Error = &'static str; 375 375 + fn try_from(value: CowStr<'r>) -> Result<Self, Self::Error> { 376 376 + if !value.eq_ignore_ascii_case(T::LITERAL) { 377 377 + Err("Invalid literal rkey - does not match literal") 378 378 + } else if [".", ".."].contains(&value.as_ref()) { 379 379 + Err("Disallowed rkey") 380 380 + } else if !RKEY_REGEX.is_match(&value) { 381 381 + Err("Invalid rkey") 382 382 + } else { 383 383 + Ok(Self { 384 384 + literal: PhantomData, 385 385 + }) 386 386 + } 387 387 + } 388 388 + } 389 389 + 390 390 + impl<T: Literal> AsRef<str> for LiteralKey<T> { 391 391 + fn as_ref(&self) -> &str { 392 392 + self.as_str() 393 393 + } 394 394 + } 395 395 + 396 396 + impl<T: Literal> Deref for LiteralKey<T> { 397 397 + type Target = str; 398 398 + 399 399 + fn deref(&self) -> &Self::Target { 400 400 + self.as_str() 401 401 + } 402 402 + }

+38 -43

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

··· 1 1 + use serde::{Deserialize, Deserializer, Serialize, de::Error}; 2 2 + use smol_str::{SmolStr, SmolStrBuilder}; 1 3 use std::fmt; 2 4 use std::sync::LazyLock; 3 5 use std::{ops::Deref, str::FromStr}; 4 6 5 5 - use compact_str::{CompactString, ToCompactString}; 6 6 - use serde::{Deserialize, Deserializer, Serialize, de::Error}; 7 7 - 7 7 + use crate::CowStr; 8 8 use crate::types::integer::LimitedU32; 9 9 - use crate::{CowStr, IntoStatic}; 10 9 use regex::Regex; 11 10 12 12 - fn s32_encode(mut i: u64) -> CowStr<'static> { 11 11 + fn s32_encode(mut i: u64) -> SmolStr { 13 12 const S32_CHAR: &[u8] = b"234567abcdefghijklmnopqrstuvwxyz"; 14 13 15 15 - let mut s = CompactString::with_capacity(13); 14 14 + let mut s = SmolStrBuilder::new(); 16 15 for _ in 0..13 { 17 16 let c = i & 0x1F; 18 17 s.push(S32_CHAR[c as usize] as char); ··· 20 19 i >>= 5; 21 20 } 22 21 23 23 - // Reverse the string to convert it to big-endian format. 24 24 - CowStr::Owned(s.chars().rev().collect()) 22 22 + let mut builder = SmolStrBuilder::new(); 23 23 + for c in s.finish().chars().rev() { 24 24 + builder.push(c); 25 25 + } 26 26 + builder.finish() 25 27 } 26 28 27 29 static TID_REGEX: LazyLock<Regex> = LazyLock::new(|| { ··· 33 35 /// [Timestamp Identifier]: https://atproto.com/specs/tid 34 36 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Hash)] 35 37 #[serde(transparent)] 36 36 - pub struct Tid<'t>(CowStr<'t>); 38 38 + #[repr(transparent)] 39 39 + pub struct Tid(SmolStr); 37 40 38 38 - impl<'t> Tid<'t> { 41 41 + impl Tid { 39 42 /// Parses a `TID` from the given string. 40 40 - pub fn new(tid: &'t str) -> Result<Self, &'static str> { 41 41 - if tid.len() != 13 { 42 42 - Err("TID must be 13 characters") 43 43 - } else if !TID_REGEX.is_match(&tid) { 44 44 - Err("Invalid TID") 45 45 - } else { 46 46 - Ok(Self(CowStr::Owned(tid.to_compact_string()))) 47 47 - } 48 48 - } 49 49 - 50 50 - /// Fallible constructor from an existing CowStr, takes ownership 51 51 - pub fn from_cowstr(tid: CowStr<'t>) -> Result<Tid<'t>, &'static str> { 43 43 + pub fn new(tid: impl AsRef<str>) -> Result<Self, &'static str> { 44 44 + let tid = tid.as_ref(); 52 45 if tid.len() != 13 { 53 46 Err("TID must be 13 characters") 54 54 - } else if !TID_REGEX.is_match(&tid) { 47 47 + } else if !TID_REGEX.is_match(&tid.as_ref()) { 55 48 Err("Invalid TID") 56 49 } else { 57 57 - Ok(Self(tid.into_static())) 50 50 + Ok(Self(SmolStr::new_inline(&tid))) 58 51 } 59 52 } 60 53 ··· 62 55 /// Will panic on invalid TID. If you're manually decoding atproto records 63 56 /// or API values you know are valid (rather than using serde), this is the one to use. 64 57 /// The From<String> and From<CowStr> impls use the same logic. 65 65 - pub fn raw(tid: &'t str) -> Self { 58 58 + pub fn raw(tid: impl AsRef<str>) -> Self { 59 59 + let tid = tid.as_ref(); 66 60 if tid.len() != 13 { 67 61 panic!("TID must be 13 characters") 68 62 } else if !TID_REGEX.is_match(&tid) { 69 63 panic!("Invalid TID") 70 64 } else { 71 71 - Self(CowStr::Borrowed(tid)) 65 65 + Self(SmolStr::new_inline(tid)) 72 66 } 73 67 } 74 68 75 69 /// Infallible constructor for when you *know* the string is a valid TID. 76 70 /// Marked unsafe because responsibility for upholding the invariant is on the developer. 77 77 - pub unsafe fn unchecked(tid: &'t str) -> Self { 78 78 - Self(CowStr::Borrowed(tid)) 71 71 + pub unsafe fn unchecked(tid: impl AsRef<str>) -> Self { 72 72 + let tid = tid.as_ref(); 73 73 + Self(SmolStr::new_inline(tid)) 79 74 } 80 75 81 76 /// Construct a new timestamp with the specified clock ID. ··· 121 116 } 122 117 } 123 118 124 124 - impl FromStr for Tid<'_> { 119 119 + impl FromStr for Tid { 125 120 type Err = &'static str; 126 121 127 122 /// Has to take ownership due to the lifetime constraints of the FromStr trait. 128 123 /// Prefer `Did::new()` or `Did::raw` if you want to borrow. 129 124 fn from_str(s: &str) -> Result<Self, Self::Err> { 130 130 - Self::from_cowstr(CowStr::Borrowed(s).into_static()) 125 125 + Self::new(s) 131 126 } 132 127 } 133 128 134 134 - impl<'de> Deserialize<'de> for Tid<'de> { 129 129 + impl<'de> Deserialize<'de> for Tid { 135 130 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 136 131 where 137 132 D: Deserializer<'de>, 138 133 { 139 139 - let value = Deserialize::deserialize(deserializer)?; 134 134 + let value: &str = Deserialize::deserialize(deserializer)?; 140 135 Self::new(value).map_err(D::Error::custom) 141 136 } 142 137 } 143 138 144 144 - impl fmt::Display for Tid<'_> { 139 139 + impl fmt::Display for Tid { 145 140 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 146 141 f.write_str(&self.0) 147 142 } 148 143 } 149 144 150 150 - impl<'t> From<Tid<'t>> for String { 151 151 - fn from(value: Tid<'t>) -> Self { 145 145 + impl From<Tid> for String { 146 146 + fn from(value: Tid) -> Self { 152 147 value.0.to_string() 153 148 } 154 149 } 155 150 156 156 - impl<'t> From<Tid<'t>> for CowStr<'t> { 157 157 - fn from(value: Tid<'t>) -> Self { 151 151 + impl From<Tid> for SmolStr { 152 152 + fn from(value: Tid) -> Self { 158 153 value.0 159 154 } 160 155 } 161 156 162 162 - impl From<String> for Tid<'static> { 157 157 + impl From<String> for Tid { 163 158 fn from(value: String) -> Self { 164 159 if value.len() != 13 { 165 160 panic!("TID must be 13 characters") 166 161 } else if !TID_REGEX.is_match(&value) { 167 162 panic!("Invalid TID") 168 163 } else { 169 169 - Self(CowStr::Owned(value.to_compact_string())) 164 164 + Self(SmolStr::new_inline(&value)) 170 165 } 171 166 } 172 167 } 173 168 174 174 - impl<'t> From<CowStr<'t>> for Tid<'t> { 169 169 + impl<'t> From<CowStr<'t>> for Tid { 175 170 fn from(value: CowStr<'t>) -> Self { 176 171 if value.len() != 13 { 177 172 panic!("TID must be 13 characters") 178 173 } else if !TID_REGEX.is_match(&value) { 179 174 panic!("Invalid TID") 180 175 } else { 181 181 - Self(value) 176 176 + Self(SmolStr::new_inline(&value)) 182 177 } 183 178 } 184 179 } 185 180 186 186 - impl AsRef<str> for Tid<'_> { 181 181 + impl AsRef<str> for Tid { 187 182 fn as_ref(&self) -> &str { 188 183 self.as_str() 189 184 } 190 185 } 191 186 192 192 - impl Deref for Tid<'_> { 187 187 + impl Deref for Tid { 193 188 type Target = str; 194 189 195 190 fn deref(&self) -> &Self::Target {