controllers/krate/versions: Implement release_tracks meta for pagination, sorted by semver

Author: eth3lbert

src/controllers/krate/versions.rs

@@ -133,7 +133,11 @@ fn list_by_date(
 
     Ok(PaginatedVersionsAndPublishers {
         data,
-        meta: ResponseMeta { total, next_page },
+        meta: ResponseMeta {
+            total,
+            next_page,
+            release_tracks: None,
+        },
     })
 }
 
@@ -153,7 +157,7 @@ fn list_by_semver(
 ) -> AppResult<PaginatedVersionsAndPublishers> {
     use seek::*;
 
-    let (data, total) = if let Some(options) = options {
+    let (data, total, release_tracks) = if let Some(options) = options {
         // Since versions will only increase in the future and both sorting and pagination need to
         // happen on the app server, implementing it with fetching only the data needed for sorting
         // and pagination, then making another query for the data to respond with, would minimize
@@ -164,18 +168,26 @@ fn list_by_semver(
         let mut sorted_versions = IndexMap::new();
         for result in versions::table
             .filter(versions::crate_id.eq(crate_id))
-            .select((versions::id, versions::num))
-            .load_iter::<(i32, String), DefaultLoadingMode>(conn)?
+            .select((versions::id, versions::num, versions::yanked))
+            .load_iter::<(i32, String, bool), DefaultLoadingMode>(conn)?
         {
-            let (id, num) = result?;
-            sorted_versions.insert(id, (num, None));
+            let (id, num, yanked) = result?;
+            let semver = semver::Version::parse(&num).ok();
+            sorted_versions.insert(id, (semver, yanked, None));
         }
-        sorted_versions.sort_by_cached_key(|_, (num, _)| Reverse(semver::Version::parse(num).ok()));
+        sorted_versions
+            .sort_unstable_by(|_, (semver_a, _, _), _, (semver_b, _, _)| semver_b.cmp(semver_a));
 
         assert!(
             !matches!(&options.page, Page::Numeric(_)),
             "?page= is not supported"
         );
+        let release_tracks = Some(ReleaseTracks::from_sorted_semver_iter(
+            sorted_versions
+                .values()
+                .filter(|(_, yanked, _)| !yanked)
+                .filter_map(|(semver, _, _)| semver.as_ref()),
+        ));
         let mut idx = Some(0);
         if let Some(SeekPayload::Semver(Semver { id })) = Seek::Semver.after(&options.page)? {
             idx = sorted_versions
@@ -197,19 +209,24 @@ fn list_by_semver(
                 .load_iter::<(Version, Option<User>), DefaultLoadingMode>(conn)?
             {
                 let row = result?;
-                sorted_versions.insert(row.0.id, (row.0.num.to_owned(), Some(row)));
+                // The versions are already sorted, and we only need to enrich the fetched rows into them.
+                // Therefore, other values can now be safely ignored.
+                sorted_versions
+                    .entry(row.0.id)
+                    .and_modify(|entry| *entry = (None, false, Some(row)));
             }
 
             let len = sorted_versions.len();
             (
                 sorted_versions
                     .into_values()
-                    .filter_map(|(_, v)| v)
+                    .filter_map(|(_, _, v)| v)
                     .collect(),
                 len,
+                release_tracks,
             )
         } else {
-            (vec![], 0)
+            (vec![], 0, release_tracks)
         }
     } else {
         let mut data: Vec<(Version, Option<User>)> = versions::table
@@ -219,7 +236,7 @@ fn list_by_semver(
             .load(conn)?;
         data.sort_by_cached_key(|(version, _)| Reverse(semver::Version::parse(&version.num).ok()));
         let total = data.len();
-        (data, total)
+        (data, total, None)
     };
 
     let mut next_page = None;
@@ -233,6 +250,7 @@ fn list_by_semver(
         meta: ResponseMeta {
             total: total as i64,
             next_page,
+            release_tracks,
         },
     })
 }
@@ -302,6 +320,7 @@ struct PaginatedVersionsAndPublishers {
 struct ResponseMeta {
     total: i64,
     next_page: Option<String>,
+    release_tracks: Option<ReleaseTracks>,
 }
 
 #[derive(Debug, Eq, PartialEq, Serialize)]

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

@@ -107,6 +107,10 @@ async fn test_sorting() {
     for (json, expect) in resp.iter().zip(expects) {
         assert_eq!(json.versions[0].num, expect);
         assert_eq!(json.meta.total as usize, expects.len());
+        assert_eq!(
+            json.meta.release_tracks,
+            Some(json!({"1.x": {"highest": "1.0.0"}}))
+        );
     }
     assert_eq!(calls as usize, expects.len() + 1);
 
@@ -131,6 +135,7 @@ async fn test_seek_based_pagination_semver_sorting() {
     let user = user.as_model();
     app.db(|conn| {
         CrateBuilder::new("foo_versions", user.id)
+            .version(VersionBuilder::new("0.5.2").yanked(true))
             .version("0.5.1")
             .version(VersionBuilder::new("1.0.0").rust_version("1.64"))
             .version("0.5.0")
@@ -146,7 +151,11 @@ async fn test_seek_based_pagination_semver_sorting() {
     });
 
     let url = "/api/v1/crates/foo_versions/versions";
-    let expects = ["1.0.0", "0.5.1", "0.5.0"];
+    let expects = ["1.0.0", "0.5.2", "0.5.1", "0.5.0"];
+    let release_tracks = Some(json!({
+        "1.x": {"highest": "1.0.0"},
+        "0.5": {"highest": "0.5.1"}
+    }));
 
     // per_page larger than the number of versions
     let json: VersionList = anon
@@ -155,6 +164,7 @@ async fn test_seek_based_pagination_semver_sorting() {
         .good();
     assert_eq!(nums(&json.versions), expects);
     assert_eq!(json.meta.total as usize, expects.len());
+    assert_eq!(json.meta.release_tracks, release_tracks);
 
     let json: VersionList = anon
         .get_with_query(url, "per_page=1&sort=semver")
@@ -178,15 +188,17 @@ async fn test_seek_based_pagination_semver_sorting() {
     assert_eq!(nums(&json.versions), expects[1..]);
     assert!(json.meta.next_page.is_none());
     assert_eq!(json.meta.total as usize, expects.len());
+    assert_eq!(json.meta.release_tracks, release_tracks);
 
     // per_page euqal to the number of remain versions
     let json: VersionList = anon
         .get_with_query(url, &format!("per_page=2&sort=semver&seek={seek}"))
         .await
         .good();
-    assert_eq!(nums(&json.versions), expects[1..]);
+    assert_eq!(nums(&json.versions), expects[1..3]);
     assert!(json.meta.next_page.is_some());
     assert_eq!(json.meta.total as usize, expects.len());
+    assert_eq!(json.meta.release_tracks, release_tracks);
 
     // A decodable seek value, MTAwCg (100), but doesn't actually exist
     let json: VersionList = anon
@@ -196,6 +208,7 @@ async fn test_seek_based_pagination_semver_sorting() {
     assert_eq!(json.versions.len(), 0);
     assert!(json.meta.next_page.is_none());
     assert_eq!(json.meta.total, 0);
+    assert_eq!(json.meta.release_tracks, release_tracks);
 }
 
 #[tokio::test(flavor = "multi_thread")]
@@ -242,6 +255,7 @@ pub struct VersionList {
 pub struct ResponseMeta {
     pub total: i64,
     pub next_page: Option<String>,
+    pub release_tracks: Option<serde_json::Value>,
 }
 
 fn nums(versions: &[EncodableVersion]) -> Vec<String> {