controllers/version: Convert version_and_crate() to async

src/controllers/version.rs

@@ -2,24 +2,26 @@ pub mod downloads;
 pub mod metadata;
 pub mod yank;
 
+use diesel_async::AsyncPgConnection;
+
 use crate::models::{Crate, Version};
-use crate::util::diesel::Conn;
 use crate::util::errors::{crate_not_found, AppResult};
 
-fn version_and_crate(
-    conn: &mut impl Conn,
+async fn version_and_crate(
+    conn: &mut AsyncPgConnection,
     crate_name: &str,
     semver: &str,
 ) -> AppResult<(Version, Crate)> {
-    use crate::util::diesel::prelude::*;
-    use diesel::RunQueryDsl;
+    use diesel::prelude::*;
+    use diesel_async::RunQueryDsl;
 
     let krate: Crate = Crate::by_name(crate_name)
         .first(conn)
+        .await
         .optional()?
         .ok_or_else(|| crate_not_found(crate_name))?;
 
-    let version = krate.find_version(conn, semver)?;
+    let version = krate.find_version(conn, semver).await?;
 
     Ok((version, krate))
 }

src/controllers/version/downloads.rs

@@ -45,14 +45,13 @@ pub async fn downloads(
         return Err(version_not_found(&crate_name, &version));
     }
 
-    let conn = app.db_read().await?;
+    let mut conn = app.db_read().await?;
+    let (version, _) = version_and_crate(&mut conn, &crate_name, &version).await?;
     spawn_blocking(move || {
         use diesel::RunQueryDsl;
 
         let conn: &mut AsyncConnectionWrapper<_> = &mut conn.into();
 
-        let (version, _) = version_and_crate(conn, &crate_name, &version)?;
-
         let cutoff_end_date = req
             .query()
             .get("before_date")

src/controllers/version/metadata.rs

@@ -58,11 +58,11 @@ pub async fn dependencies(
         return Err(version_not_found(&crate_name, &version));
     }
 
-    let conn = state.db_read().await?;
+    let mut conn = state.db_read().await?;
+    let (version, _) = version_and_crate(&mut conn, &crate_name, &version).await?;
     spawn_blocking(move || {
         let conn: &mut AsyncConnectionWrapper<_> = &mut conn.into();
 
-        let (version, _) = version_and_crate(conn, &crate_name, &version)?;
         let deps = version.dependencies(conn)?;
         let deps = deps
             .into_iter()
@@ -97,11 +97,11 @@ pub async fn show(
         return Err(version_not_found(&crate_name, &version));
     }
 
-    let conn = state.db_read().await?;
+    let mut conn = state.db_read().await?;
+    let (version, krate) = version_and_crate(&mut conn, &crate_name, &version).await?;
     spawn_blocking(move || {
         let conn: &mut AsyncConnectionWrapper<_> = &mut conn.into();
 
-        let (version, krate) = version_and_crate(conn, &crate_name, &version)?;
         let published_by = version.published_by(conn);
         let actions = VersionOwnerAction::by_version(conn, &version)?;
 
@@ -124,10 +124,10 @@ pub async fn update(
         return Err(version_not_found(&crate_name, &version));
     }
 
-    let conn = state.db_write().await?;
+    let mut conn = state.db_write().await?;
+    let (mut version, krate) = version_and_crate(&mut conn, &crate_name, &version).await?;
     spawn_blocking(move || {
         let conn: &mut AsyncConnectionWrapper<_> = &mut conn.into();
-        let (mut version, krate) = version_and_crate(conn, &crate_name, &version)?;
 
         validate_yank_update(&update_request.version, &version)?;
         perform_version_yank_update(

src/controllers/version/yank.rs

@@ -52,10 +52,10 @@ async fn modify_yank(
         return Err(version_not_found(&crate_name, &version));
     }
 
-    let conn = state.db_write().await?;
+    let mut conn = state.db_write().await?;
+    let (mut version, krate) = version_and_crate(&mut conn, &crate_name, &version).await?;
     spawn_blocking(move || {
         let conn: &mut AsyncConnectionWrapper<_> = &mut conn.into();
-        let (mut version, krate) = version_and_crate(conn, &crate_name, &version)?;
         perform_version_yank_update(&state, &req, conn, &mut version, &krate, Some(yanked), None)?;
         ok_true()
     })

src/models/krate.rs

@@ -3,6 +3,7 @@ use diesel::associations::Identifiable;
 use diesel::dsl;
 use diesel::pg::Pg;
 use diesel::sql_types::{Bool, Text};
+use diesel_async::AsyncPgConnection;
 use secrecy::SecretString;
 use thiserror::Error;
 
@@ -195,12 +196,17 @@ impl Crate {
         crates::table.select(Self::as_select())
     }
 
-    pub fn find_version(&self, conn: &mut impl Conn, version: &str) -> AppResult<Version> {
-        use diesel::RunQueryDsl;
+    pub async fn find_version(
+        &self,
+        conn: &mut AsyncPgConnection,
+        version: &str,
+    ) -> AppResult<Version> {
+        use diesel_async::RunQueryDsl;
 
         Version::belonging_to(self)
             .filter(versions::num.eq(version))
             .first(conn)
+            .await
             .optional()?
             .ok_or_else(|| version_not_found(&self.name, version))
     }