modified vendored cache impl

Cargo.lock

···
 
 [[package]]
 name = "jacquard"
-version = "0.9.3"
+version = "0.9.4"
 dependencies = [
  "bytes",
  "clap",
···
 
 [[package]]
 name = "jacquard-derive"
-version = "0.9.3"
+version = "0.9.4"
 dependencies = [
  "heck 0.5.0",
  "inventory",
···
 
 [[package]]
 name = "jacquard-lexgen"
-version = "0.9.3"
+version = "0.9.4"
 dependencies = [
  "clap",
  "clap_complete",
···
 
 [[package]]
 name = "jacquard-repo"
-version = "0.9.3"
+version = "0.9.4"
 dependencies = [
  "anyhow",
  "bytes",

crates/jacquard-identity/src/lib.rs

···
 use {
     crate::lexicon_resolver::ResolvedLexiconSchema,
     jacquard_common::{smol_str::SmolStr, types::string::Nsid},
-    std::time::Duration,
+    mini_moka::time::Duration,
 };
 
 #[cfg(all(
···
 use std::sync::Arc;
 
 // Platform-specific cache implementations
-#[cfg(all(feature = "cache", not(target_arch = "wasm32")))]
+//#[cfg(all(feature = "cache", not(target_arch = "wasm32")))]
+#[cfg(feature = "cache")]
 mod cache_impl {
     /// Native: Use sync cache (thread-safe, no mutex needed)
     pub type Cache<K, V> = mini_moka::sync::Cache<K, V>;
···
     }
 }
 
-#[cfg(all(feature = "cache", target_arch = "wasm32"))]
-mod cache_impl {
-    use std::sync::{Arc, Mutex};
+// #[cfg(all(feature = "cache", target_arch = "wasm32"))]
+// mod cache_impl {
+//     use std::sync::{Arc, Mutex};
 
-    /// WASM: Use unsync cache in Arc<Mutex<_>> (no threads, but need interior mutability)
-    pub type Cache<K, V> = Arc<Mutex<mini_moka::unsync::Cache<K, V>>>;
+//     /// WASM: Use unsync cache in Arc<Mutex<_>> (no threads, but need interior mutability)
+//     pub type Cache<K, V> = Arc<Mutex<mini_moka::unsync::Cache<K, V>>>;
 
-    pub fn new_cache<K, V>(max_capacity: u64, ttl: std::time::Duration) -> Cache<K, V>
-    where
-        K: std::hash::Hash + Eq + 'static,
-        V: Clone + 'static,
-    {
-        Arc::new(Mutex::new(
-            mini_moka::unsync::Cache::builder()
-                .max_capacity(max_capacity)
-                .time_to_idle(ttl)
-                .build(),
-        ))
-    }
+//     pub fn new_cache<K, V>(max_capacity: u64, ttl: std::time::Duration) -> Cache<K, V>
+//     where
+//         K: std::hash::Hash + Eq + 'static,
+//         V: Clone + 'static,
+//     {
+//         Arc::new(Mutex::new(
+//             mini_moka::unsync::Cache::builder()
+//                 .max_capacity(max_capacity)
+//                 .time_to_idle(ttl)
+//                 .build(),
+//         ))
+//     }
 
-    pub fn get<K, V>(cache: &Cache<K, V>, key: &K) -> Option<V>
-    where
-        K: std::hash::Hash + Eq + 'static,
-        V: Clone + 'static,
-    {
-        cache.lock().unwrap().get(key).cloned()
-    }
+//     pub fn get<K, V>(cache: &Cache<K, V>, key: &K) -> Option<V>
+//     where
+//         K: std::hash::Hash + Eq + 'static,
+//         V: Clone + 'static,
+//     {
+//         cache.lock().unwrap().get(key).cloned()
+//     }
 
-    pub fn insert<K, V>(cache: &Cache<K, V>, key: K, value: V)
-    where
-        K: std::hash::Hash + Eq + 'static,
-        V: Clone + 'static,
-    {
-        cache.lock().unwrap().insert(key, value);
-    }
+//     pub fn insert<K, V>(cache: &Cache<K, V>, key: K, value: V)
+//     where
+//         K: std::hash::Hash + Eq + 'static,
+//         V: Clone + 'static,
+//     {
+//         cache.lock().unwrap().insert(key, value);
+//     }
 
-    pub fn invalidate<K, V>(cache: &Cache<K, V>, key: &K)
-    where
-        K: std::hash::Hash + Eq + 'static,
-        V: Clone + 'static,
-    {
-        cache.lock().unwrap().invalidate(key);
-    }
-}
+//     pub fn invalidate<K, V>(cache: &Cache<K, V>, key: &K)
+//     where
+//         K: std::hash::Hash + Eq + 'static,
+//         V: Clone + 'static,
+//     {
+//         cache.lock().unwrap().invalidate(key);
+//     }
+// }
 
 /// Configuration for resolver caching
 #[cfg(feature = "cache")]

crates/jacquard-oauth/src/resolver.rs

···
 use http::{Request, StatusCode};
 use jacquard_common::CowStr;
 use jacquard_common::IntoStatic;
+use jacquard_common::cowstr::ToCowStr;
 use jacquard_common::types::did_doc::DidDocument;
 use jacquard_common::types::ident::AtIdentifier;
 use jacquard_common::{http_client::HttpClient, types::did::Did};

crates/mini-moka-vendored/src/common.rs

···
 pub(crate) mod builder_utils;
 pub(crate) mod deque;
 pub(crate) mod frequency_sketch;
-pub(crate) mod time;
+pub mod time;
 
 // Note: `CacheRegion` cannot have more than four enum variants. This is because
 // `crate::{sync,unsync}::DeqNodes` uses a `tagptr::TagNonNull<DeqNode<T>, 2>`

crates/mini-moka-vendored/src/common/concurrent/housekeeper.rs

···
     },
 };
 
-use crate::common::time::{CheckedTimeOps, Instant};
+use crate::common::time::{CheckedTimeOps, Duration, Instant};
 
-use std::{
-    sync::atomic::{AtomicBool, Ordering},
-    time::Duration,
-};
+use std::sync::atomic::{AtomicBool, Ordering};
 
 pub(crate) trait InnerSync {
     fn sync(&self, max_sync_repeats: usize);

crates/mini-moka-vendored/src/common/time.rs

···
-use std::time::Duration;
+#[cfg(not(feature = "js"))]
+pub type Duration = std::time::Duration;
+
+#[cfg(feature = "js")]
+pub type Duration = web_time::Duration;
 
 pub(crate) mod clock;
 

crates/mini-moka-vendored/src/lib.rs

···
 #[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
 pub mod sync;
 
+pub use common::time;
+
 pub use policy::Policy;
 
 #[cfg(test)]

crates/mini-moka-vendored/src/sync/base_cache.rs

···
         },
         deque::{DeqNode, Deque},
         frequency_sketch::FrequencySketch,
-        time::{CheckedTimeOps, Clock, Instant},
+        time::{CheckedTimeOps, Clock, Duration, Instant},
         CacheRegion,
     },
     Policy,
···
         atomic::{AtomicBool, Ordering},
         Arc, Mutex, RwLock,
     },
-    time::Duration,
 };
 use triomphe::Arc as TrioArc;
 

crates/mini-moka-vendored/src/sync/builder.rs

···
 use super::Cache;
-use crate::{common::builder_utils, common::concurrent::Weigher};
+use crate::{common::builder_utils, common::concurrent::Weigher, common::time::Duration};
 
 use std::{
     collections::hash_map::RandomState,
     hash::{BuildHasher, Hash},
     marker::PhantomData,
     sync::Arc,
-    time::Duration,
 };
 
 /// Builds a [`Cache`][cache-struct] or with various configuration knobs.

crates/mini-moka-vendored/src/sync/cache.rs

···
             housekeeper::{Housekeeper, InnerSync},
             Weigher, WriteOp,
         },
+        time::Duration,
         time::Instant,
     },
     Policy,
···
     fmt,
     hash::{BuildHasher, Hash},
     sync::Arc,
-    time::Duration,
 };
 
 /// A thread-safe concurrent in-memory cache built upon [`dashmap::DashMap`][dashmap].

examples/app_password_create_post.rs

···
     let args = Args::parse();
 
     let (session, auth) =
-        MemoryCredentialSession::authenticated(args.input, args.password, None).await?;
+        MemoryCredentialSession::authenticated(args.input, args.password, None, None).await?;
     println!("Signed in as {}", auth.handle);
 
     let agent: Agent<_> = Agent::from(session);