controllers/krate/versions: Add release_tracks meta for non-paginated versions

Author: eth3lbert

src/controllers/krate/versions.rs

@@ -8,7 +8,6 @@ use diesel_async::{AsyncPgConnection, RunQueryDsl};
 use futures_util::{future, TryStreamExt};
 use http::request::Parts;
 use indexmap::{IndexMap, IndexSet};
-use std::cmp::Reverse;
 use std::str::FromStr;
 
 use crate::app::AppState;
@@ -51,6 +50,7 @@ pub async fn list_versions(state: AppState, path: CratePath, req: Parts) -> AppR
         .map(|mode| ShowIncludeMode::from_str(mode))
         .transpose()?
         .unwrap_or_default();
+    let include_release_tracks = include.release_tracks;
 
     // Sort by semver by default
     let versions_and_publishers = match params.get("sort").map(|s| s.to_lowercase()).as_deref() {
@@ -75,6 +75,12 @@ pub async fn list_versions(state: AppState, path: CratePath, req: Parts) -> AppR
 
     Ok(match pagination {
         Some(_) => json!({ "versions": versions, "meta": versions_and_publishers.meta }),
+        None if include_release_tracks => {
+            json!({
+                "versions": versions,
+                "meta": ReleaseTracksMeta { release_tracks: versions_and_publishers.meta.release_tracks }
+            })
+        }
         None => json!({ "versions": versions }),
     })
 }
@@ -99,7 +105,6 @@ async fn list_by_date(
         .select(<(Version, Option<User>)>::as_select())
         .into_boxed();
 
-    let mut release_tracks = None;
     if let Some(options) = options {
         assert!(
             !matches!(&options.page, Page::Numeric(_)),
@@ -114,9 +119,20 @@ async fn list_by_date(
             )
         }
         query = query.limit(options.per_page);
+    }
+
+    query = query.order((versions::created_at.desc(), versions::id.desc()));
 
-        if include.release_tracks {
-            let mut sorted_versions = IndexSet::new();
+    let data: Vec<(Version, Option<User>)> = query.load(conn).await?;
+    let mut next_page = None;
+    if let Some(options) = options {
+        next_page = next_seek_params(&data, options, |last| Seek::Date.to_payload(last))?
+            .map(|p| req.query_with_params(p));
+    };
+
+    let release_tracks = if include.release_tracks {
+        let mut sorted_versions = IndexSet::new();
+        if options.is_some() {
             versions::table
                 .filter(versions::crate_id.eq(crate_id))
                 .filter(not(versions::yanked))
@@ -130,21 +146,23 @@ async fn list_by_date(
                     future::ready(Ok(()))
                 })
                 .await?;
-
-            sorted_versions.sort_unstable_by(|a, b| b.cmp(a));
-            release_tracks = Some(ReleaseTracks::from_sorted_semver_iter(
-                sorted_versions.iter(),
-            ));
+        } else {
+            sorted_versions = data
+                .iter()
+                .flat_map(|(version, _)| {
+                    (!version.yanked)
+                        .then_some(version)
+                        .and_then(|v| semver::Version::parse(&v.num).ok())
+                })
+                .collect();
         }
-    }
-
-    query = query.order((versions::created_at.desc(), versions::id.desc()));
 
-    let data: Vec<(Version, Option<User>)> = query.load(conn).await?;
-    let mut next_page = None;
-    if let Some(options) = options {
-        next_page = next_seek_params(&data, options, |last| Seek::Date.to_payload(last))?
-            .map(|p| req.query_with_params(p));
+        sorted_versions.sort_unstable_by(|a, b| b.cmp(a));
+        Some(ReleaseTracks::from_sorted_semver_iter(
+            sorted_versions.iter(),
+        ))
+    } else {
+        None
     };
 
     // Since the total count is retrieved through an additional query, to maintain consistency
@@ -269,15 +287,29 @@ async fn list_by_semver(
             (vec![], 0, release_tracks)
         }
     } else {
-        let mut data: Vec<(Version, Option<User>)> = versions::table
+        let mut data = IndexMap::new();
+        versions::table
             .filter(versions::crate_id.eq(crate_id))
             .left_outer_join(users::table)
             .select(<(Version, Option<User>)>::as_select())
-            .load(conn)
+            .load_stream::<(Version, Option<User>)>(conn)
+            .await?
+            .try_for_each(|row| {
+                if let Ok(semver) = semver::Version::parse(&row.0.num) {
+                    data.insert(semver, row);
+                };
+                future::ready(Ok(()))
+            })
             .await?;
-        data.sort_by_cached_key(|(version, _)| Reverse(semver::Version::parse(&version.num).ok()));
+        data.sort_unstable_by(|a, _, b, _| b.cmp(a));
         let total = data.len();
-        (data, total, None)
+        let release_tracks = include.release_tracks.then(|| {
+            ReleaseTracks::from_sorted_semver_iter(
+                data.iter()
+                    .flat_map(|(semver, (version, _))| (!version.yanked).then_some(semver)),
+            )
+        });
+        (data.into_values().collect(), total, release_tracks)
     };
 
     let mut next_page = None;
@@ -365,6 +397,12 @@ struct ResponseMeta {
     release_tracks: Option<ReleaseTracks>,
 }
 
+#[derive(Serialize)]
+struct ReleaseTracksMeta {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    release_tracks: Option<ReleaseTracks>,
+}
+
 #[derive(Debug, Eq, PartialEq, Serialize)]
 struct ReleaseTracks(IndexMap<ReleaseTrackName, ReleaseTrackDetails>);
 

src/tests/routes/crates/versions/list.rs

@@ -109,17 +109,19 @@ async fn test_sorting() -> anyhow::Result<()> {
 
     // Sort by semver
     let url = "/api/v1/crates/foo_versions/versions?sort=semver";
-    let json: AllVersions = anon.get(url).await.good();
-    for (num, expect) in nums(&json.versions).iter().zip(expects) {
-        assert_eq!(num, expect);
-    }
     for (url, release_tracks) in [
         (url, None),
         (
             &format!("{url}&include=release_tracks"),
             release_tracks.as_ref(),
         ),
     ] {
+        let json: AllVersions = anon.get(url).await.good();
+        assert_eq!(nums(&json.versions), expects);
+        assert_eq!(
+            json.meta.and_then(|m| m.release_tracks).as_ref(),
+            release_tracks
+        );
         let (resp, calls) = page_with_seek(&anon, url).await;
         for (json, expect) in resp.iter().zip(expects) {
             assert_eq!(json.versions[0].num, expect);
@@ -131,18 +133,20 @@ async fn test_sorting() -> anyhow::Result<()> {
 
     // Sort by date
     let url = "/api/v1/crates/foo_versions/versions?sort=date";
-    let json: AllVersions = anon.get(url).await.good();
-    let expects = versions.iter().cloned().rev().collect::<Vec<_>>();
-    for (num, expect) in nums(&json.versions).iter().zip(&expects) {
-        assert_eq!(num, *expect);
-    }
     for (url, release_tracks) in [
         (url, None),
         (
             &format!("{url}&include=release_tracks"),
             release_tracks.as_ref(),
         ),
     ] {
+        let json: AllVersions = anon.get(url).await.good();
+        let expects = versions.iter().cloned().rev().collect::<Vec<_>>();
+        assert_eq!(nums(&json.versions), expects);
+        assert_eq!(
+            json.meta.and_then(|m| m.release_tracks).as_ref(),
+            release_tracks
+        );
         let (resp, calls) = page_with_seek(&anon, url).await;
         for (json, expect) in resp.iter().zip(&expects) {
             assert_eq!(json.versions[0].num, *expect);
@@ -364,6 +368,12 @@ async fn invalid_seek_parameter() {
 #[derive(Debug, Deserialize)]
 pub struct AllVersions {
     pub versions: Vec<EncodableVersion>,
+    pub meta: Option<ReleaseTracksMeta>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ReleaseTracksMeta {
+    pub release_tracks: Option<serde_json::Value>,
 }
 
 #[derive(Debug, Deserialize)]