models/category: Convert toplevel() and count_toplevel() to async fns

Author: Turbo87

src/controllers/category.rs

@@ -2,14 +2,13 @@ use super::helpers::pagination::*;
 use crate::app::AppState;
 use crate::models::Category;
 use crate::schema::categories;
-use crate::tasks::spawn_blocking;
 use crate::util::errors::AppResult;
 use crate::util::RequestUtils;
 use crate::views::{EncodableCategory, EncodableCategoryWithSubcategories};
 use axum::extract::Path;
 use axum::Json;
 use diesel::QueryDsl;
-use diesel_async::async_connection_wrapper::AsyncConnectionWrapper;
+use diesel_async::RunQueryDsl;
 use http::request::Parts;
 use serde_json::Value;
 
@@ -20,36 +19,30 @@ pub async fn index(app: AppState, req: Parts) -> AppResult<Json<Value>> {
     // to paginate this.
     let options = PaginationOptions::builder().gather(&req)?;
 
-    let conn = app.db_read().await?;
-    spawn_blocking(move || {
-        let conn: &mut AsyncConnectionWrapper<_> = &mut conn.into();
+    let mut conn = app.db_read().await?;
 
-        let query = req.query();
-        let sort = query.get("sort").map_or("alpha", String::as_str);
+    let query = req.query();
+    let sort = query.get("sort").map_or("alpha", String::as_str);
 
-        let offset = options.offset().unwrap_or_default();
+    let offset = options.offset().unwrap_or_default();
 
-        let categories = Category::toplevel(conn, sort, options.per_page, offset)?;
-        let categories = categories
-            .into_iter()
-            .map(Category::into)
-            .collect::<Vec<EncodableCategory>>();
+    let categories = Category::toplevel(&mut conn, sort, options.per_page, offset).await?;
+    let categories = categories
+        .into_iter()
+        .map(Category::into)
+        .collect::<Vec<EncodableCategory>>();
 
-        // Query for the total count of categories
-        let total = Category::count_toplevel(conn)?;
+    // Query for the total count of categories
+    let total = Category::count_toplevel(&mut conn).await?;
 
-        Ok(Json(json!({
-            "categories": categories,
-            "meta": { "total": total },
-        })))
-    })
-    .await
+    Ok(Json(json!({
+        "categories": categories,
+        "meta": { "total": total },
+    })))
 }
 
 /// Handles the `GET /categories/:category_id` route.
 pub async fn show(state: AppState, Path(slug): Path<String>) -> AppResult<Json<Value>> {
-    use diesel_async::RunQueryDsl;
-
     let mut conn = state.db_read().await?;
 
     let cat: Category = Category::by_slug(&slug).first(&mut conn).await?;
@@ -83,8 +76,6 @@ pub async fn show(state: AppState, Path(slug): Path<String>) -> AppResult<Json<V
 
 /// Handles the `GET /category_slugs` route.
 pub async fn slugs(state: AppState) -> AppResult<Json<Value>> {
-    use diesel_async::RunQueryDsl;
-
     let mut conn = state.db_read().await?;
 
     let slugs: Vec<Slug> = categories::table

src/controllers/summary.rs

@@ -14,7 +14,14 @@ use serde_json::Value;
 
 /// Handles the `GET /summary` route.
 pub async fn summary(state: AppState) -> AppResult<Json<Value>> {
-    let conn = state.db_read().await?;
+    let mut conn = state.db_read().await?;
+
+    let popular_categories = Category::toplevel(&mut conn, "crates", 10, 0)
+        .await?
+        .into_iter()
+        .map(Category::into)
+        .collect::<Vec<EncodableCategory>>();
+
     spawn_blocking(move || {
         let conn: &mut AsyncConnectionWrapper<_> = &mut conn.into();
 
@@ -116,11 +123,6 @@ pub async fn summary(state: AppState) -> AppResult<Json<Value>> {
             .map(Keyword::into)
             .collect::<Vec<EncodableKeyword>>();
 
-        let popular_categories = Category::toplevel(conn, "crates", 10, 0)?
-            .into_iter()
-            .map(Category::into)
-            .collect::<Vec<EncodableCategory>>();
-
         Ok(Json(json!({
             "num_downloads": num_downloads,
             "num_crates": num_crates,

src/models/category.rs

@@ -81,22 +81,23 @@ impl Category {
         })
     }
 
-    pub fn count_toplevel(conn: &mut impl Conn) -> QueryResult<i64> {
-        use diesel::RunQueryDsl;
+    pub async fn count_toplevel(conn: &mut AsyncPgConnection) -> QueryResult<i64> {
+        use diesel_async::RunQueryDsl;
         categories::table
             .filter(categories::category.not_like("%::%"))
             .count()
             .get_result(conn)
+            .await
     }
 
-    pub fn toplevel(
-        conn: &mut impl Conn,
+    pub async fn toplevel(
+        conn: &mut AsyncPgConnection,
         sort: &str,
         limit: i64,
         offset: i64,
     ) -> QueryResult<Vec<Category>> {
         use diesel::sql_types::Int8;
-        use diesel::RunQueryDsl;
+        use diesel_async::RunQueryDsl;
 
         let sort_sql = match sort {
             "crates" => "ORDER BY crates_cnt DESC",
@@ -109,6 +110,7 @@ impl Category {
             .bind::<Int8, _>(limit)
             .bind::<Int8, _>(offset)
             .load(conn)
+            .await
     }
 
     pub async fn subcategories(&self, conn: &mut AsyncPgConnection) -> QueryResult<Vec<Category>> {
@@ -152,15 +154,17 @@ pub struct NewCategory<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_util::test_db_connection;
     use crates_io_test_db::TestDatabase;
     use diesel_async::AsyncConnection;
+    use diesel_async::RunQueryDsl;
 
-    #[test]
-    fn category_toplevel_excludes_subcategories() {
+    #[tokio::test]
+    async fn category_toplevel_excludes_subcategories() {
         use self::categories;
-        use diesel::RunQueryDsl;
-        let (_test_db, conn) = &mut test_db_connection();
+
+        let test_db = TestDatabase::new();
+        let mut conn = AsyncPgConnection::establish(test_db.url()).await.unwrap();
+
         insert_into(categories::table)
             .values(&vec![
                 (
@@ -176,10 +180,12 @@ mod tests {
                     categories::slug.eq("cat1::sub"),
                 ),
             ])
-            .execute(conn)
+            .execute(&mut conn)
+            .await
             .unwrap();
 
-        let cats = Category::toplevel(conn, "", 10, 0)
+        let cats = Category::toplevel(&mut conn, "", 10, 0)
+            .await
             .unwrap()
             .into_iter()
             .map(|c| c.category)
@@ -188,10 +194,9 @@ mod tests {
         assert_eq!(expected, cats);
     }
 
-    #[test]
-    fn category_toplevel_orders_by_crates_cnt_when_sort_given() {
+    #[tokio::test]
+    async fn category_toplevel_orders_by_crates_cnt_when_sort_given() {
         use self::categories;
-        use diesel::RunQueryDsl;
 
         let new_cat = |category, slug, crates_cnt| {
             (
@@ -201,17 +206,21 @@ mod tests {
             )
         };
 
-        let (_test_db, conn) = &mut test_db_connection();
+        let test_db = TestDatabase::new();
+        let mut conn = AsyncPgConnection::establish(test_db.url()).await.unwrap();
+
         insert_into(categories::table)
             .values(&vec![
                 new_cat("Cat 1", "cat1", 0),
                 new_cat("Cat 2", "cat2", 2),
                 new_cat("Cat 3", "cat3", 1),
             ])
-            .execute(conn)
+            .execute(&mut conn)
+            .await
             .unwrap();
 
-        let cats = Category::toplevel(conn, "crates", 10, 0)
+        let cats = Category::toplevel(&mut conn, "crates", 10, 0)
+            .await
             .unwrap()
             .into_iter()
             .map(|c| c.category)
@@ -224,11 +233,13 @@ mod tests {
         assert_eq!(expected, cats);
     }
 
-    #[test]
-    fn category_toplevel_applies_limit_and_offset() {
+    #[tokio::test]
+    async fn category_toplevel_applies_limit_and_offset() {
         use self::categories;
-        use diesel::RunQueryDsl;
-        let (_test_db, conn) = &mut test_db_connection();
+
+        let test_db = TestDatabase::new();
+        let mut conn = AsyncPgConnection::establish(test_db.url()).await.unwrap();
+
         insert_into(categories::table)
             .values(&vec![
                 (
@@ -240,18 +251,21 @@ mod tests {
                     categories::slug.eq("cat2"),
                 ),
             ])
-            .execute(conn)
+            .execute(&mut conn)
+            .await
             .unwrap();
 
-        let cats = Category::toplevel(conn, "", 1, 0)
+        let cats = Category::toplevel(&mut conn, "", 1, 0)
+            .await
             .unwrap()
             .into_iter()
             .map(|c| c.category)
             .collect::<Vec<_>>();
         let expected = vec!["Cat 1".to_string()];
         assert_eq!(expected, cats);
 
-        let cats = Category::toplevel(conn, "", 1, 1)
+        let cats = Category::toplevel(&mut conn, "", 1, 1)
+            .await
             .unwrap()
             .into_iter()
             .map(|c| c.category)
@@ -260,10 +274,9 @@ mod tests {
         assert_eq!(expected, cats);
     }
 
-    #[test]
-    fn category_toplevel_includes_subcategories_in_crate_cnt() {
+    #[tokio::test]
+    async fn category_toplevel_includes_subcategories_in_crate_cnt() {
         use self::categories;
-        use diesel::RunQueryDsl;
 
         let new_cat = |category, slug, crates_cnt| {
             (
@@ -273,7 +286,9 @@ mod tests {
             )
         };
 
-        let (_test_db, conn) = &mut test_db_connection();
+        let test_db = TestDatabase::new();
+        let mut conn = AsyncPgConnection::establish(test_db.url()).await.unwrap();
+
         insert_into(categories::table)
             .values(&vec![
                 new_cat("Cat 1", "cat1", 1),
@@ -283,10 +298,12 @@ mod tests {
                 new_cat("Cat 2::Sub 2", "cat2::sub2", 5),
                 new_cat("Cat 3", "cat3", 6),
             ])
-            .execute(conn)
+            .execute(&mut conn)
+            .await
             .unwrap();
 
-        let cats = Category::toplevel(conn, "crates", 10, 0)
+        let cats = Category::toplevel(&mut conn, "crates", 10, 0)
+            .await
             .unwrap()
             .into_iter()
             .map(|c| (c.category, c.crates_cnt))
@@ -299,10 +316,9 @@ mod tests {
         assert_eq!(expected, cats);
     }
 
-    #[test]
-    fn category_toplevel_applies_limit_and_offset_after_grouping() {
+    #[tokio::test]
+    async fn category_toplevel_applies_limit_and_offset_after_grouping() {
         use self::categories;
-        use diesel::RunQueryDsl;
 
         let new_cat = |category, slug, crates_cnt| {
             (
@@ -312,7 +328,9 @@ mod tests {
             )
         };
 
-        let (_test_db, conn) = &mut test_db_connection();
+        let test_db = TestDatabase::new();
+        let mut conn = AsyncPgConnection::establish(test_db.url()).await.unwrap();
+
         insert_into(categories::table)
             .values(&vec![
                 new_cat("Cat 1", "cat1", 1),
@@ -322,18 +340,21 @@ mod tests {
                 new_cat("Cat 2::Sub 2", "cat2::sub2", 5),
                 new_cat("Cat 3", "cat3", 6),
             ])
-            .execute(conn)
+            .execute(&mut conn)
+            .await
             .unwrap();
 
-        let cats = Category::toplevel(conn, "crates", 2, 0)
+        let cats = Category::toplevel(&mut conn, "crates", 2, 0)
+            .await
             .unwrap()
             .into_iter()
             .map(|c| (c.category, c.crates_cnt))
             .collect::<Vec<_>>();
         let expected = vec![("Cat 2".to_string(), 12), ("Cat 3".to_string(), 6)];
         assert_eq!(expected, cats);
 
-        let cats = Category::toplevel(conn, "crates", 2, 1)
+        let cats = Category::toplevel(&mut conn, "crates", 2, 1)
+            .await
             .unwrap()
             .into_iter()
             .map(|c| (c.category, c.crates_cnt))
@@ -345,7 +366,6 @@ mod tests {
     #[tokio::test]
     async fn category_parent_categories_includes_path_to_node_with_count() {
         use self::categories;
-        use diesel_async::RunQueryDsl;
 
         let new_cat = |category, slug, crates_cnt| {
             (