Rough prototype of extending CustomApiError for multiple errors.

Author: LawnGnome

src/controllers/krate/delete.rs

@@ -2,7 +2,7 @@ use crate::app::AppState;
 use crate::auth::AuthCheck;
 use crate::models::{Crate, Rights};
 use crate::schema::{crate_downloads, crates, dependencies};
-use crate::util::errors::{crate_not_found, custom, AppResult, BoxedAppError};
+use crate::util::errors::{crate_not_found, custom, AppResult, BoxedAppError, CustomApiError};
 use crate::worker::jobs;
 use axum::extract::Path;
 use bigdecimal::ToPrimitive;
@@ -56,9 +56,10 @@ pub async fn delete(Path(name): Path<String>, parts: Parts, app: AppState) -> Ap
 
     let is_old = created_at <= Utc::now() - chrono::Duration::hours(72);
     if is_old {
+        let mut errors = CustomApiError::new(StatusCode::UNPROCESSABLE_ENTITY);
+
         if owners.len() > 1 {
-            let msg = "only crates with a single owner can be deleted after 72 hours";
-            return Err(custom(StatusCode::UNPROCESSABLE_ENTITY, msg));
+            errors.push("only crates with a single owner can be deleted after 72 hours");
         }
 
         let age = Utc::now().signed_duration_since(created_at);
@@ -78,7 +79,7 @@ pub async fn delete(Path(name): Path<String>, parts: Parts, app: AppState) -> Ap
 
         if downloads > max_downloads {
             let msg = format!("only crates with less than {DOWNLOADS_PER_MONTH_LIMIT} downloads per month can be deleted after 72 hours");
-            return Err(custom(StatusCode::UNPROCESSABLE_ENTITY, msg));
+            errors.push(msg);
         }
 
         let has_rev_dep = dependencies::table
@@ -90,8 +91,11 @@ pub async fn delete(Path(name): Path<String>, parts: Parts, app: AppState) -> Ap
             .is_some();
 
         if has_rev_dep {
-            let msg = "only crates without reverse dependencies can be deleted after 72 hours";
-            return Err(custom(StatusCode::UNPROCESSABLE_ENTITY, msg));
+            errors.push("only crates without reverse dependencies can be deleted after 72 hours");
+        }
+
+        if errors.contains_errors() {
+            return Err(errors.into());
         }
     }
 

src/util/errors.rs

@@ -32,7 +32,9 @@ mod json;
 use crate::email::EmailError;
 use crates_io_github::GitHubError;
 pub use json::TOKEN_FORMAT_ERROR;
-pub(crate) use json::{custom, InsecurelyGeneratedTokenRevoked, ReadOnlyMode, TooManyRequests};
+pub(crate) use json::{
+    custom, CustomApiError, InsecurelyGeneratedTokenRevoked, ReadOnlyMode, TooManyRequests,
+};
 
 pub type BoxedAppError = Box<dyn AppError>;
 

src/util/errors/json.rs

@@ -40,14 +40,71 @@ impl fmt::Display for ReadOnlyMode {
 pub fn custom(status: StatusCode, detail: impl Into<Cow<'static, str>>) -> BoxedAppError {
     Box::new(CustomApiError {
         status,
-        detail: detail.into(),
+        detail: Detail::Single(detail.into()),
     })
 }
 
 #[derive(Debug, Clone)]
 pub struct CustomApiError {
     status: StatusCode,
-    detail: Cow<'static, str>,
+    detail: Detail,
+}
+
+#[derive(Debug, Clone)]
+enum Detail {
+    Empty,
+    Single(Cow<'static, str>),
+    Multiple(Vec<Cow<'static, str>>),
+}
+
+impl fmt::Display for Detail {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Empty => write!(f, ""),
+            Self::Single(msg) => write!(f, "{msg}"),
+            Self::Multiple(msgs) => write!(f, "{}", msgs.join(", ")),
+        }
+    }
+}
+
+impl CustomApiError {
+    pub fn new(status: StatusCode) -> Self {
+        Self {
+            status,
+            detail: Detail::Empty,
+        }
+    }
+
+    pub fn contains_errors(&self) -> bool {
+        !self.is_empty()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        matches!(&self.detail, Detail::Empty)
+    }
+
+    pub fn push(&mut self, detail: impl Into<Cow<'static, str>>) -> &mut Self {
+        match &mut self.detail {
+            Detail::Empty => {
+                self.detail = Detail::Single(detail.into());
+            }
+            Detail::Single(msg) => {
+                let msg = msg.clone();
+                self.detail = Detail::Multiple(vec![msg, detail.into()]);
+            }
+            Detail::Multiple(msgs) => {
+                msgs.push(detail.into());
+            }
+        }
+
+        self
+    }
+}
+
+impl From<CustomApiError> for BoxedAppError {
+    fn from(value: CustomApiError) -> Self {
+        Box::new(value)
+    }
 }
 
 impl fmt::Display for CustomApiError {
@@ -58,7 +115,33 @@ impl fmt::Display for CustomApiError {
 
 impl AppError for CustomApiError {
     fn response(&self) -> Response {
-        json_error(&self.detail, self.status)
+        #[derive(Serialize)]
+        struct ErrorContent {
+            detail: Cow<'static, str>,
+        }
+
+        impl From<&Cow<'static, str>> for ErrorContent {
+            fn from(value: &Cow<'static, str>) -> Self {
+                Self {
+                    detail: value.clone(),
+                }
+            }
+        }
+
+        #[derive(Serialize)]
+        struct ErrorBody {
+            errors: Vec<ErrorContent>,
+        }
+
+        let body = ErrorBody {
+            errors: match &self.detail {
+                Detail::Empty => Vec::new(),
+                Detail::Single(msg) => vec![msg.into()],
+                Detail::Multiple(msgs) => msgs.iter().map(|msg| msg.into()).collect(),
+            },
+        };
+
+        (self.status, Json(body)).into_response()
     }
 }