cached resolver

Cargo.lock

···
 ]
 
 [[package]]
+name = "async-lock"
+version = "3.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd03604047cee9b6ce9de9f70c6cd540a0520c813cbd49bae61f33ab80ed1dc"
+dependencies = [
+ "event-listener",
+ "event-listener-strategy",
+ "pin-project-lite",
+]
+
+[[package]]
 name = "async-trait"
 version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "e47641d3deaf41fb1538ac1f54735925e275eaf3bf4d55c81b137fba797e5cbb"
 
 [[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
 name = "console"
 version = "0.15.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
  "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "event-listener"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+dependencies = [
+ "event-listener",
+ "pin-project-lite",
+]
+
+[[package]]
 name = "expect-json"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "jacquard-common",
  "jacquard-lexicon",
  "miette",
+ "moka",
  "n0-future",
  "percent-encoding",
  "reqwest",
···
 ]
 
 [[package]]
+name = "moka"
+version = "0.12.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8261cd88c312e0004c1d51baad2980c66528dfdb2bee62003e643a4d8f86b077"
+dependencies = [
+ "async-lock",
+ "crossbeam-channel",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "equivalent",
+ "event-listener",
+ "futures-util",
+ "parking_lot",
+ "portable-atomic",
+ "rustc_version",
+ "smallvec",
+ "tagptr",
+ "uuid",
+]
+
+[[package]]
 name = "moxcms"
 version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "flate2",
  "miniz_oxide 0.8.9",
 ]
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
 
 [[package]]
 name = "potential_utf"
···
 ]
 
 [[package]]
+name = "tagptr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
+
+[[package]]
 name = "target-lexicon"
 version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
 dependencies = [
+ "getrandom 0.3.4",
  "js-sys",
  "wasm-bindgen",
 ]

Cargo.toml

···
 ipld-core = { version = "0.4.2", features = ["serde"] }
 multihash = "0.19"
 dashmap = "6.1"
+moka = "0.12"
 
 # Proc macros
 proc-macro2 = "1.0"

crates/jacquard-identity/Cargo.toml

···
 dns = ["dep:hickory-resolver"]
 tracing = ["dep:tracing"]
 streaming = ["jacquard-common/streaming", "dep:n0-future"]
+cache = ["dep:moka"]
 
 [dependencies]
 trait-variant.workspace = true
···
 urlencoding.workspace = true
 tracing = { workspace = true, optional = true }
 n0-future = { workspace = true, optional = true }
+moka = { workspace = true, features = ["future"], optional = true }
 
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
 hickory-resolver = { optional = true, version = "0.24", default-features = false, features = ["system-config", "tokio-runtime"]}

crates/jacquard-identity/src/lexicon_resolver.rs

···
 
 use crate::resolver::{IdentityError, IdentityResolver};
 use jacquard_common::{
-    IntoStatic, smol_str,
+    smol_str,
     types::{cid::Cid, did::Did, string::Nsid},
 };
 use smol_str::SmolStr;
···
             for data in txt.txt_data().iter() {
                 let text = std::str::from_utf8(data).unwrap_or("");
                 if let Some(did_str) = text.strip_prefix("did=") {
+                    use jacquard_common::IntoStatic;
+
                     return Did::new_owned(did_str)
                         .map(|d| d.into_static())
                         .map_err(|_| LexiconResolutionError::invalid_did(authority, did_str));
···
         &self,
         nsid: &Nsid<'_>,
     ) -> std::result::Result<Did<'static>, LexiconResolutionError> {
-        self.resolve_lexicon_authority_dns(nsid).await
+        // Try cache first
+        #[cfg(feature = "cache")]
+        if let Some(caches) = &self.caches {
+            let authority = jacquard_common::smol_str::SmolStr::from(nsid.domain_authority());
+            if let Some(did) = caches.authority_to_did.get(&authority).await {
+                return Ok(did);
+            }
+        }
+
+        // Resolve via DNS
+        let result = self.resolve_lexicon_authority_dns(nsid).await;
+
+        // Cache on success, invalidate on error
+        match &result {
+            Ok(did) =>
+            {
+                #[cfg(feature = "cache")]
+                if let Some(caches) = &self.caches {
+                    let authority =
+                        jacquard_common::smol_str::SmolStr::from(nsid.domain_authority());
+                    caches.authority_to_did.insert(authority, did.clone()).await;
+                }
+            }
+            Err(_) => {
+                #[cfg(feature = "cache")]
+                self.invalidate_authority_chain(nsid.domain_authority())
+                    .await;
+            }
+        }
+
+        result
     }
 }
 
···
         use jacquard_api::com_atproto::repo::get_record::GetRecord;
         use jacquard_common::{IntoStatic, xrpc::XrpcExt};
 
-        // 1. Resolve authority DID via DNS
-        let authority_did = self.resolve_lexicon_authority(nsid).await?;
+        // Try cache first
+        #[cfg(feature = "cache")]
+        if let Some(caches) = &self.caches {
+            let key = nsid.clone().into_static();
+            if let Some(schema) = caches.nsid_to_schema.get(&key).await {
+                return Ok((*schema).clone());
+            }
+        }
 
-        #[cfg(feature = "tracing")]
-        tracing::debug!(
-            "resolved lexicon authority {} -> {}",
-            nsid.domain_authority(),
-            authority_did
-        );
+        // Perform resolution
+        let result = async {
+            // 1. Resolve authority DID via DNS
+            let authority_did = self.resolve_lexicon_authority(nsid).await?;
 
-        // 2. Resolve DID document to get PDS endpoint
-        let did_doc_resp = self.resolve_did_doc(&authority_did).await?;
-        let did_doc = did_doc_resp.parse()?;
-        let pds = did_doc
-            .pds_endpoint()
-            .ok_or_else(|| IdentityError::missing_pds_endpoint())?;
+            #[cfg(feature = "tracing")]
+            tracing::debug!(
+                "resolved lexicon authority {} -> {}",
+                nsid.domain_authority(),
+                authority_did
+            );
 
-        #[cfg(feature = "tracing")]
-        tracing::debug!("fetching lexicon {} from PDS {}", nsid, pds);
+            // 2. Resolve DID document to get PDS endpoint
+            let did_doc_resp = self.resolve_did_doc(&authority_did).await?;
+            let did_doc = did_doc_resp.parse()?;
+            let pds = did_doc
+                .pds_endpoint()
+                .ok_or_else(|| IdentityError::missing_pds_endpoint())?;
 
-        // 3. Fetch lexicon record via XRPC getRecord
-        let collection = Nsid::new("com.atproto.lexicon.schema")
-            .map_err(|_| LexiconResolutionError::invalid_collection())?;
+            #[cfg(feature = "tracing")]
+            tracing::debug!("fetching lexicon {} from PDS {}", nsid, pds);
 
-        let request = GetRecord::new()
-            .repo(authority_did.clone())
-            .collection(collection.into_static())
-            .rkey(nsid.clone())
-            .build();
+            // 3. Fetch lexicon record via XRPC getRecord
+            let collection = Nsid::new("com.atproto.lexicon.schema")
+                .map_err(|_| LexiconResolutionError::invalid_collection())?;
 
-        let response = self
-            .xrpc(pds)
-            .send(&request)
-            .await
-            .map_err(|e| LexiconResolutionError::fetch_failed(nsid.as_str(), e))?;
+            let request = GetRecord::new()
+                .repo(authority_did.clone())
+                .collection(collection.into_static())
+                .rkey(nsid.clone())
+                .build();
 
-        let output = response
-            .into_output()
-            .map_err(|e| LexiconResolutionError::fetch_failed(nsid.as_str(), e))?;
+            let response = self
+                .xrpc(pds)
+                .send(&request)
+                .await
+                .map_err(|e| LexiconResolutionError::fetch_failed(nsid.as_str(), e))?;
 
-        // 4. Parse lexicon document from value
-        let json_str = serde_json::to_string(&output.value)
-            .map_err(|e| LexiconResolutionError::parse_failed(nsid.as_str(), e))?;
+            let output = response
+                .into_output()
+                .map_err(|e| LexiconResolutionError::fetch_failed(nsid.as_str(), e))?;
+
+            // 4. Parse lexicon document from value
+            let json_str = serde_json::to_string(&output.value)
+                .map_err(|e| LexiconResolutionError::parse_failed(nsid.as_str(), e))?;
+
+            let doc: jacquard_lexicon::lexicon::LexiconDoc = serde_json::from_str(&json_str)
+                .map_err(|e| LexiconResolutionError::parse_failed(nsid.as_str(), e))?;
 
-        let doc: jacquard_lexicon::lexicon::LexiconDoc = serde_json::from_str(&json_str)
-            .map_err(|e| LexiconResolutionError::parse_failed(nsid.as_str(), e))?;
+            #[cfg(feature = "tracing")]
+            tracing::debug!("successfully parsed lexicon schema {}", nsid);
 
-        #[cfg(feature = "tracing")]
-        tracing::debug!("successfully parsed lexicon schema {}", nsid);
+            let cid = output
+                .cid
+                .ok_or_else(|| LexiconResolutionError::missing_cid(nsid.as_str()))?
+                .into_static();
 
-        let cid = output
-            .cid
-            .ok_or_else(|| LexiconResolutionError::missing_cid(nsid.as_str()))?
-            .into_static();
+            Ok(ResolvedLexiconSchema {
+                nsid: nsid.clone().into_static(),
+                repo: authority_did.into_static(),
+                cid,
+                doc: doc.into_static(),
+            })
+        }
+        .await;
 
-        Ok(ResolvedLexiconSchema {
-            nsid: nsid.clone().into_static(),
-            repo: authority_did.into_static(),
-            cid,
-            doc: doc.into_static(),
-        })
+        // Handle result
+        match result {
+            Ok(schema) => {
+                // Cache successful resolution
+                #[cfg(feature = "cache")]
+                if let Some(caches) = &self.caches {
+                    caches
+                        .nsid_to_schema
+                        .insert(nsid.clone().into_static(), std::sync::Arc::new(schema.clone()))
+                        .await;
+                }
+                Ok(schema)
+            }
+            Err(e) => {
+                // Invalidate on error
+                #[cfg(feature = "cache")]
+                self.invalidate_lexicon_chain(nsid).await;
+                Err(e)
+            }
+        }
     }
 }

crates/jacquard-identity/src/lib.rs

···
     std::sync::Arc,
 };
 
+#[cfg(feature = "cache")]
+use {
+    crate::lexicon_resolver::ResolvedLexiconSchema,
+    jacquard_common::{smol_str::SmolStr, types::string::Nsid},
+    moka::future::Cache,
+    std::time::Duration,
+};
+
+#[cfg(all(
+    feature = "cache",
+    not(all(feature = "dns", not(target_family = "wasm")))
+))]
+use std::sync::Arc;
+
+/// Cache layer for resolver operations
+#[cfg(feature = "cache")]
+#[derive(Clone)]
+struct ResolverCaches {
+    handle_to_did: Cache<Handle<'static>, Did<'static>>,
+    did_to_doc: Cache<Did<'static>, Arc<DidDocResponse>>,
+    authority_to_did: Cache<SmolStr, Did<'static>>,
+    nsid_to_schema: Cache<Nsid<'static>, Arc<ResolvedLexiconSchema<'static>>>,
+}
+
+#[cfg(feature = "cache")]
+impl ResolverCaches {
+    fn new() -> Self {
+        Self {
+            handle_to_did: Cache::builder()
+                .max_capacity(2000)
+                .time_to_live(Duration::from_secs(24 * 3600))
+                .build(),
+            did_to_doc: Cache::builder()
+                .max_capacity(1000)
+                .time_to_live(Duration::from_secs(72 * 3600))
+                .build(),
+            authority_to_did: Cache::builder()
+                .max_capacity(200)
+                .time_to_live(Duration::from_secs(168 * 3600))
+                .build(),
+            nsid_to_schema: Cache::builder()
+                .max_capacity(500)
+                .time_to_live(Duration::from_secs(168 * 3600))
+                .build(),
+        }
+    }
+}
+
 /// Default resolver implementation with configurable fallback order.
 #[derive(Clone)]
 pub struct JacquardResolver {
···
     opts: ResolverOptions,
     #[cfg(feature = "dns")]
     dns: Option<Arc<TokioAsyncResolver>>,
+    #[cfg(feature = "cache")]
+    caches: Option<ResolverCaches>,
 }
 
 impl JacquardResolver {
···
             opts,
             #[cfg(feature = "dns")]
             dns: None,
+            #[cfg(feature = "cache")]
+            caches: None,
         }
     }
 
···
                 ResolverConfig::default(),
                 Default::default(),
             ))),
+            #[cfg(feature = "cache")]
+            caches: None,
         }
     }
 
···
     /// Enable/disable doc id validation
     pub fn with_validate_doc_id(mut self, enable: bool) -> Self {
         self.opts.validate_doc_id = enable;
+        self
+    }
+
+    #[cfg(feature = "cache")]
+    /// Enable caching with default configuration
+    pub fn with_cache(mut self) -> Self {
+        self.caches = Some(ResolverCaches::new());
         self
     }
 
···
     }
     #[cfg_attr(feature = "tracing", tracing::instrument(level = "debug", skip(self), fields(handle = %handle)))]
     async fn resolve_handle(&self, handle: &Handle<'_>) -> resolver::Result<Did<'static>> {
+        // Try cache first
+        #[cfg(feature = "cache")]
+        if let Some(caches) = &self.caches {
+            let key = handle.clone().into_static();
+            if let Some(did) = caches.handle_to_did.get(&key).await {
+                return Ok(did);
+            }
+        }
+
         let host = handle.as_str();
-        for step in &self.opts.handle_order {
+        let mut resolved_did: Option<Did<'static>> = None;
+
+        'outer: for step in &self.opts.handle_order {
             match step {
                 HandleStep::DnsTxt => {
                     #[cfg(feature = "dns")]
···
                             for txt in txts {
                                 if let Some(did_str) = txt.strip_prefix("did=") {
                                     if let Ok(did) = Did::new(did_str) {
-                                        return Ok(did.into_static());
+                                        resolved_did = Some(did.into_static());
+                                        break 'outer;
                                     }
                                 }
                             }
···
                     let url = Url::parse(&format!("https://{host}/.well-known/atproto-did"))?;
                     if let Ok(text) = self.get_text(url).await {
                         if let Ok(did) = Self::parse_atproto_did_body(&text) {
-                            return Ok(did);
+                            resolved_did = Some(did);
+                            break 'outer;
                         }
                     }
                 }
                 HandleStep::PdsResolveHandle => {
                     // Prefer PDS XRPC via stateless client
                     if let Ok(did) = self.resolve_handle_via_pds(handle).await {
-                        return Ok(did);
+                        resolved_did = Some(did);
+                        break 'outer;
                     }
                     // Public unauth fallback
                     if self.opts.public_fallback_for_handle {
···
                                             val.get("did").and_then(|v| v.as_str())
                                         {
                                             if let Ok(did) = Did::new_owned(did_str) {
-                                                return Ok(did.into_static());
+                                                resolved_did = Some(did.into_static());
+                                                break 'outer;
                                             }
                                         }
                                     }
···
                                 if let Ok(val) = serde_json::from_slice::<serde_json::Value>(&buf) {
                                     if let Some(did_str) = val.get("did").and_then(|v| v.as_str()) {
                                         if let Ok(did) = Did::new_owned(did_str) {
-                                            return Ok(did.into_static());
+                                            resolved_did = Some(did.into_static());
+                                            break 'outer;
                                         }
                                     }
                                 }
···
                 }
             }
         }
-        Err(IdentityError::invalid_well_known())
+
+        // Handle result
+        if let Some(did) = resolved_did {
+            // Cache successful resolution
+            #[cfg(feature = "cache")]
+            if let Some(caches) = &self.caches {
+                caches
+                    .handle_to_did
+                    .insert(handle.clone().into_static(), did.clone())
+                    .await;
+            }
+            Ok(did)
+        } else {
+            // Invalidate on error
+            #[cfg(feature = "cache")]
+            self.invalidate_handle_chain(handle).await;
+            Err(IdentityError::invalid_well_known())
+        }
     }
 
     #[cfg_attr(feature = "tracing", tracing::instrument(level = "debug", skip(self), fields(did = %did)))]
     async fn resolve_did_doc(&self, did: &Did<'_>) -> resolver::Result<DidDocResponse> {
+        // Try cache first
+        #[cfg(feature = "cache")]
+        if let Some(caches) = &self.caches {
+            let key = did.clone().into_static();
+            if let Some(doc_resp) = caches.did_to_doc.get(&key).await {
+                return Ok((*doc_resp).clone());
+            }
+        }
+
         let s = did.as_str();
-        for step in &self.opts.did_order {
+        let mut resolved_doc: Option<DidDocResponse> = None;
+
+        'outer: for step in &self.opts.did_order {
             match step {
                 DidStep::DidWebHttps if s.starts_with("did:web:") => {
                     let url = self.did_web_url(did)?;
                     if let Ok((buf, status)) = self.get_json_bytes(url).await {
-                        return Ok(DidDocResponse {
+                        resolved_doc = Some(DidDocResponse {
                             buffer: buf,
                             status,
                             requested: Some(did.clone().into_static()),
                         });
+                        break 'outer;
                     }
                 }
                 DidStep::PlcHttp if s.starts_with("did:plc:") => {
···
                         PlcSource::Slingshot { base } => base.join(did.as_str())?,
                     };
                     if let Ok((buf, status)) = self.get_json_bytes(url).await {
-                        return Ok(DidDocResponse {
+                        resolved_doc = Some(DidDocResponse {
                             buffer: buf,
                             status,
                             requested: Some(did.clone().into_static()),
                         });
+                        break 'outer;
                     }
                 }
                 DidStep::PdsResolveDid => {
                     // Try PDS XRPC for full DID doc
                     if let Ok(doc) = self.fetch_did_doc_via_pds_owned(did).await {
                         let buf = serde_json::to_vec(&doc).unwrap_or_default();
-                        return Ok(DidDocResponse {
+                        resolved_doc = Some(DidDocResponse {
                             buffer: Bytes::from(buf),
                             status: StatusCode::OK,
                             requested: Some(did.clone().into_static()),
                         });
+                        break 'outer;
                     }
                     // Fallback: if Slingshot configured, return mini-doc response (partial doc)
                     if let PlcSource::Slingshot { base } = &self.opts.plc_source {
                         let url = self.slingshot_mini_doc_url(base, did.as_str())?;
                         let (buf, status) = self.get_json_bytes(url).await?;
-                        return Ok(DidDocResponse {
+                        resolved_doc = Some(DidDocResponse {
                             buffer: buf,
                             status,
                             requested: Some(did.clone().into_static()),
                         });
+                        break 'outer;
                     }
                 }
                 _ => {}
             }
         }
-        Err(IdentityError::unsupported_did_method(s))
+
+        // Handle result
+        if let Some(doc_resp) = resolved_doc {
+            // Cache successful resolution
+            #[cfg(feature = "cache")]
+            if let Some(caches) = &self.caches {
+                caches
+                    .did_to_doc
+                    .insert(did.clone().into_static(), Arc::new(doc_resp.clone()))
+                    .await;
+            }
+            Ok(doc_resp)
+        } else {
+            // Invalidate on error
+            #[cfg(feature = "cache")]
+            self.invalidate_did_chain(did).await;
+            Err(IdentityError::unsupported_did_method(s))
+        }
     }
 }
 
···
             urlencoding::Encoded::new(identifier)
         )));
         Ok(url)
+    }
+
+    #[cfg(feature = "cache")]
+    async fn invalidate_handle_chain(&self, handle: &Handle<'_>) {
+        if let Some(caches) = &self.caches {
+            let key = handle.clone().into_static();
+            caches.handle_to_did.invalidate(&key).await;
+        }
+    }
+
+    #[cfg(feature = "cache")]
+    async fn invalidate_did_chain(&self, did: &Did<'_>) {
+        if let Some(caches) = &self.caches {
+            let did_key = did.clone().into_static();
+            // Get doc before evicting to extract handles
+            if let Some(doc_resp) = caches.did_to_doc.get(&did_key).await {
+                let doc_resp_clone = (*doc_resp).clone();
+                if let Ok(doc) = doc_resp_clone.parse() {
+                    if let Some(aliases) = &doc.also_known_as {
+                        for alias in aliases {
+                            if let Some(handle_str) = alias.as_ref().strip_prefix("at://") {
+                                if let Ok(handle) = Handle::new(handle_str) {
+                                    let handle_key = handle.into_static();
+                                    caches.handle_to_did.invalidate(&handle_key).await;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            caches.did_to_doc.invalidate(&did_key).await;
+        }
+    }
+
+    #[cfg(feature = "cache")]
+    async fn invalidate_authority_chain(&self, authority: &str) {
+        if let Some(caches) = &self.caches {
+            let authority = SmolStr::from(authority);
+            caches.authority_to_did.invalidate(&authority).await;
+        }
+    }
+
+    #[cfg(feature = "cache")]
+    async fn invalidate_lexicon_chain(&self, nsid: &jacquard_common::types::string::Nsid<'_>) {
+        if let Some(caches) = &self.caches {
+            let nsid_key = nsid.clone().into_static();
+            if let Some(schema) = caches.nsid_to_schema.get(&nsid_key).await {
+                let authority = SmolStr::from(nsid.domain_authority());
+                caches.authority_to_did.invalidate(&authority).await;
+                self.invalidate_did_chain(&schema.repo).await;
+            }
+            caches.nsid_to_schema.invalidate(&nsid_key).await;
+        }
     }
 
     /// Fetch a minimal DID document via Slingshot's mini-doc endpoint using a generic at-identifier