models/krate: Move Crate::owner_add() fn into corresponding controller

This fn performs way to much non-database stuff to be in the `models` module...

Author: Turbo87

src/controllers/krate/owners.rs

@@ -2,21 +2,27 @@
 
 use crate::controllers::krate::CratePath;
 use crate::models::krate::OwnerRemoveError;
-use crate::models::{krate::NewOwnerInvite, token::EndpointScope};
+use crate::models::{
+    krate::NewOwnerInvite, token::EndpointScope, CrateOwner, NewCrateOwnerInvitation,
+    NewCrateOwnerInvitationOutcome, OwnerKind,
+};
 use crate::models::{Crate, Owner, Rights, Team, User};
 use crate::util::errors::{bad_request, crate_not_found, custom, AppResult, BoxedAppError};
 use crate::views::EncodableOwner;
-use crate::{app::AppState, models::krate::OwnerAddError};
+use crate::{app::AppState, App};
 use crate::{auth::AuthCheck, email::Email};
 use axum::Json;
 use axum_extra::json;
 use axum_extra::response::ErasedJson;
+use chrono::Utc;
+use crates_io_database::schema::crate_owners;
 use diesel::prelude::*;
 use diesel_async::scoped_futures::ScopedFutureExt;
-use diesel_async::{AsyncConnection, RunQueryDsl};
+use diesel_async::{AsyncConnection, AsyncPgConnection, RunQueryDsl};
 use http::request::Parts;
 use http::StatusCode;
 use secrecy::{ExposeSecret, SecretString};
+use thiserror::Error;
 
 /// List crate owners.
 #[utoipa::path(
@@ -200,7 +206,7 @@ async fn modify_owners(
                             return Err(bad_request(format_args!("`{login}` is already an owner")));
                         }
 
-                        match krate.owner_add(&app, conn, user, login).await {
+                        match add_owner(&app, conn, user, &krate, login).await {
                             // A user was successfully invited, and they must accept
                             // the invite, and a best-effort attempt should be made
                             // to email them the invite token for one-click
@@ -275,6 +281,85 @@ async fn modify_owners(
     Ok(json!({ "msg": comma_sep_msg, "ok": true }))
 }
 
+/// Invite `login` as an owner of this crate, returning the created
+/// [`NewOwnerInvite`].
+async fn add_owner(
+    app: &App,
+    conn: &mut AsyncPgConnection,
+    req_user: &User,
+    krate: &Crate,
+    login: &str,
+) -> Result<NewOwnerInvite, OwnerAddError> {
+    use diesel::insert_into;
+
+    let owner = Owner::find_or_create_by_login(app, conn, req_user, login).await?;
+    match owner {
+        // Users are invited and must accept before being added
+        Owner::User(user) => {
+            let expires_at = Utc::now() + app.config.ownership_invitations_expiration;
+            let invite = NewCrateOwnerInvitation {
+                invited_user_id: user.id,
+                invited_by_user_id: req_user.id,
+                crate_id: krate.id,
+                expires_at,
+            };
+
+            let creation_ret = invite.create(conn).await.map_err(BoxedAppError::from)?;
+
+            match creation_ret {
+                NewCrateOwnerInvitationOutcome::InviteCreated { plaintext_token } => {
+                    Ok(NewOwnerInvite::User(user, plaintext_token))
+                }
+                NewCrateOwnerInvitationOutcome::AlreadyExists => {
+                    Err(OwnerAddError::AlreadyInvited(Box::new(user)))
+                }
+            }
+        }
+        // Teams are added as owners immediately
+        Owner::Team(team) => {
+            insert_into(crate_owners::table)
+                .values(&CrateOwner {
+                    crate_id: krate.id,
+                    owner_id: team.id,
+                    created_by: req_user.id,
+                    owner_kind: OwnerKind::Team,
+                    email_notifications: true,
+                })
+                .on_conflict(crate_owners::table.primary_key())
+                .do_update()
+                .set(crate_owners::deleted.eq(false))
+                .execute(conn)
+                .await
+                .map_err(BoxedAppError::from)?;
+
+            Ok(NewOwnerInvite::Team(team))
+        }
+    }
+}
+
+/// Error results from a [`add_owner()`] model call.
+#[derive(Debug, Error)]
+enum OwnerAddError {
+    /// An opaque [`BoxedAppError`].
+    #[error("{0}")] // AppError does not impl Error
+    AppError(BoxedAppError),
+
+    /// The requested invitee already has a pending invite.
+    ///
+    /// Note: Teams are always immediately added, so they cannot have a pending
+    /// invite to cause this error.
+    #[error("user already has pending invite")]
+    AlreadyInvited(Box<User>),
+}
+
+/// A [`BoxedAppError`] does not impl [`std::error::Error`] so it needs a manual
+/// [`From`] impl.
+impl From<BoxedAppError> for OwnerAddError {
+    fn from(value: BoxedAppError) -> Self {
+        Self::AppError(value)
+    }
+}
+
 impl From<OwnerRemoveError> for BoxedAppError {
     fn from(error: OwnerRemoveError) -> Self {
         match error {

src/models/krate.rs

@@ -1,4 +1,4 @@
-use chrono::{NaiveDateTime, Utc};
+use chrono::NaiveDateTime;
 use diesel::associations::Identifiable;
 use diesel::dsl;
 use diesel::pg::Pg;
@@ -11,12 +11,8 @@ use thiserror::Error;
 
 use crate::models::helpers::with_count::*;
 use crate::models::version::TopVersions;
-use crate::models::{
-    CrateOwner, NewCrateOwnerInvitation, NewCrateOwnerInvitationOutcome, Owner, OwnerKind,
-    ReverseDependency, User, Version,
-};
+use crate::models::{CrateOwner, Owner, OwnerKind, ReverseDependency, User, Version};
 use crate::schema::*;
-use crate::{app::App, util::errors::BoxedAppError};
 use crates_io_diesel_helpers::canon_crate_name;
 
 use super::Team;
@@ -383,62 +379,6 @@ impl Crate {
         Ok(users.chain(teams).collect())
     }
 
-    /// Invite `login` as an owner of this crate, returning the created
-    /// [`NewOwnerInvite`].
-    pub async fn owner_add(
-        &self,
-        app: &App,
-        conn: &mut AsyncPgConnection,
-        req_user: &User,
-        login: &str,
-    ) -> Result<NewOwnerInvite, OwnerAddError> {
-        use diesel::insert_into;
-
-        let owner = Owner::find_or_create_by_login(app, conn, req_user, login).await?;
-        match owner {
-            // Users are invited and must accept before being added
-            Owner::User(user) => {
-                let expires_at = Utc::now() + app.config.ownership_invitations_expiration;
-                let invite = NewCrateOwnerInvitation {
-                    invited_user_id: user.id,
-                    invited_by_user_id: req_user.id,
-                    crate_id: self.id,
-                    expires_at,
-                };
-
-                let creation_ret = invite.create(conn).await.map_err(BoxedAppError::from)?;
-
-                match creation_ret {
-                    NewCrateOwnerInvitationOutcome::InviteCreated { plaintext_token } => {
-                        Ok(NewOwnerInvite::User(user, plaintext_token))
-                    }
-                    NewCrateOwnerInvitationOutcome::AlreadyExists => {
-                        Err(OwnerAddError::AlreadyInvited(Box::new(user)))
-                    }
-                }
-            }
-            // Teams are added as owners immediately
-            Owner::Team(team) => {
-                insert_into(crate_owners::table)
-                    .values(&CrateOwner {
-                        crate_id: self.id,
-                        owner_id: team.id,
-                        created_by: req_user.id,
-                        owner_kind: OwnerKind::Team,
-                        email_notifications: true,
-                    })
-                    .on_conflict(crate_owners::table.primary_key())
-                    .do_update()
-                    .set(crate_owners::deleted.eq(false))
-                    .execute(conn)
-                    .await
-                    .map_err(BoxedAppError::from)?;
-
-                Ok(NewOwnerInvite::Team(team))
-            }
-        }
-    }
-
     pub async fn owner_remove(
         &self,
         conn: &mut AsyncPgConnection,
@@ -519,21 +459,6 @@ pub enum NewOwnerInvite {
     Team(Team),
 }
 
-/// Error results from a [`Crate::owner_add()`] model call.
-#[derive(Debug, Error)]
-pub enum OwnerAddError {
-    /// An opaque [`BoxedAppError`].
-    #[error("{0}")] // AppError does not impl Error
-    AppError(BoxedAppError),
-
-    /// The requested invitee already has a pending invite.
-    ///
-    /// Note: Teams are always immediately added, so they cannot have a pending
-    /// invite to cause this error.
-    #[error("user already has pending invite")]
-    AlreadyInvited(Box<User>),
-}
-
 #[derive(Debug, Error)]
 pub enum OwnerRemoveError {
     #[error(transparent)]
@@ -549,14 +474,6 @@ impl OwnerRemoveError {
     }
 }
 
-/// A [`BoxedAppError`] does not impl [`std::error::Error`] so it needs a manual
-/// [`From`] impl.
-impl From<BoxedAppError> for OwnerAddError {
-    fn from(value: BoxedAppError) -> Self {
-        Self::AppError(value)
-    }
-}
-
 #[derive(Debug, Eq, PartialEq, thiserror::Error)]
 pub enum InvalidFeature {
     #[error("feature cannot be empty")]