controllers/crate_owner_invitation: Remove spawn_blocking() usages

Removes `spawn_blocking()` usage from
`PUT /api/v1/me/crate_owner_invitations/:crate_id` and
`PUT /api/v1/me/crate_owner_invitations/accept/:token` endpoints.

Converts `CrateOwnerInvitation::accept()` and
`CrateOwnerInvitation::decline()` to async fns.

Author: eth3lbert

src/controllers/crate_owner_invitation.rs

@@ -290,20 +290,16 @@ pub async fn handle_invite(state: AppState, req: BytesRequest) -> AppResult<Json
         .user_id();
     let invitation =
         CrateOwnerInvitation::find_by_id(user_id, crate_invite.crate_id, &mut conn).await?;
-    spawn_blocking(move || {
-        let conn: &mut AsyncConnectionWrapper<_> = &mut conn.into();
 
-        let config = &state.config;
+    let config = &state.config;
 
-        if crate_invite.accepted {
-            invitation.accept(conn, config)?;
-        } else {
-            invitation.decline(conn)?;
-        }
+    if crate_invite.accepted {
+        invitation.accept(&mut conn, config).await?;
+    } else {
+        invitation.decline(&mut conn).await?;
+    }
 
-        Ok(Json(json!({ "crate_owner_invitation": crate_invite })))
-    })
-    .await
+    Ok(Json(json!({ "crate_owner_invitation": crate_invite })))
 }
 
 /// Handles the `PUT /api/v1/me/crate_owner_invitations/accept/:token` route.
@@ -313,20 +309,16 @@ pub async fn handle_invite_with_token(
 ) -> AppResult<Json<Value>> {
     let mut conn = state.db_write().await?;
     let invitation = CrateOwnerInvitation::find_by_token(&token, &mut conn).await?;
-    spawn_blocking(move || {
-        let conn: &mut AsyncConnectionWrapper<_> = &mut conn.into();
 
-        let config = &state.config;
+    let config = &state.config;
 
-        let crate_id = invitation.crate_id;
-        invitation.accept(conn, config)?;
+    let crate_id = invitation.crate_id;
+    invitation.accept(&mut conn, config).await?;
 
-        Ok(Json(json!({
-            "crate_owner_invitation": {
-                "crate_id": crate_id,
-                "accepted": true,
-            },
-        })))
-    })
-    .await
+    Ok(Json(json!({
+        "crate_owner_invitation": {
+            "crate_id": crate_id,
+            "accepted": true,
+        },
+    })))
 }

src/models/crate_owner_invitation.rs

@@ -110,14 +110,20 @@ impl CrateOwnerInvitation {
             .await
     }
 
-    pub fn accept(self, conn: &mut impl Conn, config: &config::Server) -> AppResult<()> {
-        use diesel::RunQueryDsl;
+    pub async fn accept(
+        self,
+        conn: &mut AsyncPgConnection,
+        config: &config::Server,
+    ) -> AppResult<()> {
+        use diesel_async::scoped_futures::ScopedFutureExt;
+        use diesel_async::{AsyncConnection, RunQueryDsl};
 
         if self.is_expired(config) {
             let crate_name: String = crates::table
                 .find(self.crate_id)
                 .select(crates::name)
-                .first(conn)?;
+                .first(conn)
+                .await?;
 
             let detail = format!(
                 "The invitation to become an owner of the {crate_name} crate expired. \
@@ -128,33 +134,38 @@ impl CrateOwnerInvitation {
         }
 
         conn.transaction(|conn| {
-            diesel::insert_into(crate_owners::table)
-                .values(&CrateOwner {
-                    crate_id: self.crate_id,
-                    owner_id: self.invited_user_id,
-                    created_by: self.invited_by_user_id,
-                    owner_kind: OwnerKind::User,
-                    email_notifications: true,
-                })
-                .on_conflict(crate_owners::table.primary_key())
-                .do_update()
-                .set(crate_owners::deleted.eq(false))
-                .execute(conn)?;
-
-            diesel::delete(&self).execute(conn)?;
-
-            Ok(())
+            async move {
+                diesel::insert_into(crate_owners::table)
+                    .values(&CrateOwner {
+                        crate_id: self.crate_id,
+                        owner_id: self.invited_user_id,
+                        created_by: self.invited_by_user_id,
+                        owner_kind: OwnerKind::User,
+                        email_notifications: true,
+                    })
+                    .on_conflict(crate_owners::table.primary_key())
+                    .do_update()
+                    .set(crate_owners::deleted.eq(false))
+                    .execute(conn)
+                    .await?;
+
+                diesel::delete(&self).execute(conn).await?;
+
+                Ok(())
+            }
+            .scope_boxed()
         })
+        .await
     }
 
-    pub fn decline(self, conn: &mut impl Conn) -> QueryResult<()> {
-        use diesel::RunQueryDsl;
+    pub async fn decline(self, conn: &mut AsyncPgConnection) -> QueryResult<()> {
+        use diesel_async::RunQueryDsl;
 
         // The check to prevent declining expired invitations is *explicitly* missing. We do not
         // care if an expired invitation is declined, as that just removes the invitation from the
         // database.
 
-        diesel::delete(&self).execute(conn)?;
+        diesel::delete(&self).execute(conn).await?;
         Ok(())
     }