controllers/krate/downloads: Add versions include mode

Author: eth3lbert

src/controllers/krate/downloads.rs

@@ -5,16 +5,35 @@
 
 use crate::app::AppState;
 use crate::controllers::krate::CratePath;
-use crate::models::{Version, VersionDownload};
+use crate::models::{User, Version, VersionDownload, VersionOwnerAction};
 use crate::schema::{version_downloads, versions};
-use crate::util::errors::AppResult;
-use crate::views::EncodableVersionDownload;
+use crate::util::errors::{bad_request, AppResult, BoxedAppError};
+use crate::views::{EncodableVersion, EncodableVersionDownload};
+use axum::extract::FromRequestParts;
+use axum_extra::extract::Query;
 use axum_extra::json;
 use axum_extra::response::ErasedJson;
+use crates_io_database::schema::users;
 use crates_io_diesel_helpers::to_char;
 use diesel::prelude::*;
 use diesel_async::RunQueryDsl;
+use futures_util::FutureExt;
 use std::cmp;
+use std::str::FromStr;
+
+#[derive(Debug, Deserialize, FromRequestParts, utoipa::IntoParams)]
+#[from_request(via(Query))]
+#[into_params(parameter_in = Query)]
+pub struct DownloadsQueryParams {
+    /// Additional data to include in the response.
+    ///
+    /// Valid values: `versions`.
+    ///
+    /// Defaults to no additional data.
+    ///
+    /// This parameter expects a comma-separated list of values.
+    include: Option<String>,
+}
 
 /// Get the download counts for a crate.
 ///
@@ -23,12 +42,16 @@ use std::cmp;
 #[utoipa::path(
     get,
     path = "/api/v1/crates/{name}/downloads",
-    params(CratePath),
+    params(CratePath, DownloadsQueryParams),
     tag = "crates",
     responses((status = 200, description = "Successful Response")),
 )]
 
-pub async fn get_crate_downloads(state: AppState, path: CratePath) -> AppResult<ErasedJson> {
+pub async fn get_crate_downloads(
+    state: AppState,
+    path: CratePath,
+    params: DownloadsQueryParams,
+) -> AppResult<ErasedJson> {
     let mut conn = state.db_read().await?;
 
     use diesel::dsl::*;
@@ -43,9 +66,10 @@ pub async fn get_crate_downloads(state: AppState, path: CratePath) -> AppResult<
         .await?;
 
     versions.sort_by_cached_key(|version| cmp::Reverse(semver::Version::parse(&version.num).ok()));
-    let (latest_five, rest) = versions.split_at(cmp::min(5, versions.len()));
+    let total = versions.len();
+    let (latest_five, rest) = versions.split_at_mut(cmp::min(5, total));
 
-    let downloads = VersionDownload::belonging_to(latest_five)
+    let downloads = VersionDownload::belonging_to(&latest_five[..])
         .filter(version_downloads::date.gt(date(now - 90.days())))
         .order((
             version_downloads::date.asc(),
@@ -58,7 +82,7 @@ pub async fn get_crate_downloads(state: AppState, path: CratePath) -> AppResult<
         .collect::<Vec<EncodableVersionDownload>>();
 
     let sum_downloads = sql::<BigInt>("SUM(version_downloads.downloads)");
-    let extra: Vec<ExtraDownload> = VersionDownload::belonging_to(rest)
+    let extra: Vec<ExtraDownload> = VersionDownload::belonging_to(&rest[..])
         .select((
             to_char(version_downloads::date, "YYYY-MM-DD"),
             sum_downloads,
@@ -75,10 +99,74 @@ pub async fn get_crate_downloads(state: AppState, path: CratePath) -> AppResult<
         downloads: i64,
     }
 
+    let include = params
+        .include
+        .as_ref()
+        .map(|mode| ShowIncludeMode::from_str(mode))
+        .transpose()?
+        .unwrap_or_default();
+
+    if include.versions {
+        latest_five.sort_unstable_by_key(|it| cmp::Reverse(it.id));
+        let ids = latest_five.iter().map(|it| it.id);
+        let versions = latest_five.iter().collect::<Vec<_>>();
+        let (id_and_publishers, actions) = tokio::try_join!(
+            versions::table
+                .left_join(users::table)
+                .select((versions::id, Option::<User>::as_select()))
+                .filter(versions::id.eq_any(ids))
+                .order_by(versions::id.desc())
+                .load::<(i32, Option<User>)>(&mut conn)
+                .boxed(),
+            VersionOwnerAction::for_versions(&mut conn, &versions).boxed()
+        )?;
+        let publishers = id_and_publishers.into_iter().map(|(_, pb)| pb);
+        let versions = versions
+            .into_iter()
+            .cloned()
+            .zip(publishers)
+            .zip(actions)
+            .map(|((v, pb), actions)| EncodableVersion::from(v, &path.name, pb, actions))
+            .collect::<Vec<_>>();
+
+        return Ok(json!({
+            "version_downloads": downloads,
+            "versions": versions,
+            "meta": {
+                "extra_downloads": extra,
+            },
+        }));
+    }
+
     Ok(json!({
         "version_downloads": downloads,
         "meta": {
             "extra_downloads": extra,
         },
     }))
 }
+
+#[derive(Debug, Default)]
+struct ShowIncludeMode {
+    versions: bool,
+}
+
+impl ShowIncludeMode {
+    const INVALID_COMPONENT: &'static str = "invalid component for ?include= (expected 'versions')";
+}
+
+impl FromStr for ShowIncludeMode {
+    type Err = BoxedAppError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut mode = Self { versions: false };
+        for component in s.split(',') {
+            match component {
+                "" => {}
+                "versions" => mode.versions = true,
+                _ => return Err(bad_request(Self::INVALID_COMPONENT)),
+            }
+        }
+        Ok(mode)
+    }
+}