feat(WidgetDriver): Pass Matrix API errors to the widget

crates/matrix-sdk/src/widget/machine/driver_req.rs

@@ -74,9 +74,11 @@ where
         Self { request_meta: None, _phantom: PhantomData }
     }
 
+    /// Setup a callback function that will be called once the matrix driver has
+    /// processed the request.
     pub(crate) fn then(
         self,
-        response_handler: impl FnOnce(Result<T, String>, &mut WidgetMachine) -> Vec<Action>
+        response_handler: impl FnOnce(Result<T, crate::Error>, &mut WidgetMachine) -> Vec<Action>
             + Send
             + 'static,
     ) {

crates/matrix-sdk/src/widget/machine/from_widget.rs

@@ -12,20 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::fmt;
-
 use ruma::{
-    api::client::delayed_events::{
-        delayed_message_event, delayed_state_event, update_delayed_event,
+    api::client::{
+        delayed_events::{delayed_message_event, delayed_state_event, update_delayed_event},
+        error::ErrorBody,
     },
     events::{AnyTimelineEvent, MessageLikeEventType, StateEventType},
     serde::Raw,
     OwnedEventId, OwnedRoomId,
 };
 use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
 
 use super::{SendEventRequest, UpdateDelayedEventRequest};
-use crate::widget::StateKeySelector;
+use crate::{widget::StateKeySelector, Error, HttpError};
 
 #[derive(Deserialize, Debug)]
 #[serde(tag = "action", rename_all = "snake_case", content = "data")]
@@ -41,28 +41,80 @@ pub(super) enum FromWidgetRequest {
     DelayedEventUpdate(UpdateDelayedEventRequest),
 }
 
+/// The full response a client sends to a from widget request
+/// in case of an error.
 #[derive(Serialize)]
 pub(super) struct FromWidgetErrorResponse {
     error: FromWidgetError,
 }
 
 impl FromWidgetErrorResponse {
-    pub(super) fn new(e: impl fmt::Display) -> Self {
-        Self { error: FromWidgetError { message: e.to_string() } }
+    /// Create a error response to send to the widget from an http error.
+    pub(crate) fn from_http_error(error: &HttpError) -> Self {
+        Self {
+            error: FromWidgetError {
+                message: error.to_string(),
+                matrix_api_error: error.as_client_api_error().and_then(
+                    |api_error| match &api_error.body {
+                        ErrorBody::Standard { kind, message } => Some(FromWidgetMatrixErrorBody {
+                            http_status: api_error.status_code.as_u16().into(),
+                            response: json!({"errcode": kind.to_string(), "error": message }),
+                        }),
+                        _ => None,
+                    },
+                ),
+            },
+        }
+    }
+
+    /// Create a error response to send to the widget from a matrix sdk error.
+    pub(crate) fn from_error(error: &Error) -> Self {
+        match &error {
+            Error::Http(e) => FromWidgetErrorResponse::from_http_error(e),
+            Error::UnknownError(e) => FromWidgetErrorResponse::from_string(e.to_string()),
+            _ => FromWidgetErrorResponse::from_string(error.to_string()),
+        }
+    }
+
+    /// Create a error response to send to the widget from a string.
+    pub(crate) fn from_string<S: Into<String>>(error: S) -> Self {
+        Self { error: FromWidgetError { message: error.into(), matrix_api_error: None } }
     }
 }
 
+/// The serializable section of an error response send by the client as a
+/// response to a from widget request.
 #[derive(Serialize)]
 struct FromWidgetError {
+    /// A unspecified error message text that caused this widget action to fail.
+    /// This is useful to prompt the user on an issue but cannot be used to
+    /// decide on how to deal with the error.
     message: String,
+    /// An optional matrix error that contains specified
+    /// information and helps finding a work around for specific errors.
+    matrix_api_error: Option<FromWidgetMatrixErrorBody>,
+}
+
+/// The serializable section of a widget response that represents a matrix
+/// error.
+#[derive(Serialize)]
+struct FromWidgetMatrixErrorBody {
+    /// The status code of the http response
+    http_status: u32,
+    /// The matrix standard error response including the `errorcode` and the
+    /// `error` message as defined in the spec: https://spec.matrix.org/v1.12/client-server-api/#standard-error-response
+    response: Value,
 }
 
+/// The serializable section of a widget response containing the supported
+/// versions.
 #[derive(Serialize)]
 pub(super) struct SupportedApiVersionsResponse {
     supported_versions: Vec<ApiVersion>,
 }
 
 impl SupportedApiVersionsResponse {
+    /// The currently supported widget api versions from the rust widget driver.
     pub(super) fn new() -> Self {
         Self {
             supported_versions: vec![

crates/matrix-sdk/src/widget/machine/incoming.rs

@@ -37,8 +37,10 @@ pub(crate) enum IncomingMessage {
         /// The ID of the request that this response corresponds to.
         request_id: Uuid,
 
-        /// The result of the request: response data or error message.
-        response: Result<MatrixDriverResponse, String>,
+        /// The result of the request: response data or matrix sdk error.
+        /// Http errors will be forwarded to the widget in a specified format
+        /// so the widget can parse the error.
+        response: Result<MatrixDriverResponse, crate::Error>,
     },
 
     /// The `MatrixDriver` notified the `WidgetMachine` of a new matrix event.

crates/matrix-sdk/src/widget/machine/mod.rs

@@ -14,7 +14,7 @@
 
 //! No I/O logic of the [`WidgetDriver`].
 
-use std::{fmt, iter, time::Duration};
+use std::{iter, time::Duration};
 
 use driver_req::UpdateDelayedEventRequest;
 use from_widget::UpdateDelayedEventResponse;
@@ -48,10 +48,11 @@ use self::{
 #[cfg(doc)]
 use super::WidgetDriver;
 use super::{
-    capabilities,
+    capabilities::{SEND_DELAYED_EVENT, UPDATE_DELAYED_EVENT},
     filter::{MatrixEventContent, MatrixEventFilterInput},
     Capabilities, StateKeySelector,
 };
+use crate::Result;
 
 mod driver_req;
 mod from_widget;
@@ -212,7 +213,12 @@ impl WidgetMachine {
     ) -> Vec<Action> {
         let request = match raw_request.deserialize() {
             Ok(r) => r,
-            Err(e) => return vec![Self::send_from_widget_error_response(raw_request, e)],
+            Err(e) => {
+                return vec![Self::send_from_widget_error_response(
+                    raw_request,
+                    FromWidgetErrorResponse::from_error(&crate::Error::SerdeJson(e)),
+                )]
+            }
         };
 
         match request {
@@ -264,16 +270,18 @@ impl WidgetMachine {
                 let CapabilitiesState::Negotiated(capabilities) = &self.capabilities else {
                     let text =
                         "Received send update delayed event request before capabilities were negotiated";
-                    return vec![Self::send_from_widget_error_response(raw_request, text)];
+                    return vec![Self::send_from_widget_error_response(
+                        raw_request,
+                        FromWidgetErrorResponse::from_string(text),
+                    )];
                 };
 
                 if !capabilities.update_delayed_event {
                     return vec![Self::send_from_widget_error_response(
                         raw_request,
-                        format!(
-                            "Not allowed: missing the {} capability.",
-                            capabilities::UPDATE_DELAYED_EVENT
-                        ),
+                        FromWidgetErrorResponse::from_string(format!(
+                            "Not allowed: missing the {UPDATE_DELAYED_EVENT} capability."
+                        )),
                     )];
                 }
 
@@ -282,13 +290,15 @@ impl WidgetMachine {
                         action: req.action,
                         delay_id: req.delay_id,
                     });
-
-                request.then(|res, _machine| {
+                request.then(|result, _machine| {
                     vec![Self::send_from_widget_result_response(
                         raw_request,
                         // This is mapped to another type because the update_delay_event::Response
                         // does not impl Serialize
-                        res.map(Into::<UpdateDelayedEventResponse>::into),
+                        match result {
+                            Ok(response) => Ok(Into::<UpdateDelayedEventResponse>::into(response)),
+                            Err(e) => Err(FromWidgetErrorResponse::from_error(&e)),
+                        },
                     )]
                 });
 
@@ -304,7 +314,10 @@ impl WidgetMachine {
     ) -> Option<Action> {
         let CapabilitiesState::Negotiated(capabilities) = &self.capabilities else {
             let text = "Received read event request before capabilities were negotiated";
-            return Some(Self::send_from_widget_error_response(raw_request, text));
+            return Some(Self::send_from_widget_error_response(
+                raw_request,
+                FromWidgetErrorResponse::from_string(text),
+            ));
         };
 
         match request {
@@ -313,7 +326,9 @@ impl WidgetMachine {
                 {
                     return Some(Self::send_from_widget_error_response(
                         raw_request,
-                        "Not allowed to read message like event",
+                        FromWidgetErrorResponse::from_string(
+                            "Not allowed to read message like event",
+                        ),
                     ));
                 }
 
@@ -324,17 +339,23 @@ impl WidgetMachine {
                 let (request, action) = self.send_matrix_driver_request(request);
 
                 request.then(|result, machine| {
-                    let response = result.and_then(|mut events| {
-                        let CapabilitiesState::Negotiated(capabilities) = &machine.capabilities
-                        else {
-                            let err = "Received read event request before capabilities negotiation";
-                            return Err(err.into());
-                        };
-
-                        events.retain(|e| capabilities.raw_event_matches_read_filter(e));
-                        Ok(ReadEventResponse { events })
-                    });
-
+                    let response = match (result, &machine.capabilities) {
+                        (Ok(mut events), CapabilitiesState::Negotiated(capabilities)) => {
+                            events.retain(|e| capabilities.raw_event_matches_read_filter(e));
+                            Ok(ReadEventResponse { events })
+                        }
+                        (Ok(_), CapabilitiesState::Unset) => {
+                            Err(FromWidgetErrorResponse::from_string(
+                                "Received read event request before capabilities negotiation",
+                            ))
+                        }
+                        (Ok(_), CapabilitiesState::Negotiating) => {
+                            Err(FromWidgetErrorResponse::from_string(
+                                "Received read event request while capabilities were negotiating",
+                            ))
+                        }
+                        (Err(e), _) => Err(FromWidgetErrorResponse::from_error(&e)),
+                    };
                     vec![Self::send_from_widget_result_response(raw_request, response)]
                 });
 
@@ -364,14 +385,16 @@ impl WidgetMachine {
                     let request = ReadStateEventRequest { event_type, state_key };
                     let (request, action) = self.send_matrix_driver_request(request);
                     request.then(|result, _machine| {
-                        let response = result.map(|events| ReadEventResponse { events });
+                        let response = result
+                            .map(|events| ReadEventResponse { events })
+                            .map_err(|e| FromWidgetErrorResponse::from_error(&e));
                         vec![Self::send_from_widget_result_response(raw_request, response)]
                     });
                     action
                 } else {
                     Some(Self::send_from_widget_error_response(
                         raw_request,
-                        "Not allowed to read state event",
+                        FromWidgetErrorResponse::from_string("Not allowed to read state event"),
                     ))
                 }
             }
@@ -402,17 +425,16 @@ impl WidgetMachine {
         if !capabilities.send_delayed_event && request.delay.is_some() {
             return Some(Self::send_from_widget_error_response(
                 raw_request,
-                format!(
-                    "Not allowed: missing the {} capability.",
-                    capabilities::SEND_DELAYED_EVENT
-                ),
+                FromWidgetErrorResponse::from_string(format!(
+                    "Not allowed: missing the {SEND_DELAYED_EVENT} capability."
+                )),
             ));
         }
 
         if !capabilities.send.iter().any(|filter| filter.matches(&filter_in)) {
             return Some(Self::send_from_widget_error_response(
                 raw_request,
-                "Not allowed to send event",
+                FromWidgetErrorResponse::from_string("Not allowed to send event"),
             ));
         }
 
@@ -422,7 +444,10 @@ impl WidgetMachine {
             if let Ok(r) = result.as_mut() {
                 r.set_room_id(machine.room_id.clone());
             }
-            vec![Self::send_from_widget_result_response(raw_request, result)]
+            vec![Self::send_from_widget_result_response(
+                raw_request,
+                result.map_err(|e| FromWidgetErrorResponse::from_error(&e)),
+            )]
         });
 
         action
@@ -465,7 +490,7 @@ impl WidgetMachine {
     fn process_matrix_driver_response(
         &mut self,
         request_id: Uuid,
-        response: Result<MatrixDriverResponse, String>,
+        response: Result<MatrixDriverResponse>,
     ) -> Vec<Action> {
         match self.pending_matrix_driver_requests.extract(&request_id) {
             Ok(request) => request
@@ -500,14 +525,14 @@ impl WidgetMachine {
 
     fn send_from_widget_error_response(
         raw_request: Raw<FromWidgetRequest>,
-        error: impl fmt::Display,
+        error: FromWidgetErrorResponse,
     ) -> Action {
-        Self::send_from_widget_response(raw_request, FromWidgetErrorResponse::new(error))
+        Self::send_from_widget_response(raw_request, error)
     }
 
     fn send_from_widget_result_response(
         raw_request: Raw<FromWidgetRequest>,
-        result: Result<impl Serialize, impl fmt::Display>,
+        result: Result<impl Serialize, FromWidgetErrorResponse>,
     ) -> Action {
         match result {
             Ok(res) => Self::send_from_widget_response(raw_request, res),
@@ -613,7 +638,7 @@ impl ToWidgetRequestMeta {
 }
 
 type MatrixDriverResponseFn =
-    Box<dyn FnOnce(Result<MatrixDriverResponse, String>, &mut WidgetMachine) -> Vec<Action> + Send>;
+    Box<dyn FnOnce(Result<MatrixDriverResponse>, &mut WidgetMachine) -> Vec<Action> + Send>;
 
 pub(crate) struct MatrixDriverRequestMeta {
     response_fn: Option<MatrixDriverResponseFn>,

crates/matrix-sdk/src/widget/machine/tests/capabilities.rs

@@ -114,7 +114,7 @@ fn test_capabilities_failure_results_into_empty_capabilities() {
 
         machine.process(IncomingMessage::MatrixDriverResponse {
             request_id,
-            response: Err("OHMG!".into()),
+            response: Err(crate::Error::UnknownError("OHMG!".into())),
         })
     };
 

crates/matrix-sdk/src/widget/machine/tests/openid.rs

@@ -154,7 +154,7 @@ fn test_openid_fail_results_in_response_blocked() {
 
         machine.process(IncomingMessage::MatrixDriverResponse {
             request_id,
-            response: Err("Unlucky one".into()),
+            response: Err(crate::Error::UnknownError("Unlucky one".into())),
         })
     };