refactor(sqlite): Make Error more precise / useful

Author: jplatte

crates/matrix-sdk-sqlite/src/crypto_store.rs

@@ -114,46 +114,41 @@ impl SqliteCryptoStore {
         })
     }
 
-    fn serialize_value(&self, value: &impl Serialize) -> Result<Vec<u8>, CryptoStoreError> {
-        let serialized = rmp_serde::to_vec_named(value).map_err(CryptoStoreError::backend)?;
+    fn serialize_value(&self, value: &impl Serialize) -> Result<Vec<u8>> {
+        let serialized = rmp_serde::to_vec_named(value)?;
 
         if let Some(key) = &self.store_cipher {
-            let encrypted =
-                key.encrypt_value_data(serialized).map_err(CryptoStoreError::backend)?;
-            rmp_serde::to_vec_named(&encrypted).map_err(CryptoStoreError::backend)
+            let encrypted = key.encrypt_value_data(serialized)?;
+            Ok(rmp_serde::to_vec_named(&encrypted)?)
         } else {
             Ok(serialized)
         }
     }
 
-    fn deserialize_value<T: DeserializeOwned>(&self, value: &[u8]) -> Result<T, CryptoStoreError> {
+    fn deserialize_value<T: DeserializeOwned>(&self, value: &[u8]) -> Result<T> {
         if let Some(key) = &self.store_cipher {
-            let encrypted = rmp_serde::from_slice(value).map_err(CryptoStoreError::backend)?;
-            let decrypted = key.decrypt_value_data(encrypted).map_err(CryptoStoreError::backend)?;
+            let encrypted = rmp_serde::from_slice(value)?;
+            let decrypted = key.decrypt_value_data(encrypted)?;
 
-            rmp_serde::from_slice(&decrypted).map_err(CryptoStoreError::backend)
+            Ok(rmp_serde::from_slice(&decrypted)?)
         } else {
-            rmp_serde::from_slice(value).map_err(CryptoStoreError::backend)
+            Ok(rmp_serde::from_slice(value)?)
         }
     }
 
     fn deserialize_pickled_inbound_group_session(
         &self,
         value: &[u8],
         backed_up: bool,
-    ) -> Result<PickledInboundGroupSession, CryptoStoreError> {
+    ) -> Result<PickledInboundGroupSession> {
         let mut pickle: PickledInboundGroupSession = self.deserialize_value(value)?;
         // backed_up SQL column is source of truth, backed_up field in pickle
         // needed for other stores though
         pickle.backed_up = backed_up;
         Ok(pickle)
     }
 
-    fn deserialize_key_request(
-        &self,
-        value: &[u8],
-        sent_out: bool,
-    ) -> Result<GossipRequest, CryptoStoreError> {
+    fn deserialize_key_request(&self, value: &[u8], sent_out: bool) -> Result<GossipRequest> {
         let mut request: GossipRequest = self.deserialize_value(value)?;
         // sent_out SQL column is source of truth, sent_out field in serialized value
         // needed for other stores though
@@ -689,7 +684,7 @@ impl CryptoStore for SqliteCryptoStore {
                 }
 
                 for hash in &changes.message_hashes {
-                    let hash = rmp_serde::to_vec(hash).map_err(CryptoStoreError::backend)?;
+                    let hash = rmp_serde::to_vec(hash)?;
                     txn.add_olm_hash(&hash)?;
                 }
 
@@ -844,7 +839,7 @@ impl CryptoStore for SqliteCryptoStore {
             .get_tracked_users()
             .await?
             .iter()
-            .map(|value| self.deserialize_value(value))
+            .map(|value| Ok(self.deserialize_value(value)?))
             .collect()
     }
 

crates/matrix-sdk-sqlite/src/error.rs

@@ -51,41 +51,40 @@ pub enum OpenStoreError {
     SaveCipher(#[source] rusqlite::Error),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub(crate) enum Error {
-    #[cfg(feature = "crypto-store")]
-    Crypto(CryptoStoreError),
+    #[error(transparent)]
     Sqlite(rusqlite::Error),
+    #[error(transparent)]
     Pool(PoolError),
+    #[error(transparent)]
+    Encode(rmp_serde::encode::Error),
+    #[error(transparent)]
+    Decode(rmp_serde::decode::Error),
+    #[error(transparent)]
+    Encryption(matrix_sdk_store_encryption::Error),
 }
 
-#[cfg(feature = "crypto-store")]
-impl From<CryptoStoreError> for Error {
-    fn from(value: CryptoStoreError) -> Self {
-        Self::Crypto(value)
-    }
-}
-
-impl From<rusqlite::Error> for Error {
-    fn from(value: rusqlite::Error) -> Self {
-        Self::Sqlite(value)
-    }
+macro_rules! impl_from {
+    ( $ty:ty => $enum:ident::$variant:ident ) => {
+        impl From<$ty> for $enum {
+            fn from(value: $ty) -> Self {
+                Self::$variant(value)
+            }
+        }
+    };
 }
 
-impl From<PoolError> for Error {
-    fn from(value: PoolError) -> Self {
-        Self::Pool(value)
-    }
-}
+impl_from!(rusqlite::Error => Error::Sqlite);
+impl_from!(PoolError => Error::Pool);
+impl_from!(rmp_serde::encode::Error => Error::Encode);
+impl_from!(rmp_serde::decode::Error => Error::Decode);
+impl_from!(matrix_sdk_store_encryption::Error => Error::Encryption);
 
 #[cfg(feature = "crypto-store")]
 impl From<Error> for CryptoStoreError {
-    fn from(value: Error) -> Self {
-        match value {
-            Error::Crypto(c) => c,
-            Error::Sqlite(b) => CryptoStoreError::backend(b),
-            Error::Pool(b) => CryptoStoreError::backend(b),
-        }
+    fn from(e: Error) -> Self {
+        CryptoStoreError::backend(e)
     }
 }