Use HasQuery for database models

crates/crates_io_database/src/models/action.rs

@@ -34,10 +34,9 @@ impl From<VersionAction> for String {
     }
 }
 
-#[derive(Debug, Clone, Copy, Queryable, Identifiable, Selectable, Associations)]
+#[derive(Debug, Clone, Copy, HasQuery, Identifiable, Associations)]
 #[diesel(
     table_name = version_owner_actions,
-    check_for_backend(diesel::pg::Pg),
     belongs_to(Version),
     belongs_to(User, foreign_key = user_id),
     belongs_to(ApiToken, foreign_key = api_token_id),
@@ -54,10 +53,7 @@ pub struct VersionOwnerAction {
 
 impl VersionOwnerAction {
     pub async fn all(conn: &mut AsyncPgConnection) -> QueryResult<Vec<Self>> {
-        version_owner_actions::table
-            .select(Self::as_select())
-            .load(conn)
-            .await
+        Self::query().load(conn).await
     }
 
     pub fn by_version<'a>(

crates/crates_io_database/src/models/category.rs

@@ -9,8 +9,8 @@ use diesel_async::{AsyncConnection, AsyncPgConnection, RunQueryDsl};
 use futures_util::FutureExt;
 use futures_util::future::BoxFuture;
 
-#[derive(Clone, Identifiable, Queryable, QueryableByName, Debug, Selectable)]
-#[diesel(table_name = categories, check_for_backend(diesel::pg::Pg))]
+#[derive(Clone, Identifiable, HasQuery, QueryableByName, Debug)]
+#[diesel(table_name = categories)]
 pub struct Category {
     pub id: i32,
     pub category: String,
@@ -53,9 +53,8 @@ impl Category {
     ) -> QueryResult<Vec<String>> {
         conn.transaction(|conn| {
             async move {
-                let categories: Vec<Category> = categories::table
+                let categories: Vec<Category> = Category::query()
                     .filter(categories::slug.eq_any(slugs))
-                    .select(Category::as_select())
                     .load(conn)
                     .await?;
 

crates/crates_io_database/src/models/cloudfront_invalidation_queue.rs

@@ -2,8 +2,8 @@ use crate::schema::cloudfront_invalidation_queue;
 use diesel::prelude::*;
 use diesel_async::{AsyncPgConnection, RunQueryDsl};
 
-#[derive(Debug, Identifiable, Queryable, QueryableByName, Selectable)]
-#[diesel(table_name = cloudfront_invalidation_queue, check_for_backend(diesel::pg::Pg))]
+#[derive(Debug, Identifiable, HasQuery, QueryableByName)]
+#[diesel(table_name = cloudfront_invalidation_queue)]
 pub struct CloudFrontInvalidationQueueItem {
     pub id: i64,
     pub path: String,
@@ -36,10 +36,9 @@ impl CloudFrontInvalidationQueueItem {
         limit: i64,
     ) -> QueryResult<Vec<CloudFrontInvalidationQueueItem>> {
         // Fetch the oldest entries up to the limit
-        cloudfront_invalidation_queue::table
+        Self::query()
             .order(cloudfront_invalidation_queue::created_at.asc())
             .limit(limit)
-            .select(Self::as_select())
             .load(conn)
             .await
     }

crates/crates_io_database/src/models/crate_owner_invitation.rs

@@ -5,7 +5,7 @@ use diesel_async::{AsyncConnection, AsyncPgConnection, RunQueryDsl};
 use secrecy::SecretString;
 
 use crate::models::{CrateOwner, User};
-use crate::schema::{crate_owner_invitations, crates, users};
+use crate::schema::{crate_owner_invitations, crates};
 
 #[derive(Debug)]
 pub enum NewCrateOwnerInvitationOutcome {
@@ -58,7 +58,7 @@ impl NewCrateOwnerInvitation {
 }
 
 /// The model representing a row in the `crate_owner_invitations` database table.
-#[derive(Clone, Debug, Identifiable, Queryable, Selectable)]
+#[derive(Clone, Debug, Identifiable, HasQuery)]
 #[diesel(primary_key(invited_user_id, crate_id))]
 pub struct CrateOwnerInvitation {
     pub invited_user_id: i32,
@@ -76,18 +76,16 @@ impl CrateOwnerInvitation {
         crate_id: i32,
         conn: &mut AsyncPgConnection,
     ) -> QueryResult<Self> {
-        crate_owner_invitations::table
+        CrateOwnerInvitation::query()
             .find((user_id, crate_id))
-            .select(CrateOwnerInvitation::as_select())
-            .first::<Self>(conn)
+            .first(conn)
             .await
     }
 
     pub async fn find_by_token(token: &str, conn: &mut AsyncPgConnection) -> QueryResult<Self> {
-        crate_owner_invitations::table
+        CrateOwnerInvitation::query()
             .filter(crate_owner_invitations::token.eq(token))
-            .select(CrateOwnerInvitation::as_select())
-            .first::<Self>(conn)
+            .first(conn)
             .await
     }
 
@@ -106,11 +104,7 @@ impl CrateOwnerInvitation {
         }
 
         // Get the user and check if they have a verified email
-        let user: User = users::table
-            .find(self.invited_user_id)
-            .select(User::as_select())
-            .first(conn)
-            .await?;
+        let user = User::query().find(self.invited_user_id).first(conn).await?;
 
         let verified_email = user.verified_email(conn).await?;
         if verified_email.is_none() {

crates/crates_io_database/src/models/default_versions.rs

@@ -13,9 +13,8 @@ use tracing::{debug, instrument, warn};
 /// It implements [Ord] in a way that sorts versions by the criteria specified
 /// in the [update_default_version] function documentation. The default version
 /// will be the "maximum" element in a sorted list of versions.
-#[derive(Clone, Debug, PartialEq, Eq, Queryable, Selectable)]
+#[derive(Clone, Debug, PartialEq, Eq, HasQuery)]
 #[diesel(table_name = versions)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
 pub struct Version {
     pub id: i32,
     #[diesel(deserialize_as = SemverVersion)]
@@ -123,10 +122,9 @@ async fn calculate_default_version(
     use diesel::result::Error::NotFound;
 
     debug!("Loading all versions for the crate…");
-    let versions = versions::table
+    let versions = Version::query()
         .filter(versions::crate_id.eq(crate_id))
-        .select(Version::as_returning())
-        .load::<Version>(conn)
+        .load(conn)
         .await?;
 
     debug!("Found {} versions", versions.len());

crates/crates_io_database/src/models/dependency.rs

@@ -5,10 +5,9 @@ use crates_io_index::DependencyKind as IndexDependencyKind;
 use diesel::prelude::*;
 use diesel::sql_types::{BigInt, Text};
 
-#[derive(Identifiable, Associations, Debug, Queryable, QueryableByName, Selectable)]
+#[derive(Identifiable, Associations, Debug, HasQuery, QueryableByName)]
 #[diesel(
     table_name = dependencies,
-    check_for_backend(diesel::pg::Pg),
     belongs_to(Version),
     belongs_to(Crate),
 )]

crates/crates_io_database/src/models/download.rs

@@ -4,7 +4,7 @@ use chrono::NaiveDate;
 use crates_io_diesel_helpers::SemverVersion;
 use diesel::prelude::*;
 
-#[derive(Queryable, Identifiable, Selectable, Associations, Debug, Clone, Copy)]
+#[derive(HasQuery, Identifiable, Associations, Debug, Clone, Copy)]
 #[diesel(
     primary_key(version_id, date),
     belongs_to(FullVersion, foreign_key=version_id),
@@ -21,7 +21,7 @@ pub struct VersionDownload {
 /// This struct is used to load all versions of a crate from the database,
 /// without loading the additional data that is unnecessary for download version resolution.
 ///
-#[derive(Queryable, Selectable, Identifiable)]
+#[derive(HasQuery, Identifiable)]
 #[diesel(table_name = versions)]
 pub struct Version {
     pub id: i32,

crates/crates_io_database/src/models/email.rs

@@ -6,7 +6,7 @@ use secrecy::SecretString;
 use crate::models::User;
 use crate::schema::emails;
 
-#[derive(Debug, Queryable, Identifiable, Selectable, Associations)]
+#[derive(Debug, HasQuery, Identifiable, Associations)]
 #[diesel(belongs_to(User))]
 pub struct Email {
     pub id: i32,

crates/crates_io_database/src/models/keyword.rs

@@ -7,7 +7,7 @@ use crate::models::Crate;
 use crate::schema::*;
 use crates_io_diesel_helpers::lower;
 
-#[derive(Clone, Identifiable, Queryable, Debug, Selectable)]
+#[derive(Clone, Identifiable, HasQuery, Debug)]
 pub struct Keyword {
     pub id: i32,
     pub keyword: String,
@@ -30,9 +30,8 @@ pub struct CrateKeyword {
 
 impl Keyword {
     pub async fn find_by_keyword(conn: &mut AsyncPgConnection, name: &str) -> QueryResult<Keyword> {
-        keywords::table
+        Keyword::query()
             .filter(keywords::keyword.eq(lower(name)))
-            .select(Keyword::as_select())
             .first(conn)
             .await
     }
@@ -54,9 +53,8 @@ impl Keyword {
             .execute(conn)
             .await?;
 
-        keywords::table
+        Keyword::query()
             .filter(keywords::keyword.eq_any(&lowercase_names))
-            .select(Keyword::as_select())
             .load(conn)
             .await
     }

crates/crates_io_database/src/models/krate.rs

@@ -18,14 +18,14 @@ use tracing::instrument;
 
 use super::Team;
 
-#[derive(Debug, Clone, Queryable, Selectable)]
-#[diesel(table_name = crates, check_for_backend(diesel::pg::Pg))]
+#[derive(Debug, Clone, HasQuery)]
+#[diesel(table_name = crates)]
 pub struct CrateName {
     pub name: String,
 }
 
-#[derive(Debug, Clone, Queryable, Identifiable, AsChangeset, Selectable, Serialize)]
-#[diesel(table_name = crates, check_for_backend(diesel::pg::Pg))]
+#[derive(Debug, Clone, Identifiable, AsChangeset, HasQuery, Serialize)]
+#[diesel(table_name = crates)]
 pub struct Crate {
     pub id: i32,
     pub name: String,

crates/crates_io_database/src/models/team.rs

@@ -7,7 +7,7 @@ use crate::schema::{crate_owners, teams};
 
 /// For now, just a GitHub Team. Can be upgraded to other teams
 /// later if desirable.
-#[derive(Queryable, Identifiable, serde::Serialize, serde::Deserialize, Debug, Selectable)]
+#[derive(HasQuery, Identifiable, serde::Serialize, serde::Deserialize, Debug)]
 pub struct Team {
     /// Unique table id
     pub id: i32,

crates/crates_io_database/src/models/token.rs

@@ -39,9 +39,7 @@ impl NewApiToken {
 }
 
 /// The model representing a row in the `api_tokens` database table.
-#[derive(
-    Debug, Identifiable, Queryable, Selectable, Associations, serde::Serialize, utoipa::ToSchema,
-)]
+#[derive(Debug, Identifiable, HasQuery, Associations, serde::Serialize, utoipa::ToSchema)]
 #[diesel(belongs_to(User))]
 pub struct ApiToken {
     /// An opaque unique identifier for the token.

crates/crates_io_database/src/models/trustpub/github_config.rs

@@ -4,8 +4,8 @@ use diesel::prelude::*;
 use diesel_async::{AsyncPgConnection, RunQueryDsl};
 use serde::Serialize;
 
-#[derive(Debug, Identifiable, Queryable, Selectable, Serialize)]
-#[diesel(table_name = trustpub_configs_github, check_for_backend(diesel::pg::Pg))]
+#[derive(Debug, Identifiable, HasQuery, Serialize)]
+#[diesel(table_name = trustpub_configs_github)]
 pub struct GitHubConfig {
     pub id: i32,
     pub created_at: DateTime<Utc>,

crates/crates_io_database/src/models/trustpub/gitlab_config.rs

@@ -4,8 +4,8 @@ use diesel::prelude::*;
 use diesel_async::{AsyncPgConnection, RunQueryDsl};
 use serde::Serialize;
 
-#[derive(Debug, Identifiable, Queryable, Selectable, Serialize)]
-#[diesel(table_name = trustpub_configs_gitlab, check_for_backend(diesel::pg::Pg))]
+#[derive(Debug, Identifiable, HasQuery, Serialize)]
+#[diesel(table_name = trustpub_configs_gitlab)]
 pub struct GitLabConfig {
     pub id: i32,
     pub created_at: DateTime<Utc>,
@@ -71,10 +71,9 @@ mod tests {
         let inserted_config = new_config.insert(&mut conn).await.unwrap();
 
         // Retrieve the config
-        let retrieved_config = trustpub_configs_gitlab::table
+        let retrieved_config = GitLabConfig::query()
             .filter(trustpub_configs_gitlab::id.eq(inserted_config.id))
-            .select(GitLabConfig::as_select())
-            .first::<GitLabConfig>(&mut conn)
+            .first(&mut conn)
             .await
             .unwrap();
 

crates/crates_io_database/src/models/user.rs

@@ -12,7 +12,7 @@ use crate::schema::{crate_owners, emails, users};
 use crates_io_diesel_helpers::lower;
 
 /// The model representing a row in the `users` database table.
-#[derive(Clone, Debug, Queryable, Identifiable, Selectable, Serialize)]
+#[derive(Clone, Debug, HasQuery, Identifiable, Serialize)]
 pub struct User {
     pub id: i32,
     pub name: Option<String>,
@@ -29,18 +29,13 @@ pub struct User {
 
 impl User {
     pub async fn find(conn: &mut AsyncPgConnection, id: i32) -> QueryResult<User> {
-        users::table
-            .find(id)
-            .select(User::as_select())
-            .first(conn)
-            .await
+        User::query().find(id).first(conn).await
     }
 
     pub async fn find_by_login(conn: &mut AsyncPgConnection, login: &str) -> QueryResult<User> {
-        users::table
+        User::query()
             .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

crates/crates_io_database/src/models/version.rs

@@ -8,9 +8,9 @@ use diesel_async::{AsyncPgConnection, RunQueryDsl};
 use serde::Deserialize;
 
 use crate::models::{Crate, TrustpubData, User};
-use crate::schema::{readme_renderings, users, versions};
+use crate::schema::{readme_renderings, versions};
 
-#[derive(Clone, Identifiable, Associations, Debug, Queryable, Selectable)]
+#[derive(Clone, Identifiable, Associations, Debug, HasQuery)]
 #[diesel(belongs_to(Crate), belongs_to(crate::models::download::Version, foreign_key=id))]
 pub struct Version {
     pub id: i32,
@@ -59,12 +59,7 @@ 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)
-                .select(User::as_select())
-                .first(conn)
-                .await
-                .optional(),
+            Some(pb) => User::query().find(pb).first(conn).await.optional(),
             None => Ok(None),
         }
     }

crates/crates_io_worker/src/storage.rs

@@ -6,7 +6,7 @@ use diesel::sql_types::{Bool, Integer, Interval};
 use diesel::{delete, update};
 use diesel_async::{AsyncPgConnection, RunQueryDsl};
 
-#[derive(Queryable, Selectable, Identifiable, Debug, Clone)]
+#[derive(HasQuery, Identifiable, Debug, Clone)]
 pub(super) struct BackgroundJob {
     pub(super) id: i64,
     pub(super) job_type: String,
@@ -30,14 +30,13 @@ pub(super) async fn find_next_unlocked_job(
     conn: &mut AsyncPgConnection,
     job_types: &[String],
 ) -> QueryResult<BackgroundJob> {
-    background_jobs::table
-        .select(BackgroundJob::as_select())
+    BackgroundJob::query()
         .filter(background_jobs::job_type.eq_any(job_types))
         .filter(retriable())
         .order((background_jobs::priority.desc(), background_jobs::id))
         .for_update()
         .skip_locked()
-        .first::<BackgroundJob>(conn)
+        .first(conn)
         .await
 }