Improvements based on feedback

1. Remove `new` from trait, it made no sense, added a function to modify the
   ttl and tti instead
2. Removed `unwrap` and add logs instead

crates/cdk-axum/src/cache/backend/memory.rs

@@ -2,7 +2,7 @@ use std::time::Duration;
 
 use moka::future::Cache;
 
-use crate::cache::{HttpCacheKey, HttpCacheStorage};
+use crate::cache::{HttpCacheKey, HttpCacheStorage, DEFAULT_TTI_SECS, DEFAULT_TTL_SECS};
 
 /// In memory cache storage for the HTTP cache.
 ///
@@ -13,20 +13,27 @@ use crate::cache::{HttpCacheKey, HttpCacheStorage};
 /// instances nor persisted.
 pub struct InMemoryHttpCache(pub Cache<HttpCacheKey, Vec<u8>>);
 
-#[async_trait::async_trait]
-impl HttpCacheStorage for InMemoryHttpCache {
-    fn new(cache_ttl: Duration, cache_tti: Duration) -> Self
-    where
-        Self: Sized,
-    {
+impl Default for InMemoryHttpCache {
+    fn default() -> Self {
         InMemoryHttpCache(
             Cache::builder()
                 .max_capacity(10_000)
-                .time_to_live(cache_ttl)
-                .time_to_idle(cache_tti)
+                .time_to_live(Duration::from_secs(DEFAULT_TTL_SECS))
+                .time_to_idle(Duration::from_secs(DEFAULT_TTI_SECS))
                 .build(),
         )
     }
+}
+
+#[async_trait::async_trait]
+impl HttpCacheStorage for InMemoryHttpCache {
+    fn set_expiration_times(&mut self, cache_ttl: Duration, cache_tti: Duration) {
+        self.0 = Cache::builder()
+            .max_capacity(10_000)
+            .time_to_live(cache_ttl)
+            .time_to_idle(cache_tti)
+            .build();
+    }
 
     async fn get(&self, key: &HttpCacheKey) -> Option<Vec<u8>> {
         self.0.get(key)

crates/cdk-axum/src/cache/backend/redis.rs

@@ -11,7 +11,7 @@ use crate::cache::{HttpCacheKey, HttpCacheStorage};
 pub struct HttpCacheRedis {
     cache_ttl: Duration,
     prefix: Option<Vec<u8>>,
-    client: Option<redis::Client>,
+    client: redis::Client,
 }
 
 /// Configuration for the Redis cache storage.
@@ -26,9 +26,12 @@ pub struct Config {
 
 impl HttpCacheRedis {
     /// Create a new Redis cache.
-    pub fn set_client(mut self, client: redis::Client) -> Self {
-        self.client = Some(client);
-        self
+    pub fn new(client: redis::Client) -> Self {
+        Self {
+            client,
+            prefix: None,
+            cache_ttl: Duration::from_secs(60),
+        }
     }
 
     /// Set a prefix for the cache keys.
@@ -43,22 +46,12 @@ impl HttpCacheRedis {
 
 #[async_trait::async_trait]
 impl HttpCacheStorage for HttpCacheRedis {
-    fn new(cache_ttl: Duration, _cache_tti: Duration) -> Self {
-        Self {
-            cache_ttl,
-            prefix: None,
-            client: None,
-        }
+    fn set_expiration_times(&mut self, cache_ttl: Duration, _cache_tti: Duration) {
+        self.cache_ttl = cache_ttl;
     }
 
     async fn get(&self, key: &HttpCacheKey) -> Option<Vec<u8>> {
-        let mut con = match self
-            .client
-            .as_ref()
-            .expect("A client must be set with set_client()")
-            .get_multiplexed_tokio_connection()
-            .await
-        {
+        let mut con = match self.client.get_multiplexed_tokio_connection().await {
             Ok(con) => con,
             Err(err) => {
                 tracing::error!("Failed to get redis connection: {:?}", err);
@@ -82,13 +75,7 @@ impl HttpCacheStorage for HttpCacheRedis {
         let mut db_key = self.prefix.clone().unwrap_or_default();
         db_key.extend(&*key);
 
-        let mut con = match self
-            .client
-            .as_ref()
-            .expect("A client must be set with set_client()")
-            .get_multiplexed_tokio_connection()
-            .await
-        {
+        let mut con = match self.client.get_multiplexed_tokio_connection().await {
             Ok(con) => con,
             Err(err) => {
                 tracing::error!("Failed to get redis connection: {:?}", err);

crates/cdk-axum/src/cache/mod.rs

@@ -25,10 +25,8 @@ pub use self::config::Config;
 #[async_trait::async_trait]
 /// Cache storage for the HTTP cache.
 pub trait HttpCacheStorage {
-    /// Create a new cache storage instance
-    fn new(cache_ttl: Duration, cache_tti: Duration) -> Self
-    where
-        Self: Sized;
+    /// Sets the expiration times for the cache.
+    fn set_expiration_times(&mut self, cache_ttl: Duration, cache_tti: Duration);
 
     /// Get a value from the cache.
     async fn get(&self, key: &HttpCacheKey) -> Option<Vec<u8>>;
@@ -43,7 +41,8 @@ pub struct HttpCache {
     pub ttl: Duration,
     /// Time to idle for the cache.
     pub tti: Duration,
-    storage: Arc<dyn HttpCacheStorage + Send + Sync>,
+    /// Storage backend for the cache.
+    storage: Arc<Box<dyn HttpCacheStorage + Send + Sync>>,
 }
 
 impl Default for HttpCache {
@@ -94,12 +93,7 @@ impl From<config::Config> for HttpCache {
             config::Backend::Redis(redis_config) => {
                 let client = redis::Client::open(redis_config.connection_string)
                     .expect("Failed to create Redis client");
-                let storage = HttpCacheRedis::new(
-                    Duration::from_secs(config.ttl.unwrap_or(60)),
-                    Duration::from_secs(config.tti.unwrap_or(60)),
-                )
-                .set_client(client)
-                .set_prefix(
+                let storage = HttpCacheRedis::new(client).set_prefix(
                     redis_config
                         .key_prefix
                         .unwrap_or_default()
@@ -109,7 +103,7 @@ impl From<config::Config> for HttpCache {
                 Self::new(
                     Duration::from_secs(config.ttl.unwrap_or(DEFAULT_TTL_SECS)),
                     Duration::from_secs(config.tti.unwrap_or(DEFAULT_TTI_SECS)),
-                    Some(Arc::new(storage)),
+                    Some(Box::new(storage)),
                 )
             }
         }
@@ -121,12 +115,15 @@ impl HttpCache {
     pub fn new(
         ttl: Duration,
         tti: Duration,
-        storage: Option<Arc<dyn HttpCacheStorage + Send + Sync + 'static>>,
+        storage: Option<Box<dyn HttpCacheStorage + Send + Sync + 'static>>,
     ) -> Self {
+        let mut storage = storage.unwrap_or_else(|| Box::new(InMemoryHttpCache::default()));
+        storage.set_expiration_times(ttl, tti);
+
         Self {
             ttl,
             tti,
-            storage: storage.unwrap_or_else(|| Arc::new(InMemoryHttpCache::new(ttl, tti))),
+            storage: Arc::new(storage),
         }
     }
 
@@ -142,7 +139,10 @@ impl HttpCache {
     /// double hash to have a predictable key size, although it may open the
     /// window for CPU attacks with large payloads, but it is a trade-off.
     /// Perhaps upper layer have a protection against large payloads.
-    pub fn calculate_key<K: Serialize>(&self, key: &K) -> Option<HttpCacheKey> {
+    pub fn calculate_key<K>(&self, key: &K) -> Option<HttpCacheKey>
+    where
+        K: Serialize,
+    {
         let json_value = match serde_json::to_vec(key) {
             Ok(value) => value,
             Err(err) => {
@@ -162,16 +162,27 @@ impl HttpCache {
     }
 
     /// Get a value from the cache.
-    pub async fn get<V: DeserializeOwned>(self: &Arc<Self>, key: &HttpCacheKey) -> Option<V> {
-        self.storage
-            .get(key)
-            .await
-            .map(|value| serde_json::from_slice(&value).unwrap())
+    pub async fn get<V>(self: &Arc<Self>, key: &HttpCacheKey) -> Option<V>
+    where
+        V: DeserializeOwned,
+    {
+        self.storage.get(key).await.and_then(|value| {
+            serde_json::from_slice(&value)
+                .map_err(|e| {
+                    tracing::warn!("Failed to deserialize value: {:?}", e);
+                    e
+                })
+                .ok()
+        })
     }
 
     /// Set a value in the cache.
     pub async fn set<V: Serialize>(self: &Arc<Self>, key: HttpCacheKey, value: &V) {
-        let value = serde_json::to_vec(value).unwrap();
-        self.storage.set(key, value).await;
+        if let Ok(bytes) = serde_json::to_vec(value).map_err(|e| {
+            tracing::warn!("Failed to serialize value: {:?}", e);
+            e
+        }) {
+            self.storage.set(key, bytes).await;
+        }
     }
 }

crates/cdk-mintd/src/config.rs

@@ -211,7 +211,10 @@ pub struct MintInfo {
 
 impl Settings {
     #[must_use]
-    pub fn new<P: Into<PathBuf>>(config_file_name: Option<P>) -> Self {
+    pub fn new<P>(config_file_name: Option<P>) -> Self
+    where
+        P: Into<PathBuf>,
+    {
         let default_settings = Self::default();
         // attempt to construct settings with file
         let from_file = Self::new_from_default(&default_settings, config_file_name);
@@ -224,10 +227,13 @@ impl Settings {
         }
     }
 
-    fn new_from_default<P: Into<PathBuf>>(
+    fn new_from_default<P>(
         default: &Settings,
         config_file_name: Option<P>,
-    ) -> Result<Self, ConfigError> {
+    ) -> Result<Self, ConfigError>
+    where
+        P: Into<PathBuf>,
+    {
         let mut default_config_file_name = home::home_dir()
             .ok_or(ConfigError::NotFound("Config Path".to_string()))?
             .join("cashu-rs-mint");