feat: expire cache when updating user

src/api/v1/me/mod.rs

@@ -81,8 +81,7 @@ pub async fn update(
         let byte_slice: &[u8] = &bytes;
 
         me.set_avatar(
-            &data.bunny_cdn,
+            &data,
-            &mut conn,
             data.config.bunny.cdn_url.clone(),
             byte_slice.into(),
         )
@@ -91,15 +90,15 @@ pub async fn update(
 
     if let Some(new_info) = form.json.0 {
         if let Some(username) = &new_info.username {
-            me.set_username(&mut conn, username.clone()).await?;
+            me.set_username(&data, username.clone()).await?;
         }
 
         if let Some(display_name) = &new_info.display_name {
-            me.set_display_name(&mut conn, display_name.clone()).await?;
+            me.set_display_name(&data, display_name.clone()).await?;
         }
 
         if let Some(email) = &new_info.email {
-            me.set_email(&mut conn, email.to_string()).await?;
+            me.set_email(&data, email.to_string()).await?;
         }
     }
 

src/structs.rs

@@ -961,25 +961,27 @@ impl Me {
 
     pub async fn set_avatar(
         &mut self,
-        bunny_cdn: &bunny_api_tokio::Client,
+        data: &Data,
-        conn: &mut Conn,
         cdn_url: Url,
         avatar: BytesMut,
     ) -> Result<(), Error> {
         let avatar_clone = avatar.clone();
         let image_type = task::spawn_blocking(move || image_check(avatar_clone)).await??;
 
+        let mut conn = data.pool.get().await?;
+
         if let Some(avatar) = &self.avatar {
             let avatar_url: Url = avatar.parse()?;
 
             let relative_url = avatar_url.path().trim_start_matches('/');
 
-            bunny_cdn.storage.delete(relative_url).await?;
+            data.bunny_cdn.storage.delete(relative_url).await?;
         }
 
         let path = format!("avatar/{}/avatar.{}", self.uuid, image_type);
 
-        bunny_cdn
+        data.
+            bunny_cdn
             .storage
             .upload(path.clone(), avatar.into())
             .await?;
@@ -990,9 +992,13 @@ impl Me {
         update(users::table)
             .filter(dsl::uuid.eq(self.uuid))
             .set(dsl::avatar.eq(avatar_url.as_str()))
-            .execute(conn)
+            .execute(&mut conn)
             .await?;
 
+        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
+            data.del_cache_key(self.uuid.to_string()).await?
+        }
+
         self.avatar = Some(avatar_url.to_string());
 
         Ok(())
@@ -1011,20 +1017,26 @@ impl Me {
 
     pub async fn set_username(
         &mut self,
-        conn: &mut Conn,
+        data: &Data,
         new_username: String,
     ) -> Result<(), Error> {
         if !USERNAME_REGEX.is_match(&new_username) {
             return Err(Error::BadRequest("Invalid username".to_string()));
         }
 
+        let mut conn = data.pool.get().await?;
+
         use users::dsl;
         update(users::table)
             .filter(dsl::uuid.eq(self.uuid))
             .set(dsl::username.eq(new_username.as_str()))
-            .execute(conn)
+            .execute(&mut conn)
             .await?;
 
+        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
+            data.del_cache_key(self.uuid.to_string()).await?
+        }
+
         self.username = new_username;
 
         Ok(())
@@ -1032,26 +1044,34 @@ impl Me {
 
     pub async fn set_display_name(
         &mut self,
-        conn: &mut Conn,
+        data: &Data,
         new_display_name: String,
     ) -> Result<(), Error> {
+        let mut conn = data.pool.get().await?;
+
         use users::dsl;
         update(users::table)
             .filter(dsl::uuid.eq(self.uuid))
             .set(dsl::display_name.eq(new_display_name.as_str()))
-            .execute(conn)
+            .execute(&mut conn)
             .await?;
 
+        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
+            data.del_cache_key(self.uuid.to_string()).await?
+        }
+
         self.display_name = Some(new_display_name);
 
         Ok(())
     }
 
-    pub async fn set_email(&mut self, conn: &mut Conn, new_email: String) -> Result<(), Error> {
+    pub async fn set_email(&mut self, data: &Data, new_email: String) -> Result<(), Error> {
         if !EMAIL_REGEX.is_match(&new_email) {
             return Err(Error::BadRequest("Invalid username".to_string()));
         }
 
+        let mut conn = data.pool.get().await?;
+
         use users::dsl;
         update(users::table)
             .filter(dsl::uuid.eq(self.uuid))
@@ -1059,9 +1079,13 @@ impl Me {
                 dsl::email.eq(new_email.as_str()),
                 dsl::email_verified.eq(false),
             ))
-            .execute(conn)
+            .execute(&mut conn)
             .await?;
 
+        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
+            data.del_cache_key(self.uuid.to_string()).await?
+        }
+
         self.email = new_email;
 
         Ok(())