move shared crate-details functions into database crate

Author: syphar

Cargo.lock

@@ -144,16 +144,19 @@ struct DeserializedMetadata {
 #[derive(Deserialize)]
 struct DeserializedResolve {
     root: String,
+    #[allow(dead_code)]
     nodes: Vec<DeserializedResolveNode>,
 }
 
 #[derive(Deserialize)]
+#[allow(dead_code)]
 struct DeserializedResolveNode {
     id: String,
     deps: Vec<DeserializedResolveDep>,
 }
 
 #[derive(Deserialize)]
 struct DeserializedResolveDep {
+    #[allow(dead_code)]
     pkg: String,
 }

crates/lib/docs_rs_cargo_metadata/src/metadata.rs

@@ -6,8 +6,10 @@ build = "build.rs"
 
 [dependencies]
 anyhow = { workspace = true }
+chrono = { workspace = true }
 docs_rs_env_vars = { path = "../docs_rs_env_vars" }
 docs_rs_opentelemetry = { path = "../docs_rs_opentelemetry" }
+docs_rs_types = { path = "../docs_rs_types" }
 futures-util = { workspace = true }
 hex = "0.4.3"
 opentelemetry = { workspace = true }

crates/lib/docs_rs_database/.sqlx/query-1e660947261dfa1a5d1745d1732df59e0cf67ef1906da818086d063e6a0e21c6.json

@@ -0,0 +1,116 @@
+use anyhow::Result;
+use chrono::{DateTime, Utc};
+use futures_util::TryStreamExt as _;
+use serde_json::Value;
+use docs_rs_types::{BuildStatus, CrateId, ReleaseId, Version};
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Release {
+    pub id: ReleaseId,
+    pub version: Version,
+    #[allow(clippy::doc_overindented_list_items)]
+    /// Aggregated build status of the release.
+    /// * no builds -> build In progress
+    /// * any build is successful -> Success
+    ///   -> even with failed or in-progress builds we have docs to show
+    /// * any build is failed -> Failure
+    ///   -> we can only have Failure or InProgress here, so the Failure is the
+    ///      important part on this aggregation level.
+    /// * the rest is all builds are in-progress -> InProgress
+    ///   -> if we have any builds, and the previous conditions don't match, we end
+    ///      up here, but we still check.
+    ///
+    /// calculated in a database view : `release_build_status`
+    pub build_status: BuildStatus,
+    pub yanked: Option<bool>,
+    pub is_library: Option<bool>,
+    pub rustdoc_status: Option<bool>,
+    pub target_name: Option<String>,
+    pub default_target: Option<String>,
+    pub doc_targets: Option<Vec<String>>,
+    pub release_time: Option<DateTime<Utc>>,
+}
+
+pub fn parse_doc_targets(targets: Value) -> Vec<String> {
+    let mut targets: Vec<String> = serde_json::from_value(targets).unwrap_or_default();
+    targets.sort_unstable();
+    targets
+}
+
+/// Return all releases for a crate, sorted in descending order by semver
+pub async fn releases_for_crate(
+    conn: &mut sqlx::PgConnection,
+    crate_id: CrateId,
+) -> Result<Vec<Release>, anyhow::Error> {
+    let mut releases: Vec<Release> = sqlx::query!(
+        r#"SELECT
+             releases.id as "id: ReleaseId",
+             releases.version as "version: Version",
+             release_build_status.build_status as "build_status!: BuildStatus",
+             releases.yanked,
+             releases.is_library,
+             releases.rustdoc_status,
+             releases.release_time,
+             releases.target_name,
+             releases.default_target,
+             releases.doc_targets
+         FROM releases
+         INNER JOIN release_build_status ON releases.id = release_build_status.rid
+         WHERE
+             releases.crate_id = $1"#,
+        crate_id.0,
+    )
+    .fetch(&mut *conn)
+    .try_filter_map(|row| async move {
+        Ok(Some(Release {
+            id: row.id,
+            version: row.version,
+            build_status: row.build_status,
+            yanked: row.yanked,
+            is_library: row.is_library,
+            rustdoc_status: row.rustdoc_status,
+            target_name: row.target_name,
+            default_target: row.default_target,
+            doc_targets: row.doc_targets.map(parse_doc_targets),
+            release_time: row.release_time,
+        }))
+    })
+    .try_collect()
+    .await?;
+
+    releases.sort_by(|a, b| b.version.cmp(&a.version));
+    Ok(releases)
+}
+
+pub fn latest_release(releases: &[Release]) -> Option<&Release> {
+    if let Some(release) = releases.iter().find(|release| {
+        release.version.pre.is_empty()
+            && release.yanked == Some(false)
+            && release.build_status != BuildStatus::InProgress
+    }) {
+        Some(release)
+    } else {
+        releases
+            .iter()
+            .find(|release| release.build_status != BuildStatus::InProgress)
+    }
+}
+
+pub async fn update_latest_version_id(
+    conn: &mut sqlx::PgConnection,
+    crate_id: CrateId,
+) -> Result<()> {
+    let releases = releases_for_crate(conn, crate_id).await?;
+
+    sqlx::query!(
+        "UPDATE crates
+         SET latest_version_id = $2
+         WHERE id = $1",
+        crate_id.0,
+        latest_release(&releases).map(|release| release.id.0),
+    )
+    .execute(&mut *conn)
+    .await?;
+
+    Ok(())
+}

crates/lib/docs_rs_database/.sqlx/query-4894c7d8c4e354dca1d952362b2e0cb25441e8e65b273e01ed86d2d3ecebfe84.json

@@ -1,4 +1,5 @@
 mod config;
+pub mod crate_details;
 mod errors;
 mod metrics;
 mod migrations;

crates/lib/docs_rs_database/Cargo.toml

@@ -10,7 +10,10 @@ use docs_rs::{
         list_crate_priorities, queue_builder, remove_crate_priority, set_crate_priority,
     },
 };
-use docs_rs_database::service_config::{ConfigName, get_config, set_config};
+use docs_rs_database::{
+    crate_details,
+    service_config::{ConfigName, get_config, set_config},
+};
 use docs_rs_storage::add_path_into_database;
 use docs_rs_types::{CrateId, Version};
 use futures_util::StreamExt;
@@ -533,7 +536,7 @@ impl DatabaseSubcommand {
 
                         println!("handling crate {}", row.name);
 
-                        db::update_latest_version_id(&mut update_conn, row.id).await?;
+                        crate_details::update_latest_version_id(&mut update_conn, row.id).await?;
                     }
 
                     Ok::<(), anyhow::Error>(())