delete revs

src/database/models/organization_item.rs

@@ -318,13 +318,15 @@ impl Organization {
         title: Option<String>,
         redis: &RedisPool,
     ) -> Result<(), super::DatabaseError> {
-        redis.delete(ORGANIZATIONS_NAMESPACE, id.0).await?;
-        if let Some(title) = title {
-            redis
-                .delete(ORGANIZATIONS_TITLES_NAMESPACE, title.to_lowercase())
-                .await?;
-        }
-
+        redis
+            .delete_many([
+                (ORGANIZATIONS_NAMESPACE, Some(id.0.to_string())),
+                (
+                    ORGANIZATIONS_TITLES_NAMESPACE,
+                    title.map(|x| x.to_lowercase()),
+                ),
+            ])
+            .await?;
         Ok(())
     }
 }

src/database/models/pat_item.rs

@@ -237,15 +237,15 @@ impl PersonalAccessToken {
             return Ok(());
         }
 
-        for (id, token, user_id) in clear_pats {
-            redis
-                .delete_many([
+        redis
+            .delete_many(clear_pats.into_iter().flat_map(|(id, token, user_id)| {
+                [
                     (PATS_NAMESPACE, id.map(|i| i.0.to_string())),
                     (PATS_TOKENS_NAMESPACE, token),
                     (PATS_USERS_NAMESPACE, user_id.map(|i| i.0.to_string())),
-                ])
-                .await?;
-        }
+                ]
+            }))
+            .await?;
 
         Ok(())
     }

src/database/models/session_item.rs

@@ -287,16 +287,19 @@ impl Session {
             return Ok(());
         }
 
-        for (id, session, user_id) in clear_sessions {
-            redis
-                .delete_many([
-                    (SESSIONS_NAMESPACE, id.map(|i| i.0.to_string())),
-                    (SESSIONS_IDS_NAMESPACE, session),
-                    (SESSIONS_USERS_NAMESPACE, user_id.map(|i| i.0.to_string())),
-                ])
-                .await?;
-        }
-
+        redis
+            .delete_many(
+                clear_sessions
+                    .into_iter()
+                    .flat_map(|(id, session, user_id)| {
+                        [
+                            (SESSIONS_NAMESPACE, id.map(|i| i.0.to_string())),
+                            (SESSIONS_IDS_NAMESPACE, session),
+                            (SESSIONS_USERS_NAMESPACE, user_id.map(|i| i.0.to_string())),
+                        ]
+                    }),
+            )
+            .await?;
         Ok(())
     }
 

src/database/models/user_item.rs

@@ -351,16 +351,17 @@ impl User {
         user_ids: &[(UserId, Option<String>)],
         redis: &RedisPool,
     ) -> Result<(), DatabaseError> {
-        for (id, username) in user_ids {
-            redis.delete(USERS_NAMESPACE, id.0).await?;
-
-            if let Some(username) = username {
-                redis
-                    .delete(USER_USERNAMES_NAMESPACE, username.to_lowercase())
-                    .await?;
-            }
-        }
-
+        redis
+            .delete_many(user_ids.into_iter().flat_map(|(id, username)| {
+                [
+                    (USERS_NAMESPACE, Some(id.0.to_string())),
+                    (
+                        USER_USERNAMES_NAMESPACE,
+                        username.clone().map(|i| i.to_lowercase()),
+                    ),
+                ]
+            }))
+            .await?;
         Ok(())
     }
 

src/database/models/version_item.rs

@@ -7,6 +7,7 @@ use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::collections::HashMap;
+use std::iter;
 
 const VERSIONS_NAMESPACE: &str = "versions";
 const VERSION_FILES_NAMESPACE: &str = "versions_files";
@@ -736,16 +737,17 @@ impl Version {
         version: &QueryVersion,
         redis: &RedisPool,
     ) -> Result<(), DatabaseError> {
-        redis.delete(VERSIONS_NAMESPACE, version.inner.id.0).await?;
-
-        for file in &version.files {
-            for (algo, hash) in &file.hashes {
-                redis
-                    .delete(VERSION_FILES_NAMESPACE, format!("{}_{}", algo, hash))
-                    .await?;
-            }
-        }
-
+        redis
+            .delete_many(
+                iter::once((VERSIONS_NAMESPACE, Some(version.inner.id.0.to_string()))).chain(
+                    version.files.iter().flat_map(|file| {
+                        file.hashes.iter().map(|(algo, hash)| {
+                            (VERSION_FILES_NAMESPACE, Some(format!("{}_{}", algo, hash)))
+                        })
+                    }),
+                ),
+            )
+            .await?;
         Ok(())
     }
 }