models/user: Remove sync fns

Author: Turbo87

src/bin/crates-admin/delete_crate.rs

@@ -61,7 +61,7 @@ pub async fn run(opts: Opts) -> anyhow::Result<()> {
         .await
         .context("Failed to look up crate name from the database")?;
 
-    let deleted_by = User::async_find_by_login(&mut conn, &opts.deleted_by)
+    let deleted_by = User::find_by_login(&mut conn, &opts.deleted_by)
         .await
         .context("Failed to look up `--deleted-by` user from the database")?;
 

src/controllers/github/secret_scanning.rs

@@ -187,7 +187,7 @@ async fn send_notification_email(
         .await
         .context("Failed to find user")?;
 
-    let Some(recipient) = user.async_email(conn).await? else {
+    let Some(recipient) = user.email(conn).await? else {
         return Err(anyhow!("No address found"));
     };
 

src/controllers/krate/owners.rs

@@ -188,7 +188,7 @@ async fn modify_owners(
                                 ));
 
                                 if let Some(recipient) =
-                                    invitee.async_verified_email(conn).await.ok().flatten()
+                                    invitee.verified_email(conn).await.ok().flatten()
                                 {
                                     emails.push(OwnerInviteEmail {
                                         recipient_email_address: recipient,

src/controllers/krate/publish.rs

@@ -118,7 +118,7 @@ pub async fn publish(app: AppState, req: BytesRequest) -> AppResult<Json<GoodCra
         .check(&req, &mut conn)
         .await?;
 
-    let verified_email_address = auth.user().async_verified_email(&mut conn).await?;
+    let verified_email_address = auth.user().verified_email(&mut conn).await?;
     let verified_email_address = verified_email_address.ok_or_else(|| {
         bad_request(format!(
             "A verified email address is required to publish crates to crates.io. \

src/controllers/token.rs

@@ -132,7 +132,7 @@ pub async fn new(
         .transpose()
         .map_err(|_err| bad_request("invalid endpoint scope"))?;
 
-    let recipient = user.async_email(&mut conn).await?;
+    let recipient = user.email(&mut conn).await?;
 
     let api_token = ApiToken::insert_with_scopes(
         &mut conn,

src/controllers/user/update.rs

@@ -50,7 +50,7 @@ pub async fn update_user(
                 .await?;
 
             if !publish_notifications {
-                let email_address = user.async_verified_email(&mut conn).await?;
+                let email_address = user.verified_email(&mut conn).await?;
 
                 if let Some(email_address) = email_address {
                     let email = PublishNotificationsUnsubscribeEmail {

src/models/owner.rs

@@ -71,7 +71,7 @@ impl Owner {
                 Team::create_or_update(app, conn, name, req_user).await?,
             ))
         } else {
-            User::async_find_by_login(conn, name)
+            User::find_by_login(conn, name)
                 .await
                 .optional()?
                 .map(Owner::User)

src/models/user.rs

@@ -1,6 +1,7 @@
 use chrono::NaiveDateTime;
+use diesel::prelude::*;
 use diesel_async::scoped_futures::ScopedFutureExt;
-use diesel_async::{AsyncConnection, AsyncPgConnection};
+use diesel_async::{AsyncConnection, AsyncPgConnection, RunQueryDsl};
 use secrecy::SecretString;
 
 use crate::app::App;
@@ -11,8 +12,6 @@ use crate::util::errors::AppResult;
 use crate::models::{Crate, CrateOwner, Email, NewEmail, Owner, OwnerKind, Rights};
 use crate::schema::{crate_owners, emails, users};
 use crate::sql::lower;
-use crate::util::diesel::prelude::*;
-use crate::util::diesel::Conn;
 
 /// The model representing a row in the `users` database table.
 #[derive(Clone, Debug, PartialEq, Eq, Queryable, Identifiable, AsChangeset, Selectable)]
@@ -31,27 +30,10 @@ pub struct User {
 
 impl User {
     pub async fn find(conn: &mut AsyncPgConnection, id: i32) -> QueryResult<User> {
-        use diesel_async::RunQueryDsl;
-
         users::table.find(id).first(conn).await
     }
 
-    pub fn find_by_login(conn: &mut impl Conn, login: &str) -> QueryResult<User> {
-        use diesel::RunQueryDsl;
-
-        users::table
-            .filter(lower(users::gh_login).eq(login.to_lowercase()))
-            .filter(users::gh_id.ne(-1))
-            .order(users::gh_id.desc())
-            .first(conn)
-    }
-
-    pub async fn async_find_by_login(
-        conn: &mut AsyncPgConnection,
-        login: &str,
-    ) -> QueryResult<User> {
-        use diesel_async::RunQueryDsl;
-
+    pub async fn find_by_login(conn: &mut AsyncPgConnection, login: &str) -> QueryResult<User> {
         users::table
             .filter(lower(users::gh_login).eq(login.to_lowercase()))
             .filter(users::gh_id.ne(-1))
@@ -61,8 +43,6 @@ impl User {
     }
 
     pub async fn owning(krate: &Crate, conn: &mut AsyncPgConnection) -> QueryResult<Vec<Owner>> {
-        use diesel_async::RunQueryDsl;
-
         let users = CrateOwner::by_owner_kind(OwnerKind::User)
             .inner_join(users::table)
             .select(User::as_select())
@@ -104,24 +84,10 @@ impl User {
 
     /// Queries the database for the verified emails
     /// belonging to a given user
-    pub fn verified_email(&self, conn: &mut impl Conn) -> QueryResult<Option<String>> {
-        use diesel::RunQueryDsl;
-
-        Email::belonging_to(self)
-            .select(emails::email)
-            .filter(emails::verified.eq(true))
-            .first(conn)
-            .optional()
-    }
-
-    /// Queries the database for the verified emails
-    /// belonging to a given user
-    pub async fn async_verified_email(
+    pub async fn verified_email(
         &self,
         conn: &mut AsyncPgConnection,
     ) -> QueryResult<Option<String>> {
-        use diesel_async::RunQueryDsl;
-
         Email::belonging_to(self)
             .select(emails::email)
             .filter(emails::verified.eq(true))
@@ -131,19 +97,7 @@ impl User {
     }
 
     /// Queries for the email belonging to a particular user
-    pub fn email(&self, conn: &mut impl Conn) -> QueryResult<Option<String>> {
-        use diesel::RunQueryDsl;
-
-        Email::belonging_to(self)
-            .select(emails::email)
-            .first(conn)
-            .optional()
-    }
-
-    /// Queries for the email belonging to a particular user
-    pub async fn async_email(&self, conn: &mut AsyncPgConnection) -> QueryResult<Option<String>> {
-        use diesel_async::RunQueryDsl;
-
+    pub async fn email(&self, conn: &mut AsyncPgConnection) -> QueryResult<Option<String>> {
         Email::belonging_to(self)
             .select(emails::email)
             .first(conn)
@@ -191,7 +145,6 @@ impl<'a> NewUser<'a> {
         use diesel::insert_into;
         use diesel::pg::upsert::excluded;
         use diesel::sql_types::Integer;
-        use diesel_async::RunQueryDsl;
 
         conn.transaction(|conn| {
             async move {

src/worker/jobs/expiry_notification.rs

@@ -75,7 +75,7 @@ async fn handle_expiring_token(
     let user = User::find(conn, token.user_id).await?;
 
     debug!("Looking up email address for user {}…", user.id);
-    let recipient = user.async_email(conn).await?;
+    let recipient = user.email(conn).await?;
     if let Some(recipient) = recipient {
         debug!("Sending expiry notification to {}…", recipient);
         let email = ExpiryNotificationEmail {