Drop dependency on anyhow (#241)

Preparation for upgrading to matrix-rust-sdk 0.12.0.

As of matrix-org/matrix-rust-sdk#5082, some of the the errors returned by the rust SDK are no longer Send + Sync. That means we can no longer pass them into anyhow::Error::from().

As it turns out, most of our uses of anyhow::Error are redundant anyway. This patch set (review commit-by-commit) removes the places we use anyhow::Error, and means that we will be able to build against rust-sdk 0.12.0.

Fixes: #232

Author: richvdh

Cargo.lock

@@ -58,7 +58,6 @@ default = ["qrcode"]
 qrcode = ["matrix-sdk-crypto/qrcode", "dep:matrix-sdk-qrcode"]
 
 [dependencies]
-anyhow = "1.0.68"
 console_error_panic_hook = "0.1.7"
 futures-util = "0.3.27"
 # getrandom is not a direct dependency, but we need to enable the "wasm_js" backend.
@@ -71,6 +70,7 @@ matrix-sdk-qrcode = { git = "https://github.com/matrix-org/matrix-rust-sdk", rev
 serde = "1.0.91"
 serde_json = "1.0.91"
 serde-wasm-bindgen = "0.6.5"
+thiserror = "2.0.12"
 tracing = { version = "0.1.36", default-features = false, features = ["std"] }
 tracing-subscriber = { version = "0.3.14", default-features = false, features = ["registry", "std", "ansi"] }
 url = "2.5.0"

Cargo.toml

@@ -1,18 +1,29 @@
 use std::future::Future;
 
-use futures_util::TryFutureExt;
 use js_sys::Promise;
 use wasm_bindgen::{JsError, JsValue, UnwrapThrowExt};
 use wasm_bindgen_futures::spawn_local;
 
+/**
+ * Convert a Rust [`Future`] which returns [`Result<T, JsError>`] into a
+ * Javascript [`Promise`] which either resolves with an object of type `T`,
+ * or rejects with an error of type [`Error`].
+ *
+ * [`Error`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+ */
 pub(crate) fn future_to_promise<F, T>(future: F) -> Promise
 where
-    F: Future<Output = Result<T, anyhow::Error>> + 'static,
+    F: Future<Output = Result<T, JsError>> + 'static,
     T: Into<JsValue>,
 {
-    future_to_promise_with_custom_error(future.map_err(|error| JsError::new(&error.to_string())))
+    future_to_promise_with_custom_error(future)
 }
 
+/**
+ * Convert a Rust [`Future`] which returns [`Result<T, E>`] into a
+ * Javascript [`Promise`] which either resolves with an object of type `T`,
+ * or rejects with an error of type `E`.
+ */
 pub(crate) fn future_to_promise_with_custom_error<F, T, E>(future: F) -> Promise
 where
     F: Future<Output = Result<T, E>> + 'static,

src/future.rs

@@ -16,7 +16,6 @@
 
 use std::time::Duration;
 
-use anyhow::Context;
 use js_sys::{Date, Uint8Array};
 use matrix_sdk_common::ruma::{
     DeviceKeyAlgorithm, MilliSecondsSinceUnixEpoch, SecondsSinceUnixEpoch, UInt,
@@ -120,8 +119,7 @@ impl Migration {
         store_handle: &StoreHandle,
     ) -> Result<JsValue, JsError> {
         migrate_base_data_to_store(data, &(pickle_key.to_vec()), store_handle.store.as_ref())
-            .await
-            .map_err(|e| JsError::from(&*e))?;
+            .await?;
         Ok(JsValue::UNDEFINED)
     }
 }
@@ -130,13 +128,13 @@ async fn migrate_base_data_to_store(
     data: &BaseMigrationData,
     pickle_key: &[u8],
     store: &DynCryptoStore,
-) -> anyhow::Result<()> {
-    let user_id = data.user_id.clone().context("User ID not specified")?.inner;
+) -> Result<(), JsError> {
+    let user_id = data.user_id.clone().ok_or(JsError::new("User ID not specified"))?.inner;
     let account = vodozemac::olm::Account::from_libolm_pickle(&data.pickled_account, pickle_key)?;
     let account =
         matrix_sdk_crypto::olm::Account::from_pickle(matrix_sdk_crypto::olm::PickledAccount {
             user_id: user_id.clone(),
-            device_id: data.device_id.clone().context("Device ID not specified")?.inner,
+            device_id: data.device_id.clone().ok_or(JsError::new("Device ID not specified"))?.inner,
             pickle: account.pickle(),
             // Legacy crypto in the js-sdk does not keep a record of whether it has published the
             // device keys to the server (it does it every time the stack is started). For safety,
@@ -253,9 +251,7 @@ impl Migration {
             .map(|session| libolm_pickled_session_to_rust_pickled_session(session, &pickle_key))
             .collect::<Result<_>>()?;
 
-        import_olm_sessions_to_store(rust_sessions, store_handle.store.as_ref())
-            .await
-            .map_err(|e| JsError::from(&*e))?;
+        import_olm_sessions_to_store(rust_sessions, store_handle.store.as_ref()).await?;
         Ok(JsValue::UNDEFINED)
     }
 }
@@ -295,11 +291,11 @@ fn libolm_pickled_session_to_rust_pickled_session(
 async fn import_olm_sessions_to_store(
     pickled_sessions: Vec<matrix_sdk_crypto::olm::PickledSession>,
     store: &DynCryptoStore,
-) -> anyhow::Result<()> {
+) -> Result<(), JsError> {
     let account = store
         .load_account()
         .await?
-        .context("Base data must be imported before calling `migrateOlmSessions`")?;
+        .ok_or(JsError::new("Base data must be imported before calling `migrateOlmSessions`"))?;
 
     let sessions = pickled_sessions
         .into_iter()
@@ -409,9 +405,7 @@ impl Migration {
             })
             .collect::<Result<_>>()?;
 
-        import_megolm_sessions_to_store(rust_sessions, store_handle.store.as_ref())
-            .await
-            .map_err(|e| JsError::from(&*e))?;
+        import_megolm_sessions_to_store(rust_sessions, store_handle.store.as_ref()).await?;
         Ok(JsValue::UNDEFINED)
     }
 }
@@ -455,7 +449,7 @@ fn libolm_pickled_megolm_session_to_rust_pickled_session(
 async fn import_megolm_sessions_to_store(
     pickled_sessions: Vec<matrix_sdk_crypto::olm::PickledInboundGroupSession>,
     store: &DynCryptoStore,
-) -> anyhow::Result<()> {
+) -> Result<(), JsError> {
     let inbound_group_sessions = pickled_sessions
         .into_iter()
         .map(matrix_sdk_crypto::olm::InboundGroupSession::from_pickle)

src/libolm_migration.rs

@@ -38,7 +38,7 @@ use crate::{
     future::{future_to_promise, future_to_promise_with_custom_error},
     identifiers, identities, olm, requests,
     requests::{outgoing_request_to_js_value, CrossSigningBootstrapRequests, ToDeviceRequest},
-    responses::{self, response_from_string},
+    responses::{self, response_from_string, UnsupportedAlgorithmError},
     store,
     store::{RoomKeyInfo, RoomKeyWithheldInfo, StoreHandle},
     sync_events,
@@ -99,9 +99,7 @@ impl OlmMachine {
         let user_id = user_id.inner.clone();
         let device_id = device_id.inner.clone();
 
-        let store_handle = StoreHandle::open(store_name, store_passphrase)
-            .await
-            .map_err(|e| JsError::from(&*e))?;
+        let store_handle = StoreHandle::open(store_name, store_passphrase).await?;
         Self::init_helper(user_id, device_id, store_handle).await
     }
 
@@ -513,13 +511,15 @@ impl OlmMachine {
                 .map_err(MegolmDecryptionError::from)?
                 .into();
 
-            responses::DecryptedRoomEvent::try_from(room_event).map_err(|e: anyhow::Error| {
-                // This happens if we somehow encounter a room event whose encryption info we
-                // don't understand (e.g., it is encrypted with Olm rather than
-                // Megolm). That seems pretty unlikely. If it happens, let's
-                // just treat it as a generic UTD.
-                MegolmDecryptionError::unable_to_decrypt(format!("{e:#}"))
-            })
+            responses::DecryptedRoomEvent::try_from(room_event).map_err(
+                |e: UnsupportedAlgorithmError| {
+                    // This happens if we somehow encounter a room event whose encryption info we
+                    // don't understand (e.g., it is encrypted with Olm rather than
+                    // Megolm). That seems pretty unlikely. If it happens, let's
+                    // just treat it as a generic UTD.
+                    MegolmDecryptionError::unable_to_decrypt(format!("{e:#}"))
+                },
+            )
         }))
     }
 
@@ -979,7 +979,7 @@ impl OlmMachine {
         let me = self.inner.clone();
 
         future_to_promise(async move {
-            stream_to_json_array(pin!(
+            Ok(stream_to_json_array(pin!(
                 me.store()
                     .export_room_keys_stream(|session| {
                         let session = session.clone();
@@ -992,7 +992,7 @@ impl OlmMachine {
                     })
                     .await?,
             ))
-            .await
+            .await?)
         })
     }
 
@@ -1696,7 +1696,7 @@ pub(crate) async fn promise_result_to_future(
     }
 }
 
-async fn stream_to_json_array<T, S>(mut stream: Pin<&mut S>) -> Result<String, anyhow::Error>
+async fn stream_to_json_array<T, S>(mut stream: Pin<&mut S>) -> Result<String, serde_json::Error>
 where
     T: Serialize,
     S: Stream<Item = T>,
@@ -1709,5 +1709,5 @@ where
     }
     seq.end()?;
 
-    Ok(String::from_utf8(stream_json)?)
+    Ok(String::from_utf8(stream_json).expect("serde_json generated invalid UTF8"))
 }

src/machine.rs

@@ -2,7 +2,6 @@
 
 use std::sync::Arc;
 
-use anyhow::anyhow;
 use js_sys::{Array, JsString};
 pub(crate) use matrix_sdk_common::ruma::api::client::{
     backup::add_backup_keys::v3::Response as KeysBackupResponse,
@@ -19,6 +18,7 @@ use matrix_sdk_common::{
     ruma::{self, api::IncomingResponse as RumaIncomingResponse},
 };
 use matrix_sdk_crypto::types::requests::AnyIncomingResponse;
+use thiserror::Error;
 use wasm_bindgen::prelude::*;
 
 use crate::{encryption, identifiers, requests::RequestType};
@@ -216,7 +216,7 @@ impl DecryptedRoomEvent {
 }
 
 impl TryFrom<matrix_sdk_common::deserialized_responses::TimelineEvent> for DecryptedRoomEvent {
-    type Error = anyhow::Error;
+    type Error = UnsupportedAlgorithmError;
 
     fn try_from(
         value: matrix_sdk_common::deserialized_responses::TimelineEvent,
@@ -288,7 +288,7 @@ impl EncryptionInfo {
 }
 
 impl TryFrom<Arc<matrix_sdk_common::deserialized_responses::EncryptionInfo>> for EncryptionInfo {
-    type Error = anyhow::Error;
+    type Error = UnsupportedAlgorithmError;
 
     fn try_from(
         value: Arc<matrix_sdk_common::deserialized_responses::EncryptionInfo>,
@@ -306,8 +306,8 @@ impl TryFrom<Arc<matrix_sdk_common::deserialized_responses::EncryptionInfo>> for
                     verification_state: value.verification_state.clone(),
                 })
             }
-            AlgorithmInfo::OlmV1Curve25519AesSha2 { .. } => Err(anyhow!(
-                "AlgorithmInfo::OlmV1Curve25519AesSha2 is not applicable for room event EncryptionInfo",
+            AlgorithmInfo::OlmV1Curve25519AesSha2 { .. } => Err(UnsupportedAlgorithmError(
+                "AlgorithmInfo::OlmV1Curve25519AesSha2 is not applicable for room event EncryptionInfo".to_owned()
             )),
         }
     }
@@ -344,14 +344,15 @@ pub struct ToDeviceEncryptionInfo {
 }
 
 impl TryFrom<matrix_sdk_common::deserialized_responses::EncryptionInfo> for ToDeviceEncryptionInfo {
-    type Error = anyhow::Error;
+    type Error = UnsupportedAlgorithmError;
 
     fn try_from(
         value: matrix_sdk_common::deserialized_responses::EncryptionInfo,
     ) -> Result<Self, Self::Error> {
         match &value.algorithm_info {
-            AlgorithmInfo::MegolmV1AesSha2 { .. } => Err(anyhow!(
-                "AlgorithmInfo::MegolmV1AesSha2 is not applicable for ToDeviceEncryptionInfo",
+            AlgorithmInfo::MegolmV1AesSha2 { .. } => Err(UnsupportedAlgorithmError(
+                "AlgorithmInfo::MegolmV1AesSha2 is not applicable for ToDeviceEncryptionInfo"
+                    .to_owned(),
             )),
             AlgorithmInfo::OlmV1Curve25519AesSha2 { curve25519_public_key_base64 } => Ok(Self {
                 sender_curve25519_key_base64: curve25519_public_key_base64.clone(),
@@ -375,3 +376,11 @@ impl ToDeviceEncryptionInfo {
         )
     }
 }
+
+/// Error type returned when converting
+/// [`matrix_sdk_common::deserialized_responses::EncryptionInfo`] to one of our
+/// own types: the `algorithm_info` on the `EncryptionInfo` was of an unexpected
+/// type.
+#[derive(Error, Debug)]
+#[error("{0}")]
+pub struct UnsupportedAlgorithmError(String);

src/responses.rs

@@ -2,7 +2,6 @@
 
 use std::sync::Arc;
 
-use anyhow::Context;
 use matrix_sdk_crypto::{
     store::{DynCryptoStore, IntoCryptoStore, MemoryStore},
     types::BackupSecrets,
@@ -50,19 +49,19 @@ impl StoreHandle {
         store_name: Option<String>,
         store_passphrase: Option<String>,
     ) -> Result<StoreHandle, JsError> {
-        StoreHandle::open(store_name, store_passphrase).await.map_err(|e| JsError::from(&*e))
+        StoreHandle::open(store_name, store_passphrase).await
     }
 
     pub(crate) async fn open(
         store_name: Option<String>,
         store_passphrase: Option<String>,
-    ) -> Result<StoreHandle, anyhow::Error> {
+    ) -> Result<StoreHandle, JsError> {
         let store = match store_name {
             Some(store_name) => Self::open_indexeddb(&store_name, store_passphrase).await?,
 
             None => {
                 if store_passphrase.is_some() {
-                    return Err(anyhow::Error::msg(
+                    return Err(JsError::new(
                         "The `store_passphrase` has been set, but it has an effect only if \
                         `store_name` is set, which is not; please provide one",
                     ));
@@ -118,8 +117,7 @@ impl StoreHandle {
             store_key
                 .as_slice()
                 .try_into()
-                .with_context(|| "Expected a key of length 32")
-                .map_err(|e| JsError::from(&*e))?,
+                .map_err(|_| JsError::new("Expected a key of length 32"))?,
         );
         store_key.zeroize();
 

src/store.rs

@@ -1034,9 +1034,7 @@ impl VerificationRequest {
                 .transpose()
             {
                 Ok(a) => Ok(a),
-                Err(_) => {
-                    Err(anyhow::Error::msg("Failed to build the outgoing verification request"))
-                }
+                Err(_) => Err(JsError::new("Failed to build the outgoing verification request")),
             }
         })
     }