controllers/krate/metadata: Add support for default_version include mode

This allows us to respond with a version data of `default_version`
included, which potentially benefits apps by eliminating the need to
wait for the crate response to obtain the default version and then make
a subsequent request to get the actual version data. This is
particularly useful when we move towards not requesting with `versions`
included.

Author: eth3lbert

src/controllers/krate/metadata.rs

@@ -118,6 +118,21 @@ pub async fn find_crate(
         .as_ref()
         .map(|vps| vps.iter().map(|v| v.0.id).collect());
 
+    let mut default_version_meta = None;
+    if let Some(default_version) = default_version.as_ref().filter(|_| include.default_version) {
+        // Find the default_version from composed versions to minimize round trips when possible.
+        if let Some(versions) = versions_publishers_and_audit_actions.as_ref() {
+            default_version_meta = versions
+                .iter()
+                .find(|(version, _, _)| version.num.as_str() == default_version)
+                .cloned();
+        } else if let Ok(version) = krate.find_version(&mut conn, default_version).await {
+            let published_by = version.published_by(&mut conn).await?;
+            let actions = VersionOwnerAction::by_version(&mut conn, &version).await?;
+            default_version_meta = Some((version, published_by, actions));
+        }
+    };
+
     let kws = if include.keywords {
         Some(
             CrateKeyword::belonging_to(&krate)
@@ -174,6 +189,8 @@ pub async fn find_crate(
             .map(|(v, pb, aas)| EncodableVersion::from(v, &krate.name, pb, aas))
             .collect::<Vec<_>>()
     });
+    let encodable_default_version =
+        default_version_meta.map(|(v, pb, aas)| EncodableVersion::from(v, &krate.name, pb, aas));
 
     let encodable_keywords = kws.map(|kws| {
         kws.into_iter()
@@ -192,6 +209,7 @@ pub async fn find_crate(
         "versions": encodable_versions,
         "keywords": encodable_keywords,
         "categories": encodable_cats,
+        "default_version": encodable_default_version,
     }))
 }
 
@@ -202,6 +220,7 @@ struct ShowIncludeMode {
     categories: bool,
     badges: bool,
     downloads: bool,
+    default_version: bool,
 }
 
 impl Default for ShowIncludeMode {
@@ -213,13 +232,14 @@ impl Default for ShowIncludeMode {
             categories: true,
             badges: true,
             downloads: true,
+            default_version: false,
         }
     }
 }
 
 impl ShowIncludeMode {
     const INVALID_COMPONENT: &'static str =
-        "invalid component for ?include= (expected 'versions', 'keywords', 'categories', 'badges', 'downloads', or 'full')";
+        "invalid component for ?include= (expected 'versions', 'keywords', 'categories', 'badges', 'downloads', 'default_version', or 'full')";
 }
 
 impl FromStr for ShowIncludeMode {
@@ -232,6 +252,7 @@ impl FromStr for ShowIncludeMode {
             categories: false,
             badges: false,
             downloads: false,
+            default_version: false,
         };
         for component in s.split(',') {
             match component {
@@ -243,13 +264,15 @@ impl FromStr for ShowIncludeMode {
                         categories: true,
                         badges: true,
                         downloads: true,
+                        default_version: true,
                     }
                 }
                 "versions" => mode.versions = true,
                 "keywords" => mode.keywords = true,
                 "categories" => mode.categories = true,
                 "badges" => mode.badges = true,
                 "downloads" => mode.downloads = true,
+                "default_version" => mode.default_version = true,
                 _ => return Err(bad_request(Self::INVALID_COMPONENT)),
             }
         }

src/tests/routes/crates/read.rs

@@ -178,3 +178,43 @@ async fn test_new_name() {
         ".crate.updated_at" => "[datetime]",
     });
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_include_default_version() {
+    let (app, anon, user) = TestApp::init().with_user().await;
+    let mut conn = app.db_conn().await;
+    let user = user.as_model();
+
+    CrateBuilder::new("foo_default_version", user.id)
+        .description("description")
+        .documentation("https://example.com")
+        .homepage("http://example.com")
+        .version(VersionBuilder::new("1.0.0").yanked(true))
+        .version(VersionBuilder::new("0.5.0"))
+        .version(VersionBuilder::new("0.5.1"))
+        .keyword("kw1")
+        .downloads(20)
+        .recent_downloads(10)
+        .expect_build(&mut conn)
+        .await;
+
+    let response = anon
+        .get::<()>("/api/v1/crates/foo_default_version?include=default_version")
+        .await;
+    assert_eq!(response.status(), StatusCode::OK);
+    assert_json_snapshot!(response.json(), {
+        ".crate.created_at" => "[datetime]",
+        ".crate.updated_at" => "[datetime]",
+        ".default_version.created_at" => "[datetime]",
+        ".default_version.updated_at" => "[datetime]",
+    });
+
+    let response_with_versions = anon
+        .get::<()>("/api/v1/crates/foo_default_version?include=versions,default_version")
+        .await;
+    assert_eq!(response_with_versions.status(), StatusCode::OK);
+    assert_eq!(
+        response_with_versions.json().get("default_version"),
+        response.json().get("default_version")
+    );
+}