Add a "minimal crate metadata" API endpoint

As mentioned in #4503 and renovatebot/renovate#3486,
this is intended to be a lighter-weight API than /crates/:crate_id, which can be
subject to looser rate limits.

Author: nightkr

src/controllers/krate/metadata.rs

@@ -45,7 +45,7 @@ pub fn summary(req: &mut dyn RequestExt) -> EndpointResult {
             .map(|((top_versions, krate), recent_downloads)| {
                 Ok(EncodableCrate::from_minimal(
                     krate,
-                    &top_versions,
+                    Some(&top_versions),
                     None,
                     false,
                     recent_downloads,
@@ -159,7 +159,7 @@ pub fn show(req: &mut dyn RequestExt) -> EndpointResult {
     Ok(req.json(&json!({
         "crate": EncodableCrate::from(
             krate.clone(),
-            &top_versions,
+            Some(&top_versions),
             Some(ids),
             Some(&kws),
             Some(&cats),
@@ -176,6 +176,26 @@ pub fn show(req: &mut dyn RequestExt) -> EndpointResult {
     })))
 }
 
+/// Handles the `GET /crates/:crate_id/crate` route.
+///
+/// A minimal version of [`show`] that only covers the crate itself, without versions or catalog information
+/// (such as keywords and categories).
+pub fn krate(req: &mut dyn RequestExt) -> EndpointResult {
+    let name = &req.params()["crate_id"];
+    let conn = req.db_read_only()?;
+    let krate: Crate = Crate::by_name(name).first(&*conn)?;
+
+    Ok(req.json(&json!({
+        "crate": EncodableCrate::from_minimal(
+            krate,
+            None,
+            None,
+            false,
+            None,
+        ),
+    })))
+}
+
 /// Handles the `GET /crates/:crate_id/:version/readme` route.
 pub fn readme(req: &mut dyn RequestExt) -> EndpointResult {
     let crate_name = &req.params()["crate_id"];

src/controllers/krate/publish.rs

@@ -252,7 +252,7 @@ pub fn publish(req: &mut dyn RequestExt) -> EndpointResult {
         };
 
         Ok(req.json(&GoodCrate {
-            krate: EncodableCrate::from_minimal(krate, &top_versions, None, false, None),
+            krate: EncodableCrate::from_minimal(krate, Some(&top_versions), None, false, None),
             warnings,
         }))
     })

src/controllers/krate/search.rs

@@ -330,7 +330,7 @@ pub fn search(req: &mut dyn RequestExt) -> EndpointResult {
             |((((max_version, krate), perfect_match), recent_downloads), badges)| {
                 EncodableCrate::from_minimal(
                     krate,
-                    &max_version,
+                    Some(&max_version),
                     Some(badges),
                     perfect_match,
                     Some(recent_downloads),

src/router.rs

@@ -36,6 +36,7 @@ pub fn build_router(app: &App) -> RouteBuilder {
 
     // Routes used by the frontend
     api_router.get("/crates/:crate_id", C(krate::metadata::show));
+    api_router.get("/crates/:crate_id/crate", C(krate::metadata::krate));
     api_router.get("/crates/:crate_id/:version", C(version::metadata::show));
     api_router.get(
         "/crates/:crate_id/:version/readme",

src/views.rs

@@ -238,7 +238,7 @@ impl EncodableCrate {
     #[allow(clippy::too_many_arguments)]
     pub fn from(
         krate: Crate,
-        top_versions: &TopVersions,
+        top_versions: Option<&TopVersions>,
         versions: Option<Vec<i32>>,
         keywords: Option<&[Keyword]>,
         categories: Option<&[Category]>,
@@ -267,18 +267,18 @@ impl EncodableCrate {
         let documentation = Self::remove_blocked_documentation_urls(documentation);
 
         let max_version = top_versions
-            .highest
-            .as_ref()
+            .and_then(|v| v.highest.as_ref())
             .map(|v| v.to_string())
             .unwrap_or_else(|| "0.0.0".to_string());
 
         let newest_version = top_versions
-            .newest
-            .as_ref()
+            .and_then(|v| v.newest.as_ref())
             .map(|v| v.to_string())
             .unwrap_or_else(|| "0.0.0".to_string());
 
-        let max_stable_version = top_versions.highest_stable.as_ref().map(|v| v.to_string());
+        let max_stable_version = top_versions
+            .and_then(|v| v.highest_stable.as_ref())
+            .map(|v| v.to_string());
 
         EncodableCrate {
             id: name.clone(),
@@ -312,7 +312,7 @@ impl EncodableCrate {
 
     pub fn from_minimal(
         krate: Crate,
-        top_versions: &TopVersions,
+        top_versions: Option<&TopVersions>,
         badges: Option<Vec<Badge>>,
         exact_match: bool,
         recent_downloads: Option<i64>,