- chore: ran cargo fix on the codebase

utils/src/redis_cache.rs

@@ -23,7 +23,7 @@ pub trait Cache {
         &self,
         key: &String,
     ) -> Result<Option<T>, redis::RedisError>;
-    
+
     async fn delete(&mut self, key: &str) -> redis::RedisResult<()>;
 }
 
@@ -34,7 +34,9 @@ pub struct RedisCache {
 impl RedisCache {
     pub fn new(redis_url: &str) -> Self {
         let cfg = Config::from_url(redis_url);
-        let pool = cfg.create_pool(Some(Runtime::Tokio1)).expect("Failed to create Redis pool");
+        let pool = cfg
+            .create_pool(Some(Runtime::Tokio1))
+            .expect("Failed to create Redis pool");
         RedisCache { pool }
     }
 }
@@ -47,20 +49,20 @@ impl Cache for RedisCache {
         value: &T,
         ttl: u64,
     ) -> Result<(), redis::RedisError> {
-        let mut conn = self.pool.get().await
-            .map_err(|err| {
-                redis::RedisError::from((
-                    redis::ErrorKind::IoError,
-                    "Failed to get Redis connection",
-                    format!("{:?}", err),
-                ))
-            })?;
-        let serialized_value = serde_json::to_string(value)
-            .map_err(|err| RedisError::from((
+        let mut conn = self.pool.get().await.map_err(|err| {
+            redis::RedisError::from((
+                redis::ErrorKind::IoError,
+                "Failed to get Redis connection",
+                format!("{:?}", err),
+            ))
+        })?;
+        let serialized_value = serde_json::to_string(value).map_err(|err| {
+            RedisError::from((
                 redis::ErrorKind::IoError,
                 "Serialization error",
                 format!("Serialization error: {}", err),
-            )))?;
+            ))
+        })?;
         if ttl > 0 {
             conn.set_ex(key, serialized_value, ttl).await
         } else {
@@ -68,22 +70,25 @@ impl Cache for RedisCache {
         }
     }
 
-    async fn get<T: for<'de> Deserialize<'de> + Send + Sync>(&self, key: &String) -> Result<Option<T>, redis::RedisError> {
-        let mut conn = self.pool.get().await
-            .map_err(|err| {
-                redis::RedisError::from((
-                    redis::ErrorKind::IoError,
-                    "Failed to get Redis connection",
-                    format!("{:?}", err),
-                ))
-            })?;
+    async fn get<T: for<'de> Deserialize<'de> + Send + Sync>(
+        &self,
+        key: &String,
+    ) -> Result<Option<T>, redis::RedisError> {
+        let mut conn = self.pool.get().await.map_err(|err| {
+            redis::RedisError::from((
+                redis::ErrorKind::IoError,
+                "Failed to get Redis connection",
+                format!("{:?}", err),
+            ))
+        })?;
         if let Some(serialized_value) = conn.get::<_, Option<String>>(key).await? {
-            let deserialized_value = serde_json::from_str(&serialized_value)
-                .map_err(|err| RedisError::from((
+            let deserialized_value = serde_json::from_str(&serialized_value).map_err(|err| {
+                RedisError::from((
                     redis::ErrorKind::IoError,
                     "Deserialization error",
                     format!("Deserialization error: {}", err),
-                )))?;
+                ))
+            })?;
             Ok(Some(deserialized_value))
         } else {
             Ok(None)
@@ -96,22 +101,22 @@ impl Cache for RedisCache {
         value: Option<&T>,
         ttl: Option<u64>,
     ) -> Result<(), redis::RedisError> {
-        let mut conn = self.pool.get().await
-            .map_err(|err| {
-                redis::RedisError::from((
-                    redis::ErrorKind::IoError,
-                    "Failed to get Redis connection",
-                    format!("{:?}", err),
-                ))
-            })?;
+        let mut conn = self.pool.get().await.map_err(|err| {
+            redis::RedisError::from((
+                redis::ErrorKind::IoError,
+                "Failed to get Redis connection",
+                format!("{:?}", err),
+            ))
+        })?;
         let serialized_value;
         if value.is_some() {
-            serialized_value = serde_json::to_string(&value)
-                .map_err(|err| RedisError::from((
+            serialized_value = serde_json::to_string(&value).map_err(|err| {
+                RedisError::from((
                     redis::ErrorKind::IoError,
                     "Serialization error",
                     format!("Serialization error: {}", err),
-                )))?;
+                ))
+            })?;
         } else {
             serialized_value = conn.get(key).await?;
         }
@@ -123,14 +128,13 @@ impl Cache for RedisCache {
     }
 
     async fn delete(&mut self, key: &str) -> redis::RedisResult<()> {
-        let mut conn = self.pool.get().await
-            .map_err(|err| {
-                redis::RedisError::from((
-                    redis::ErrorKind::IoError,
-                    "Failed to get Redis connection",
-                    format!("{:?}", err),
-                ))
-            })?;
+        let mut conn = self.pool.get().await.map_err(|err| {
+            redis::RedisError::from((
+                redis::ErrorKind::IoError,
+                "Failed to get Redis connection",
+                format!("{:?}", err),
+            ))
+        })?;
         conn.del(key).await
     }
 }