controllers/krate/versions: Add ShowIncludeMode for pagination

This enables clients to specify the `include` query param to include
`release_tracks` meta.

Author: eth3lbert

src/controllers/krate/versions.rs

@@ -9,14 +9,15 @@ use http::request::Parts;
 use indexmap::{IndexMap, IndexSet};
 use serde_json::Value;
 use std::cmp::Reverse;
+use std::str::FromStr;
 
 use crate::app::AppState;
 use crate::controllers::helpers::pagination::{encode_seek, Page, PaginationOptions};
 use crate::models::{Crate, User, Version, VersionOwnerAction};
 use crate::schema::{crates, users, versions};
 use crate::tasks::spawn_blocking;
 use crate::util::diesel::Conn;
-use crate::util::errors::{crate_not_found, AppResult};
+use crate::util::errors::{bad_request, crate_not_found, AppResult, BoxedAppError};
 use crate::util::RequestUtils;
 use crate::views::EncodableVersion;
 
@@ -48,11 +49,18 @@ pub async fn versions(
             );
         }
 
+        let include = req
+            .query()
+            .get("include")
+            .map(|mode| ShowIncludeMode::from_str(mode))
+            .transpose()?
+            .unwrap_or_default();
+
         // Sort by semver by default
         let versions_and_publishers = match params.get("sort").map(|s| s.to_lowercase()).as_deref()
         {
-            Some("date") => list_by_date(crate_id, pagination.as_ref(), &req, conn)?,
-            _ => list_by_semver(crate_id, pagination.as_ref(), &req, conn)?,
+            Some("date") => list_by_date(crate_id, pagination.as_ref(), include, &req, conn)?,
+            _ => list_by_semver(crate_id, pagination.as_ref(), include, &req, conn)?,
         };
 
         let versions = versions_and_publishers
@@ -84,6 +92,7 @@ pub async fn versions(
 fn list_by_date(
     crate_id: i32,
     options: Option<&PaginationOptions>,
+    include: ShowIncludeMode,
     req: &Parts,
     conn: &mut impl Conn,
 ) -> AppResult<PaginatedVersionsAndPublishers> {
@@ -111,22 +120,24 @@ 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(versions::yanked.ne(true))
-            .select(versions::num)
-            .load_iter::<String, DefaultLoadingMode>(conn)?
-        {
-            let Ok(semver) = semver::Version::parse(&result?) else {
-                continue;
-            };
-            sorted_versions.insert(semver);
+        if include.release_tracks {
+            let mut sorted_versions = IndexSet::new();
+            for result in versions::table
+                .filter(versions::crate_id.eq(crate_id))
+                .filter(versions::yanked.ne(true))
+                .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(),
+            ));
         }
-        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()));
@@ -170,6 +181,7 @@ fn list_by_date(
 fn list_by_semver(
     crate_id: i32,
     options: Option<&PaginationOptions>,
+    include: ShowIncludeMode,
     req: &Parts,
     conn: &mut impl Conn,
 ) -> AppResult<PaginatedVersionsAndPublishers> {
@@ -200,12 +212,16 @@ fn list_by_semver(
             !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 release_tracks = include.release_tracks.then(|| {
+            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
@@ -435,6 +451,39 @@ impl serde::Serialize for SemverTriple {
     }
 }
 
+#[derive(Debug, Default)]
+struct ShowIncludeMode {
+    release_tracks: bool,
+}
+
+impl ShowIncludeMode {
+    const INVALID_COMPONENT: &'static str =
+        "invalid component for ?include= (expected 'release_tracks', or 'full')";
+}
+
+impl FromStr for ShowIncludeMode {
+    type Err = BoxedAppError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut mode = Self {
+            release_tracks: false,
+        };
+        for component in s.split(',') {
+            match component {
+                "" => {}
+                "full" => {
+                    mode = Self {
+                        release_tracks: true,
+                    }
+                }
+                "release_tracks" => mode.release_tracks = true,
+                _ => return Err(bad_request(Self::INVALID_COMPONENT)),
+            }
+        }
+        Ok(mode)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::{HighestSemver, ReleaseSlug, ReleaseTracks};

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

@@ -86,9 +86,6 @@ async fn test_sorting() {
             .expect_build(conn);
     });
 
-    // Sort by semver
-    let url = "/api/v1/crates/foo_versions/versions?sort=semver";
-    let json: AllVersions = anon.get(url).await.good();
     let expects = [
         "2.0.0-alpha",
         "1.0.0",
@@ -100,19 +97,26 @@ async fn test_sorting() {
         "1.0.0-alpha.1",
         "1.0.0-alpha",
     ];
+    let release_tracks = Some(json!({"1.x": {"highest": "1.0.0"}}));
+
+    // 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);
     }
-    let (resp, calls) = page_with_seek(&anon, url).await;
-    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"}}))
-        );
+    for (url, release_tracks) in [
+        (url, None),
+        (&format!("{url}&include=release_tracks"), release_tracks.as_ref()),
+    ] {
+        let (resp, calls) = page_with_seek(&anon, url).await;
+        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.as_ref(), release_tracks);
+        }
+        assert_eq!(calls as usize, expects.len() + 1);
     }
-    assert_eq!(calls as usize, expects.len() + 1);
 
     // Sort by date
     let url = "/api/v1/crates/foo_versions/versions?sort=date";
@@ -121,16 +125,19 @@ async fn test_sorting() {
     for (num, expect) in nums(&json.versions).iter().zip(&expects) {
         assert_eq!(num, *expect);
     }
-    let (resp, calls) = page_with_seek(&anon, url).await;
-    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"}}))
-        );
+    for (url, release_tracks) in [
+        (url, None),
+        (&format!("{url}&include=release_tracks"), release_tracks.as_ref()),
+    ] {
+        let (resp, calls) = page_with_seek(&anon, url).await;
+        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.as_ref(), release_tracks);
+        }
+        assert_eq!(calls as usize, expects.len() + 1);
     }
-    assert_eq!(calls as usize, expects.len() + 1);
+
 }
 
 #[tokio::test(flavor = "multi_thread")]
@@ -167,10 +174,10 @@ 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);
+    assert_eq!(json.meta.release_tracks, None);
 
     let json: VersionList = anon
-        .get_with_query(url, "per_page=1&sort=semver")
+        .get_with_query(url, "per_page=1&sort=semver&include=release_tracks")
         .await
         .good();
     assert_eq!(nums(&json.versions), expects[0..1]);
@@ -192,7 +199,7 @@ 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);
+    assert_eq!(json.meta.release_tracks, None);
 
     // per_page euqal to the number of remain versions
     let json: VersionList = anon
@@ -202,7 +209,7 @@ async fn test_seek_based_pagination_semver_sorting() {
     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);
+    assert_eq!(json.meta.release_tracks, None);
 
     // A decodable seek value, MTAwCg (100), but doesn't actually exist
     let json: VersionList = anon
@@ -212,7 +219,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);
+    assert_eq!(json.meta.release_tracks, None);
 }
 
 #[tokio::test(flavor = "multi_thread")]
@@ -249,10 +256,10 @@ async fn test_seek_based_pagination_date_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);
+    assert_eq!(json.meta.release_tracks, None);
 
     let json: VersionList = anon
-        .get_with_query(url, "per_page=1&sort=date")
+        .get_with_query(url, "per_page=1&sort=date&include=release_tracks")
         .await
         .good();
     assert_eq!(nums(&json.versions), expects[0..1]);
@@ -274,7 +281,7 @@ async fn test_seek_based_pagination_date_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);
+    assert_eq!(json.meta.release_tracks, None);
 
     // per_page euqal to the number of remain versions
     let json: VersionList = anon
@@ -284,7 +291,7 @@ async fn test_seek_based_pagination_date_sorting() {
     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);
+    assert_eq!(json.meta.release_tracks, None);
 
     // A decodable seek value, WzE3Mjg1NjE5OTI3MzQ2NzMsNV0K ([1728561992734673,5]), but doesn't actually exist
     let json: VersionList = anon
@@ -297,7 +304,7 @@ async fn test_seek_based_pagination_date_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);
+    assert_eq!(json.meta.release_tracks, None);
 }
 
 #[tokio::test(flavor = "multi_thread")]