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

Author: eth3lbert

src/controllers/krate/versions.rs

@@ -3,10 +3,11 @@
 use axum::extract::Path;
 use axum::Json;
 use diesel::connection::DefaultLoadingMode;
+use diesel::dsl::not;
 use diesel::prelude::*;
 use diesel_async::async_connection_wrapper::AsyncConnectionWrapper;
 use http::request::Parts;
-use indexmap::IndexMap;
+use indexmap::{IndexMap, IndexSet};
 use serde_json::Value;
 use std::cmp::Reverse;
 
@@ -95,6 +96,7 @@ fn list_by_date(
         .select((versions::all_columns, users::all_columns.nullable()))
         .into_boxed();
 
+    let mut release_tracks = None;
     if let Some(options) = options {
         assert!(
             !matches!(&options.page, Page::Numeric(_)),
@@ -109,6 +111,23 @@ fn list_by_date(
             )
         }
         query = query.limit(options.per_page);
+
+        let mut sorted_versions = IndexSet::new();
+        for result in versions::table
+            .filter(versions::crate_id.eq(crate_id))
+            .filter(not(versions::yanked))
+            .select(versions::num)
+            .load_iter::<String, DefaultLoadingMode>(conn)?
+        {
+            let Ok(semver) = semver::Version::parse(&result?) else {
+                continue;
+            };
+            sorted_versions.insert(semver);
+        }
+        sorted_versions.sort_unstable_by(|a, b| b.cmp(a));
+        release_tracks = Some(ReleaseTracks::from_sorted_semver_iter(
+            sorted_versions.iter(),
+        ));
     }
 
     query = query.order((versions::created_at.desc(), versions::id.desc()));
@@ -136,7 +155,7 @@ fn list_by_date(
         meta: ResponseMeta {
             total,
             next_page,
-            release_tracks: None,
+            release_tracks,
         },
     })
 }

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

@@ -125,6 +125,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": {"highest": "1.0.0"}}))
+        );
     }
     assert_eq!(calls as usize, expects.len() + 1);
 }
@@ -211,6 +215,91 @@ async fn test_seek_based_pagination_semver_sorting() {
     assert_eq!(json.meta.release_tracks, release_tracks);
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn test_seek_based_pagination_date_sorting() {
+    let (app, anon, user) = TestApp::init().with_user();
+    let user = user.as_model();
+    app.db(|conn| {
+        CrateBuilder::new("foo_versions", user.id)
+            .version(VersionBuilder::new("0.5.1").yanked(true))
+            .version(VersionBuilder::new("1.0.0").rust_version("1.64"))
+            .version("0.5.0")
+            .expect_build(conn);
+        // Make version 1.0.0 mimic a version published before we started recording who published
+        // versions
+        let none: Option<i32> = None;
+        update(versions::table)
+            .filter(versions::num.eq("1.0.0"))
+            .set(versions::published_by.eq(none))
+            .execute(conn)
+            .unwrap();
+    });
+
+    let url = "/api/v1/crates/foo_versions/versions";
+    let expects = ["0.5.0", "1.0.0", "0.5.1"];
+    let release_tracks = Some(json!({
+        "1": {"highest": "1.0.0"},
+        "0.5": {"highest": "0.5.0"}
+    }));
+
+    // per_page larger than the number of versions
+    let json: VersionList = anon
+        .get_with_query(url, "per_page=10&sort=date")
+        .await
+        .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=date")
+        .await
+        .good();
+    assert_eq!(nums(&json.versions), expects[0..1]);
+    assert_eq!(json.meta.total as usize, expects.len());
+    assert_eq!(json.meta.release_tracks, release_tracks);
+
+    let seek = json
+        .meta
+        .next_page
+        .map(|s| s.split_once("seek=").unwrap().1.to_owned())
+        .map(|p| p.split_once('&').map(|t| t.0.to_owned()).unwrap_or(p))
+        .unwrap();
+
+    // per_page larger than the number of remain versions
+    let json: VersionList = anon
+        .get_with_query(url, &format!("per_page=5&sort=date&seek={seek}"))
+        .await
+        .good();
+    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=date&seek={seek}"))
+        .await
+        .good();
+    assert_eq!(nums(&json.versions), expects[1..]);
+    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, WzE3Mjg1NjE5OTI3MzQ2NzMsNV0K ([1728561992734673,5]), but doesn't actually exist
+    let json: VersionList = anon
+        .get_with_query(
+            url,
+            "per_page=10&sort=date&seek=WzE3Mjg1NjE5OTI3MzQ2NzMsNV0K",
+        )
+        .await
+        .good();
+    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")]
 async fn invalid_seek_parameter() {
     let (app, anon, user) = TestApp::init().with_user();