Optimize dependencies route and change return value (#230)

src/routes/auth.rs

@@ -228,7 +228,7 @@ pub async fn auth_callback(
 
         transaction.commit().await?;
 
-        let redirect_url = if result.url.contains("?") {
+        let redirect_url = if result.url.contains('?') {
             format!("{}&code={}", result.url, token.access_token)
         } else {
             format!("{}?code={}", result.url, token.access_token)

src/routes/projects.rs

@@ -16,7 +16,6 @@ use actix_web::{delete, get, patch, post, web, HttpRequest, HttpResponse};
 use futures::StreamExt;
 use serde::{Deserialize, Serialize};
 use sqlx::PgPool;
-use std::collections::HashMap;
 use std::sync::Arc;
 use validator::Validate;
 
@@ -133,8 +132,8 @@ pub async fn project_get(
 
 #[derive(Serialize)]
 struct DependencyInfo {
-    pub project: Option<models::projects::Project>,
+    pub projects: Vec<models::projects::Project>,
-    pub version: Option<models::projects::Version>,
+    pub versions: Vec<models::projects::Version>,
 }
 
 #[get("dependencies")]
@@ -177,50 +176,27 @@ pub async fn dependency_list(
         )>>()
         .await?;
 
-        let projects = database::Project::get_many_full(
+        let (projects_result, versions_result) = futures::join!(
-            dependencies.iter().map(|x| x.2).flatten().collect(),
+            database::Project::get_many_full(
-            &**pool,
+                dependencies.iter().map(|x| x.2).flatten().collect(),
-        )
+                &**pool,
-        .await?;
+            ),
-        let versions = database::Version::get_many_full(
+            database::Version::get_many_full(
-            dependencies.iter().map(|x| x.1).flatten().collect(),
+                dependencies.iter().map(|x| x.1).flatten().collect(),
-            &**pool,
+                &**pool,
-        )
+            )
-        .await?;
+        );
 
-        let mut response: HashMap<models::projects::VersionId, Vec<DependencyInfo>> =
+        let projects = projects_result?
-            HashMap::new();
+            .into_iter()
+            .map(convert_project)
+            .collect::<Vec<models::projects::Project>>();
+        let versions = versions_result?
+            .into_iter()
+            .map(super::versions::convert_version)
+            .collect::<Vec<models::projects::Version>>();
 
-        for dependency in dependencies {
+        Ok(HttpResponse::Ok().json(DependencyInfo { projects, versions }))
-            let deps = response.get_mut(&dependency.0.into());
-
-            let info = DependencyInfo {
-                project: if let Some(id) = dependency.2 {
-                    projects
-                        .iter()
-                        .find(|x| x.inner.id == id)
-                        .map(|x| convert_project(x.clone()))
-                } else {
-                    None
-                },
-                version: if let Some(id) = dependency.1 {
-                    versions
-                        .iter()
-                        .find(|x| x.id == id)
-                        .map(|x| super::versions::convert_version(x.clone()))
-                } else {
-                    None
-                },
-            };
-
-            if let Some(deps) = deps {
-                deps.push(info);
-            } else {
-                response.insert(dependency.0.into(), vec![info]);
-            }
-        }
-
-        Ok(HttpResponse::Ok().json(response))
     } else {
         Ok(HttpResponse::NotFound().body(""))
     }

src/routes/versions.rs

@@ -62,10 +62,12 @@ pub async fn version_list(
 
         // Attempt to populate versions with "auto featured" versions
         if response.is_empty() && !versions.is_empty() && filters.featured.unwrap_or(false) {
-            let loaders = database::models::categories::Loader::list(&**pool).await?;
+            let (loaders, game_versions) = futures::join!(
-            let game_versions =
+                database::models::categories::Loader::list(&**pool),
                 database::models::categories::GameVersion::list_filter(None, Some(true), &**pool)
-                    .await?;
+            );
+
+            let (loaders, game_versions) = (loaders?, game_versions?);
 
             let mut joined_filters = Vec::new();
             for game_version in &game_versions {