- chore: ran cargo fix on the codebase

database-service/src/characters.rs

@@ -1,8 +1,8 @@
+use serde::{Deserialize, Serialize};
 use sqlx::{FromRow, Row};
-use utils::redis_cache::{Cache, RedisCache}; // Import RedisCache
-use serde::{Serialize, Deserialize};
 use std::sync::Arc;
 use tokio::sync::Mutex;
+use utils::redis_cache::{Cache, RedisCache}; // Import RedisCache
 
 #[derive(Debug, FromRow, Serialize, Deserialize)]
 pub struct Character {
@@ -34,7 +34,14 @@ impl CharacterRepository {
         let cache_key = format!("character:{}", character_id);
 
         // Try fetching from Redis cache
-        if let Some(character) = self.cache.lock().await.get::<Character>(&cache_key).await.map_err(|_| sqlx::Error::RowNotFound)? {
+        if let Some(character) = self
+            .cache
+            .lock()
+            .await
+            .get::<Character>(&cache_key)
+            .await
+            .map_err(|_| sqlx::Error::RowNotFound)?
+        {
             return Ok(character);
         }
 
@@ -49,11 +56,24 @@ impl CharacterRepository {
             .await?;
 
         // Cache result
-        self.cache.lock().await.set(&cache_key, &character, 300).await.map_err(|_| sqlx::Error::RowNotFound)?;
+        self.cache
+            .lock()
+            .await
+            .set(&cache_key, &character, 300)
+            .await
+            .map_err(|_| sqlx::Error::RowNotFound)?;
         Ok(character)
     }
 
-    pub async fn create_character(&self, user_id: i32, name: &str, inventory: serde_json::Value, stats: serde_json::Value, looks: serde_json::Value, position: serde_json::Value) -> Result<i32, sqlx::Error> {
+    pub async fn create_character(
+        &self,
+        user_id: i32,
+        name: &str,
+        inventory: serde_json::Value,
+        stats: serde_json::Value,
+        looks: serde_json::Value,
+        position: serde_json::Value,
+    ) -> Result<i32, sqlx::Error> {
         let result = sqlx::query(
             "INSERT INTO characters (user_id, name, inventory, stats, looks, position, created_at, updated_at, is_active) \
              VALUES ($1, $2, $3, $4, $5, $6, NOW(), NOW(), true) RETURNING id",
@@ -69,35 +89,62 @@ impl CharacterRepository {
 
         // Invalidate cache
         let cache_key = format!("character:user:{}", user_id);
-        self.cache.lock().await.delete(&cache_key).await.map_err(|_| sqlx::Error::RowNotFound)?;
+        self.cache
+            .lock()
+            .await
+            .delete(&cache_key)
+            .await
+            .map_err(|_| sqlx::Error::RowNotFound)?;
         Ok(result.get("id"))
     }
 
-    pub async fn delete_character(&self, character_id: i32, delete_type: i32) -> Result<i64, sqlx::Error> {
-        let mut query = "UPDATE characters SET updated_at = NOW(), deleted_at = NOW() + '24 hours' WHERE id = $1 RETURNING user_id, extract(epoch from (deleted_at - now()))::BIGINT as deleted_at"; 
+    pub async fn delete_character(
+        &self,
+        character_id: i32,
+        delete_type: i32,
+    ) -> Result<i64, sqlx::Error> {
+        let mut query = "UPDATE characters SET updated_at = NOW(), deleted_at = NOW() + '24 hours' WHERE id = $1 RETURNING user_id, extract(epoch from (deleted_at - now()))::BIGINT as deleted_at";
         if 0 == delete_type {
             query = "UPDATE characters SET updated_at = NOW(), deleted_at = null WHERE id = $1 RETURNING user_id, 0::BIGINT as deleted_at";
         }
-        let result = sqlx::query(
-            query,
-        )
+        let result = sqlx::query(query)
             .bind(character_id)
             .fetch_one(&self.pool)
             .await?;
 
         // Invalidate cache
         let cache_key = format!("character:user:{}", result.get::<i32, &str>("user_id"));
-        self.cache.lock().await.delete(&cache_key).await.map_err(|_| sqlx::Error::RowNotFound)?;
+        self.cache
+            .lock()
+            .await
+            .delete(&cache_key)
+            .await
+            .map_err(|_| sqlx::Error::RowNotFound)?;
         let cache_key = format!("character:{}", character_id);
-        self.cache.lock().await.delete(&cache_key).await.map_err(|_| sqlx::Error::RowNotFound)?;
+        self.cache
+            .lock()
+            .await
+            .delete(&cache_key)
+            .await
+            .map_err(|_| sqlx::Error::RowNotFound)?;
         Ok(result.get::<i64, &str>("deleted_at"))
     }
 
-    pub async fn get_characters_by_user(&self, user_id: i32) -> Result<Vec<Character>, sqlx::Error> {
+    pub async fn get_characters_by_user(
+        &self,
+        user_id: i32,
+    ) -> Result<Vec<Character>, sqlx::Error> {
         let cache_key = format!("character:user:{}", user_id);
 
         // Try fetching from Redis cache
-        if let Some(characters) = self.cache.lock().await.get::<Vec<Character>>(&cache_key).await.map_err(|_| sqlx::Error::RowNotFound)? {
+        if let Some(characters) = self
+            .cache
+            .lock()
+            .await
+            .get::<Vec<Character>>(&cache_key)
+            .await
+            .map_err(|_| sqlx::Error::RowNotFound)?
+        {
             return Ok(characters);
         }
 
@@ -110,7 +157,12 @@ impl CharacterRepository {
             .await?;
 
         // Cache result
-        self.cache.lock().await.set(&cache_key, &characters, 300).await.map_err(|_| sqlx::Error::RowNotFound)?;
+        self.cache
+            .lock()
+            .await
+            .set(&cache_key, &characters, 300)
+            .await
+            .map_err(|_| sqlx::Error::RowNotFound)?;
         Ok(characters)
     }
 }