Use User::as_select() to avoid column ordering issues

Author: Turbo87

crates/crates_io_database/src/models/action.rs

@@ -66,6 +66,7 @@ impl VersionOwnerAction {
         version_owner_actions::table
             .filter(version_id.eq(version.id))
             .inner_join(users::table)
+            .select((VersionOwnerAction::as_select(), User::as_select()))
             .order(version_owner_actions::dsl::id)
             .load(conn)
             .boxed()
@@ -77,6 +78,7 @@ impl VersionOwnerAction {
     ) -> QueryResult<Vec<Vec<(Self, User)>>> {
         Ok(Self::belonging_to(versions)
             .inner_join(users::table)
+            .select((VersionOwnerAction::as_select(), User::as_select()))
             .order(version_owner_actions::dsl::id)
             .load(conn)
             .await?

crates/crates_io_database/src/models/crate_owner_invitation.rs

@@ -103,7 +103,11 @@ impl CrateOwnerInvitation {
         }
 
         // Get the user and check if they have a verified email
-        let user: User = users::table.find(self.invited_user_id).first(conn).await?;
+        let user: User = users::table
+            .find(self.invited_user_id)
+            .select(User::as_select())
+            .first(conn)
+            .await?;
 
         let verified_email = user.verified_email(conn).await?;
         if verified_email.is_none() {

crates/crates_io_database/src/models/user.rs

@@ -31,13 +31,18 @@ pub struct User {
 
 impl User {
     pub async fn find(conn: &mut AsyncPgConnection, id: i32) -> QueryResult<User> {
-        users::table.find(id).first(conn).await
+        users::table
+            .find(id)
+            .select(User::as_select())
+            .first(conn)
+            .await
     }
 
     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))
+            .select(User::as_select())
             .order(users::gh_id.desc())
             .first(conn)
             .await
@@ -96,6 +101,7 @@ impl NewUser<'_> {
     pub async fn insert(&self, conn: &mut AsyncPgConnection) -> QueryResult<User> {
         diesel::insert_into(users::table)
             .values(self)
+            .returning(User::as_returning())
             .get_result(conn)
             .await
     }
@@ -120,6 +126,7 @@ impl NewUser<'_> {
                 users::gh_avatar.eq(excluded(users::gh_avatar)),
                 users::gh_access_token.eq(excluded(users::gh_access_token)),
             ))
+            .returning(User::as_returning())
             .get_result(conn)
             .await
     }

crates/crates_io_database/src/models/version.rs

@@ -59,7 +59,12 @@ impl Version {
     /// Not for use when you have a group of versions you need the publishers for.
     pub async fn published_by(&self, conn: &mut AsyncPgConnection) -> QueryResult<Option<User>> {
         match self.published_by {
-            Some(pb) => users::table.find(pb).first(conn).await.optional(),
+            Some(pb) => users::table
+                .find(pb)
+                .select(User::as_select())
+                .first(conn)
+                .await
+                .optional(),
             None => Ok(None),
         }
     }

src/bin/crates-admin/transfer_crates.rs

@@ -27,11 +27,13 @@ pub async fn run(opts: Opts) -> anyhow::Result<()> {
 async fn transfer(opts: Opts, conn: &mut AsyncPgConnection) -> anyhow::Result<()> {
     let from: User = users::table
         .filter(users::gh_login.eq(opts.from_user))
+        .select(User::as_select())
         .first(conn)
         .await?;
 
     let to: User = users::table
         .filter(users::gh_login.eq(opts.to_user))
+        .select(User::as_select())
         .first(conn)
         .await?;
 

src/controllers/crate_owner_invitation.rs

@@ -266,6 +266,7 @@ async fn prepare_list(
     if !missing_users.is_empty() {
         let new_users: Vec<User> = users::table
             .filter(users::id.eq_any(missing_users))
+            .select(User::as_select())
             .load(conn)
             .await?;
         for user in new_users.into_iter() {

src/controllers/krate/downloads.rs

@@ -187,6 +187,7 @@ fn load_actions<'a>(
     }
     VersionOwnerAction::belonging_to(versions)
         .inner_join(users::table)
+        .select((VersionOwnerAction::as_select(), User::as_select()))
         .order(version_owner_actions::id)
         .load(conn)
         .boxed()

src/controllers/session.rs

@@ -204,6 +204,7 @@ async fn create_or_update_user(
 async fn find_user_by_gh_id(conn: &mut AsyncPgConnection, gh_id: i32) -> QueryResult<Option<User>> {
     users::table
         .filter(users::gh_id.eq(gh_id))
+        .select(User::as_select())
         .first(conn)
         .await
         .optional()

src/controllers/user/other.rs

@@ -37,6 +37,7 @@ pub async fn find_user(
     let name = lower(&user_name);
     let user: User = users
         .filter(lower(gh_login).eq(name))
+        .select(User::as_select())
         .order(id.desc())
         .first(&mut conn)
         .await?;