refactor: Improve errors for failed action operations

proton/proton-api/src/domain/errors.rs

@@ -127,6 +127,7 @@ impl APIError {
             }
         }
     }
+
     /// Create a new instance with an `http_status` code.
     #[must_use]
     pub fn new(http_status: u16) -> Self {
@@ -137,4 +138,15 @@ impl APIError {
             details: None,
         }
     }
+
+    /// Create a new instance with an `http_status` code and `description`.
+    #[must_use]
+    pub fn with_desc(http_status: u16, description: APIErrorDesc) -> Self {
+        Self {
+            http_code: http_status,
+            api_code: description.code,
+            message: description.error,
+            details: description.details,
+        }
+    }
 }

proton/proton-api/src/requests/message.rs

@@ -1,4 +1,4 @@
-use crate::domain::errors::{APIErrorDesc, OPERATION_SUCCESS};
+use crate::domain::errors::{APIError, APIErrorDesc, OPERATION_SUCCESS};
 use crate::domain::label;
 use crate::domain::message::Id;
 use http::{Method, RequestBuilder};
@@ -33,6 +33,19 @@ impl OperationResponse {
     pub fn is_success(&self) -> bool {
         self.response.code == OPERATION_SUCCESS
     }
+
+    /// Convert the current response into a result type.
+    ///
+    /// # Errors
+    ///
+    /// Converts into an `APIError` if the operation did not succeed.
+    pub fn into_result(self) -> Result<(), APIError> {
+        if self.is_success() {
+            Ok(())
+        } else {
+            Err(APIError::with_desc(200, self.response))
+        }
+    }
 }
 
 #[derive(Debug, Deserialize)]

youhavemail/src/backend/proton.rs

@@ -3,6 +3,7 @@
 use crate::backend::{Action, Error as BackendError, Error, NewEmail, Result as BackendResult};
 use crate::state::Account;
 use crate::yhm::{IntoAccount, Yhm};
+use anyhow::anyhow;
 use http::{Client, Proxy};
 use parking_lot::Mutex;
 use proton_api::auth::{new_thread_safe_store, Auth as ProtonAuth, InMemoryStore, StoreError};
@@ -264,27 +265,48 @@ impl crate::backend::Poller for Poller {
         match action {
             AccountAction::MarkMessageRead(id) => {
                 debug!("Marking {id} as read");
-                self.session
+                let response = self
+                    .session
                     .execute_with_auth(PutMarkMessageReadRequest::new([id]))
                     .inspect_err(|e| {
                         error!("Failed to mark message as read: {e}");
                     })?;
+                for response in response.responses {
+                    response.into_result().map_err(|e| {
+                        error!("Failed to mark message as read: {}", e);
+                        Error::Unknown(anyhow!("Failed to mark message as read"))
+                    })?;
+                }
             }
             AccountAction::MoveMessageToTrash(id) => {
                 debug!("Moving {id} to trash");
-                self.session
+                let response = self
+                    .session
                     .execute_with_auth(PutLabelMessageRequest::new(label::Id::trash(), [id]))
                     .inspect_err(|e| {
                         error!("Failed to move message to trash: {e}");
                     })?;
+                for response in response.responses {
+                    response.into_result().map_err(|e| {
+                        error!("Failed to move message to trash: {}", e);
+                        Error::Unknown(anyhow!("Failed to move message to trash"))
+                    })?;
+                }
             }
             AccountAction::MoveMessageToSpam(id) => {
                 debug!("Moving {id} to spam");
-                self.session
+                let response = self
+                    .session
                     .execute_with_auth(PutLabelMessageRequest::new(label::Id::spam(), [id]))
                     .inspect_err(|e| {
                         error!("Failed to move message to spam: {e}");
                     })?;
+                for response in response.responses {
+                    response.into_result().map_err(|e| {
+                        error!("Failed to move message to spam: {}", e);
+                        Error::Unknown(anyhow!("Failed to move message to spam"))
+                    })?;
+                }
             }
         }