controllers/krate/downloads: Add versions include mode

Author: eth3lbert

src/controllers/krate/downloads.rs

@@ -6,17 +6,36 @@
 use crate::app::AppState;
 use crate::controllers::krate::CratePath;
 use crate::models::download::Version;
-use crate::models::VersionDownload;
-use crate::schema::{version_downloads, versions};
-use crate::util::errors::AppResult;
-use crate::views::EncodableVersionDownload;
+use crate::models::{User, Version as FullVersion, VersionDownload, VersionOwnerAction};
+use crate::schema::{version_downloads, version_owner_actions, versions};
+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 diesel_async::{AsyncPgConnection, RunQueryDsl};
+use futures_util::future::BoxFuture;
 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.
 ///
@@ -25,12 +44,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::*;
@@ -47,8 +70,15 @@ pub async fn get_crate_downloads(state: AppState, path: CratePath) -> AppResult<
     versions.sort_unstable_by(|a, b| b.num.cmp(&a.num));
     let (latest_five, rest) = versions.split_at(cmp::min(5, versions.len()));
 
+    let include = params
+        .include
+        .as_ref()
+        .map(|mode| ShowIncludeMode::from_str(mode))
+        .transpose()?
+        .unwrap_or_default();
+
     let sum_downloads = sql::<BigInt>("SUM(version_downloads.downloads)");
-    let (downloads, extra) = tokio::try_join!(
+    let (downloads, extra, versions_and_publishers, actions) = tokio::try_join!(
         VersionDownload::belonging_to(latest_five)
             .filter(version_downloads::date.gt(date(now - 90.days())))
             .order((
@@ -67,6 +97,8 @@ pub async fn get_crate_downloads(state: AppState, path: CratePath) -> AppResult<
             .order(version_downloads::date.asc())
             .load::<ExtraDownload>(&mut conn)
             .boxed(),
+        load_versions_and_publishers(&mut conn, latest_five, include.versions),
+        load_actions(&mut conn, latest_five, include.versions),
     )?;
 
     let downloads = downloads
@@ -80,10 +112,88 @@ pub async fn get_crate_downloads(state: AppState, path: CratePath) -> AppResult<
         downloads: i64,
     }
 
+    if include.versions {
+        let versions_and_publishers = versions_and_publishers.grouped_by(latest_five);
+        let actions = actions.grouped_by(latest_five);
+        let versions = versions_and_publishers
+            .into_iter()
+            .zip(actions)
+            .filter_map(|(vp, actions)| {
+                vp.into_iter().next().map(|(version, publisher)| {
+                    EncodableVersion::from(version, &path.name, publisher, actions)
+                })
+            })
+            .collect::<Vec<_>>();
+
+        return Ok(json!({
+            "version_downloads": downloads,
+            "versions": versions,
+            "meta": {
+                "extra_downloads": extra,
+            },
+        }));
+    }
+
     Ok(json!({
         "version_downloads": downloads,
         "meta": {
             "extra_downloads": extra,
         },
     }))
 }
+
+type VersionsAndPublishers = (FullVersion, Option<User>);
+fn load_versions_and_publishers<'a>(
+    conn: &mut AsyncPgConnection,
+    versions: &'a [Version],
+    includes: bool,
+) -> BoxFuture<'a, QueryResult<Vec<VersionsAndPublishers>>> {
+    if !includes {
+        return futures_util::future::always_ready(|| Ok(vec![])).boxed();
+    }
+    FullVersion::belonging_to(versions)
+        .left_outer_join(users::table)
+        .select(VersionsAndPublishers::as_select())
+        .load(conn)
+        .boxed()
+}
+
+fn load_actions<'a>(
+    conn: &mut AsyncPgConnection,
+    versions: &'a [Version],
+    includes: bool,
+) -> BoxFuture<'a, QueryResult<Vec<(VersionOwnerAction, User)>>> {
+    if !includes {
+        return futures_util::future::always_ready(|| Ok(vec![])).boxed();
+    }
+    VersionOwnerAction::belonging_to(versions)
+        .inner_join(users::table)
+        .order(version_owner_actions::id)
+        .load(conn)
+        .boxed()
+}
+
+#[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)
+    }
+}

src/models/action.rs

@@ -41,6 +41,7 @@ impl From<VersionAction> for String {
     belongs_to(Version),
     belongs_to(User, foreign_key = user_id),
     belongs_to(ApiToken, foreign_key = api_token_id),
+    belongs_to(crate::models::download::Version, foreign_key = version_id),
 )]
 pub struct VersionOwnerAction {
     pub id: i32,

src/models/version.rs

@@ -13,7 +13,7 @@ use crate::schema::*;
 
 // Queryable has a custom implementation below
 #[derive(Clone, Identifiable, Associations, Debug, Queryable, Selectable)]
-#[diesel(belongs_to(Crate))]
+#[diesel(belongs_to(Crate), belongs_to(crate::models::download::Version, foreign_key=id))]
 pub struct Version {
     pub id: i32,
     pub crate_id: i32,

src/snapshots/crates_io__openapi__tests__openapi_snapshot.snap

@@ -564,6 +564,15 @@ expression: response.json()
             "schema": {
               "type": "string"
             }
+          },
+          {
+            "description": "Additional data to include in the response.\n\nValid values: `versions`.\n\nDefaults to no additional data.\n\nThis parameter expects a comma-separated list of values.",
+            "in": "query",
+            "name": "include",
+            "required": false,
+            "schema": {
+              "type": "string"
+            }
           }
         ],
         "responses": {