Fix version creation taking forever (#878)

* Fix version creation taking forever

* run fmt + prep

* fix tests?

src/database/models/ids.rs

@@ -1,6 +1,6 @@
 use super::DatabaseError;
 use crate::models::ids::base62_impl::to_base62;
-use crate::models::ids::random_base62_rng;
+use crate::models::ids::{random_base62_rng, random_base62_rng_range};
 use censor::Censor;
 use serde::{Deserialize, Serialize};
 use sqlx::sqlx_macros::Type;
@@ -41,6 +41,37 @@ macro_rules! generate_ids {
     };
 }
 
+macro_rules! generate_bulk_ids {
+    ($vis:vis $function_name:ident, $return_type:ty, $select_stmnt:literal, $id_function:expr) => {
+        $vis async fn $function_name(
+            count: usize,
+            con: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+        ) -> Result<Vec<$return_type>, DatabaseError> {
+            let mut rng = rand::thread_rng();
+            let mut retry_count = 0;
+
+            // Check if ID is unique
+            loop {
+                let base = random_base62_rng_range(&mut rng, 1, 10) as i64;
+                let ids = (0..count).map(|x| base + x as i64).collect::<Vec<_>>();
+
+                let results = sqlx::query!($select_stmnt, &ids)
+                    .fetch_one(&mut **con)
+                    .await?;
+
+                if !results.exists.unwrap_or(true) {
+                    return Ok(ids.into_iter().map(|x| $id_function(x)).collect());
+                }
+
+                retry_count += 1;
+                if retry_count > ID_RETRY_COUNT {
+                    return Err(DatabaseError::RandomId);
+                }
+            }
+        }
+    };
+}
+
 generate_ids!(
     pub generate_project_id,
     ProjectId,
@@ -121,6 +152,13 @@ generate_ids!(
     NotificationId
 );
 
+generate_bulk_ids!(
+    pub generate_many_notification_ids,
+    NotificationId,
+    "SELECT EXISTS(SELECT 1 FROM notifications WHERE id = ANY($1))",
+    NotificationId
+);
+
 generate_ids!(
     pub generate_thread_id,
     ThreadId,

src/database/models/notification_item.rs

@@ -3,7 +3,6 @@ use crate::database::{models::DatabaseError, redis::RedisPool};
 use crate::models::notifications::NotificationBody;
 use chrono::{DateTime, Utc};
 use futures::TryStreamExt;
-use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
 const USER_NOTIFICATIONS_NAMESPACE: &str = "user_notifications";
@@ -46,37 +45,15 @@ impl NotificationBuilder {
         transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
         redis: &RedisPool,
     ) -> Result<(), DatabaseError> {
-        let mut notifications = Vec::new();
-        for user in users {
-            let id = generate_notification_id(&mut *transaction).await?;
+        let notification_ids =
+            generate_many_notification_ids(users.len(), &mut *transaction).await?;
 
-            notifications.push(Notification {
-                id,
-                user_id: user,
-                body: self.body.clone(),
-                read: false,
-                created: Utc::now(),
-            });
-        }
-
-        Notification::insert_many(&notifications, transaction, redis).await?;
-
-        Ok(())
-    }
-}
-
-impl Notification {
-    pub async fn insert_many(
-        notifications: &[Notification],
-        transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
-        redis: &RedisPool,
-    ) -> Result<(), DatabaseError> {
-        let notification_ids = notifications.iter().map(|n| n.id.0).collect_vec();
-        let user_ids = notifications.iter().map(|n| n.user_id.0).collect_vec();
-        let bodies = notifications
+        let body = serde_json::value::to_value(&self.body)?;
+        let bodies = notification_ids
             .iter()
-            .map(|n| Ok(serde_json::value::to_value(n.body.clone())?))
-            .collect::<Result<Vec<_>, DatabaseError>>()?;
+            .map(|_| body.clone())
+            .collect::<Vec<_>>();
+
         sqlx::query!(
             "
             INSERT INTO notifications (
@@ -84,22 +61,23 @@ impl Notification {
             )
             SELECT * FROM UNNEST($1::bigint[], $2::bigint[], $3::jsonb[])
             ",
-            &notification_ids[..],
-            &user_ids[..],
+            &notification_ids
+                .into_iter()
+                .map(|x| x.0)
+                .collect::<Vec<_>>()[..],
+            &users.iter().map(|x| x.0).collect::<Vec<_>>()[..],
             &bodies[..],
         )
         .execute(&mut **transaction)
         .await?;
 
-        Notification::clear_user_notifications_cache(
-            notifications.iter().map(|n| &n.user_id),
-            redis,
-        )
-        .await?;
+        Notification::clear_user_notifications_cache(&users, redis).await?;
 
         Ok(())
     }
+}
 
+impl Notification {
     pub async fn get<'a, 'b, E>(
         id: NotificationId,
         executor: E,