Add API routes to request multiple of an item (#70)

* Change header name

* Add default bio value

* Remove default

* Make name null

* Run prepare

* Add new API Routes for requesting multiple of an item

* Run formatter

* Simplify get mods query

* Run prepare

* Refactor to use one query for most routes, change version create route to have mod_id in data

* More fixes

src/database/models/mod_item.rs

@@ -143,6 +143,46 @@ impl Mod {
         }
     }
 
+    pub async fn get_many<'a, E>(mod_ids: Vec<ModId>, exec: E) -> Result<Vec<Mod>, sqlx::Error>
+    where
+        E: sqlx::Executor<'a, Database = sqlx::Postgres> + Copy,
+    {
+        use futures::stream::TryStreamExt;
+
+        let mod_ids_parsed: Vec<i64> = mod_ids.into_iter().map(|x| x.0).collect();
+        let mods = sqlx::query!(
+            "
+            SELECT id, title, description, downloads,
+                   icon_url, body_url, published,
+                   issues_url, source_url, wiki_url,
+                   team_id
+            FROM mods
+            WHERE id IN (SELECT * FROM UNNEST($1::bigint[]))
+            ",
+            &mod_ids_parsed
+        )
+        .fetch_many(exec)
+        .try_filter_map(|e| async {
+            Ok(e.right().map(|m| Mod {
+                id: ModId(m.id),
+                team_id: TeamId(m.team_id),
+                title: m.title,
+                description: m.description,
+                downloads: m.downloads,
+                body_url: m.body_url,
+                icon_url: m.icon_url,
+                published: m.published,
+                issues_url: m.issues_url,
+                source_url: m.source_url,
+                wiki_url: m.wiki_url,
+            }))
+        })
+        .try_collect::<Vec<Mod>>()
+        .await?;
+
+        Ok(mods)
+    }
+
     pub async fn remove_full<'a, 'b, E>(
         id: ModId,
         exec: E,

src/database/models/user_item.rs

@@ -1,4 +1,4 @@
-use super::ids::UserId;
+use super::ids::{ModId, UserId};
 
 pub struct User {
     pub id: UserId,
@@ -112,4 +112,62 @@ impl User {
             Ok(None)
         }
     }
+
+    pub async fn get_many<'a, E>(user_ids: Vec<UserId>, exec: E) -> Result<Vec<User>, sqlx::Error>
+    where
+        E: sqlx::Executor<'a, Database = sqlx::Postgres> + Copy,
+    {
+        use futures::stream::TryStreamExt;
+
+        let user_ids_parsed: Vec<i64> = user_ids.into_iter().map(|x| x.0).collect();
+        let users = sqlx::query!(
+            "
+            SELECT u.id, u.github_id, u.name, u.email,
+                u.avatar_url, u.username, u.bio,
+                u.created, u.role FROM users u
+            WHERE u.id IN (SELECT * FROM UNNEST($1::bigint[]))
+            ",
+            &user_ids_parsed
+        )
+        .fetch_many(exec)
+        .try_filter_map(|e| async {
+            Ok(e.right().map(|u| User {
+                id: UserId(u.id),
+                github_id: u.github_id,
+                name: u.name,
+                email: u.email,
+                avatar_url: u.avatar_url,
+                username: u.username,
+                bio: u.bio,
+                created: u.created,
+                role: u.role,
+            }))
+        })
+        .try_collect::<Vec<User>>()
+        .await?;
+
+        Ok(users)
+    }
+
+    pub async fn get_mods<'a, E>(user_id: UserId, exec: E) -> Result<Vec<ModId>, sqlx::Error>
+    where
+        E: sqlx::Executor<'a, Database = sqlx::Postgres> + Copy,
+    {
+        use futures::stream::TryStreamExt;
+
+        let mods = sqlx::query!(
+            "
+            SELECT m.id FROM mods m
+            INNER JOIN team_members tm ON tm.team_id = m.team_id
+            WHERE tm.user_id = $1
+            ",
+            user_id as UserId,
+        )
+        .fetch_many(exec)
+        .try_filter_map(|e| async { Ok(e.right().map(|m| ModId(m.id))) })
+        .try_collect::<Vec<ModId>>()
+        .await?;
+
+        Ok(mods)
+    }
 }

src/database/models/version_item.rs

@@ -371,6 +371,46 @@ impl Version {
         }
     }
 
+    pub async fn get_many<'a, E>(
+        version_ids: Vec<VersionId>,
+        exec: E,
+    ) -> Result<Vec<Version>, sqlx::Error>
+    where
+        E: sqlx::Executor<'a, Database = sqlx::Postgres> + Copy,
+    {
+        use futures::stream::TryStreamExt;
+
+        let version_ids_parsed: Vec<i64> = version_ids.into_iter().map(|x| x.0).collect();
+        let versions = sqlx::query!(
+            "
+            SELECT v.id, v.mod_id, v.author_id, v.name, v.version_number,
+                v.changelog_url, v.date_published, v.downloads,
+                v.release_channel
+            FROM versions v
+            WHERE v.id IN (SELECT * FROM UNNEST($1::bigint[]))
+            ",
+            &version_ids_parsed
+        )
+        .fetch_many(exec)
+        .try_filter_map(|e| async {
+            Ok(e.right().map(|v| Version {
+                id: VersionId(v.id),
+                mod_id: ModId(v.mod_id),
+                author_id: UserId(v.author_id),
+                name: v.name,
+                version_number: v.version_number,
+                changelog_url: v.changelog_url,
+                date_published: v.date_published,
+                downloads: v.downloads,
+                release_channel: ChannelId(v.release_channel),
+            }))
+        })
+        .try_collect::<Vec<Version>>()
+        .await?;
+
+        Ok(versions)
+    }
+
     pub async fn get_full<'a, 'b, E>(
         id: VersionId,
         executor: E,