IndexedDB: Clean up code after EventCacheStore-MediaStore split

crates/matrix-sdk-indexeddb/Cargo.toml

@@ -20,6 +20,9 @@ media-store = ["dep:matrix-sdk-base"]
 state-store = ["dep:matrix-sdk-base", "growable-bloom-filter"]
 e2e-encryption = ["dep:matrix-sdk-crypto"]
 testing = ["matrix-sdk-crypto?/testing"]
+experimental-encrypted-state-events = [
+    "matrix-sdk-crypto?/experimental-encrypted-state-events"
+]
 
 [dependencies]
 anyhow.workspace = true

crates/matrix-sdk-indexeddb/src/crypto_store/migrations/mod.rs

@@ -18,7 +18,7 @@ use indexed_db_futures::{prelude::*, web_sys::DomException};
 use tracing::info;
 use wasm_bindgen::JsValue;
 
-use crate::{crypto_store::Result, serializer::IndexeddbSerializer, IndexeddbCryptoStoreError};
+use crate::{crypto_store::Result, serializer::SafeEncodeSerializer, IndexeddbCryptoStoreError};
 
 mod old_keys;
 mod v0_to_v5;
@@ -100,7 +100,7 @@ const MAX_SUPPORTED_SCHEMA_VERSION: u32 = 99;
 /// of the schema if necessary.
 pub async fn open_and_upgrade_db(
     name: &str,
-    serializer: &IndexeddbSerializer,
+    serializer: &SafeEncodeSerializer,
 ) -> Result<IdbDatabase, IndexeddbCryptoStoreError> {
     // Move the DB version up from where it is to the latest version.
     //
@@ -282,7 +282,7 @@ mod tests {
     #[async_test]
     async fn test_count_lots_of_sessions_v8() {
         let cipher = Arc::new(StoreCipher::new().unwrap());
-        let serializer = IndexeddbSerializer::new(Some(cipher.clone()));
+        let serializer = SafeEncodeSerializer::new(Some(cipher.clone()));
         // Session keys are slow to create, so make one upfront and use it for every
         // session
         let session_key = create_session_key();
@@ -319,7 +319,7 @@ mod tests {
     /// Make lots of sessions and see how long it takes to count them in v10
     #[async_test]
     async fn test_count_lots_of_sessions_v10() {
-        let serializer = IndexeddbSerializer::new(Some(Arc::new(StoreCipher::new().unwrap())));
+        let serializer = SafeEncodeSerializer::new(Some(Arc::new(StoreCipher::new().unwrap())));
 
         // Session keys are slow to create, so make one upfront and use it for every
         // session
@@ -395,7 +395,7 @@ mod tests {
         i: usize,
         session_key: &SessionKey,
         cipher: &Arc<StoreCipher>,
-        serializer: &IndexeddbSerializer,
+        serializer: &SafeEncodeSerializer,
     ) -> (JsValue, JsValue) {
         let session = create_inbound_group_session(i, session_key);
         let pickled_session = session.pickle().await;
@@ -416,7 +416,7 @@ mod tests {
     async fn create_inbound_group_sessions3_record(
         i: usize,
         session_key: &SessionKey,
-        serializer: &IndexeddbSerializer,
+        serializer: &SafeEncodeSerializer,
     ) -> (JsValue, JsValue) {
         let session = create_inbound_group_session(i, session_key);
         let pickled_session = session.pickle().await;
@@ -682,7 +682,7 @@ mod tests {
         // entry.
         let db = create_v5_db(&db_name).await.unwrap();
 
-        let serializer = IndexeddbSerializer::new(store_cipher.clone());
+        let serializer = SafeEncodeSerializer::new(store_cipher.clone());
 
         let txn = db
             .transaction_on_one_with_mode(

crates/matrix-sdk-indexeddb/src/crypto_store/migrations/v10_to_v11.rs

@@ -24,14 +24,14 @@ use crate::{
         keys,
         migrations::{do_schema_upgrade, old_keys, MigrationDb},
     },
-    serializer::IndexeddbSerializer,
+    serializer::SafeEncodeSerializer,
 };
 
 /// Migrate data from `backup_keys.backup_key_v1` to
 /// `backup_keys.backup_version_v1`.
 pub(crate) async fn data_migrate(
     name: &str,
-    serializer: &IndexeddbSerializer,
+    serializer: &SafeEncodeSerializer,
 ) -> crate::crypto_store::Result<()> {
     let db = MigrationDb::new(name, 11).await?;
     let txn = db.transaction_on_one_with_mode(keys::BACKUP_KEYS, IdbTransactionMode::Readwrite)?;

crates/matrix-sdk-indexeddb/src/crypto_store/migrations/v13_to_v14.rs

@@ -19,10 +19,10 @@ use web_sys::{DomException, IdbTransactionMode};
 use super::MigrationDb;
 use crate::{
     crypto_store::{keys, migrations::do_schema_upgrade, Result},
-    serializer::IndexeddbSerializer,
+    serializer::SafeEncodeSerializer,
 };
 
-pub(crate) async fn data_migrate(name: &str, _: &IndexeddbSerializer) -> Result<()> {
+pub(crate) async fn data_migrate(name: &str, _: &SafeEncodeSerializer) -> Result<()> {
     let db = MigrationDb::new(name, 14).await?;
     let transaction = db.transaction_on_one_with_mode(
         keys::RECEIVED_ROOM_KEY_BUNDLES,

crates/matrix-sdk-indexeddb/src/crypto_store/migrations/v5_to_v7.rs

@@ -30,7 +30,7 @@ use crate::{
         migrations::{add_nonunique_index, do_schema_upgrade, old_keys, v7, MigrationDb},
         Result,
     },
-    serializer::IndexeddbSerializer,
+    serializer::SafeEncodeSerializer,
     IndexeddbCryptoStoreError,
 };
 
@@ -51,7 +51,7 @@ pub(crate) async fn schema_add(name: &str) -> Result<(), DomException> {
 }
 
 /// Migrate data from `inbound_group_sessions` into `inbound_group_sessions2`.
-pub(crate) async fn data_migrate(name: &str, serializer: &IndexeddbSerializer) -> Result<()> {
+pub(crate) async fn data_migrate(name: &str, serializer: &SafeEncodeSerializer) -> Result<()> {
     let db = MigrationDb::new(name, 7).await?;
 
     // The new store has been made for inbound group sessions; time to populate it.

crates/matrix-sdk-indexeddb/src/crypto_store/migrations/v7.rs

@@ -34,7 +34,7 @@ pub struct InboundGroupSessionIndexedDbObject2 {
     #[serde(
         default,
         skip_serializing_if = "std::ops::Not::not",
-        with = "crate::serialize_bool_for_indexeddb"
+        with = "crate::serializer::foreign::bool"
     )]
     pub needs_backup: bool,
 }

crates/matrix-sdk-indexeddb/src/crypto_store/migrations/v7_to_v8.rs

@@ -25,15 +25,15 @@ use crate::{
         migrations::{do_schema_upgrade, old_keys, v7, MigrationDb},
         Result,
     },
-    serializer::IndexeddbSerializer,
+    serializer::SafeEncodeSerializer,
     IndexeddbCryptoStoreError,
 };
 
 /// In the migration v5 to v7, we incorrectly copied the keys in
 /// `inbound_group_sessions` verbatim into `inbound_group_sessions2`. What we
 /// should have done is re-hash them using the new table name, so we fix them up
 /// here.
-pub(crate) async fn data_migrate(name: &str, serializer: &IndexeddbSerializer) -> Result<()> {
+pub(crate) async fn data_migrate(name: &str, serializer: &SafeEncodeSerializer) -> Result<()> {
     let db = MigrationDb::new(name, 8).await?;
 
     let txn = db.transaction_on_one_with_mode(

crates/matrix-sdk-indexeddb/src/crypto_store/migrations/v8_to_v10.rs

@@ -29,7 +29,7 @@ use crate::{
         },
         InboundGroupSessionIndexedDbObject, Result,
     },
-    serializer::IndexeddbSerializer,
+    serializer::SafeEncodeSerializer,
     IndexeddbCryptoStoreError,
 };
 
@@ -59,7 +59,7 @@ pub(crate) async fn schema_add(name: &str) -> Result<(), DomException> {
 }
 
 /// Migrate data from `inbound_group_sessions2` into `inbound_group_sessions3`.
-pub(crate) async fn data_migrate(name: &str, serializer: &IndexeddbSerializer) -> Result<()> {
+pub(crate) async fn data_migrate(name: &str, serializer: &SafeEncodeSerializer) -> Result<()> {
     let db = MigrationDb::new(name, 10).await?;
 
     let txn = db.transaction_on_multi_with_mode(

crates/matrix-sdk-indexeddb/src/crypto_store/mod.rs

@@ -52,7 +52,7 @@ use web_sys::IdbKeyRange;
 
 use crate::{
     crypto_store::migrations::open_and_upgrade_db,
-    serializer::{IndexeddbSerializer, IndexeddbSerializerError, MaybeEncrypted},
+    serializer::{MaybeEncrypted, SafeEncodeSerializer, SafeEncodeSerializerError},
 };
 
 mod migrations;
@@ -122,7 +122,7 @@ pub struct IndexeddbCryptoStore {
     name: String,
     pub(crate) inner: IdbDatabase,
 
-    serializer: IndexeddbSerializer,
+    serializer: SafeEncodeSerializer,
     save_changes_lock: Arc<Mutex<()>>,
 }
 
@@ -155,14 +155,14 @@ pub enum IndexeddbCryptoStoreError {
     SchemaTooNewError { max_supported_version: u32, current_version: u32 },
 }
 
-impl From<IndexeddbSerializerError> for IndexeddbCryptoStoreError {
-    fn from(value: IndexeddbSerializerError) -> Self {
+impl From<SafeEncodeSerializerError> for IndexeddbCryptoStoreError {
+    fn from(value: SafeEncodeSerializerError) -> Self {
         match value {
-            IndexeddbSerializerError::Serialization(error) => Self::Serialization(error),
-            IndexeddbSerializerError::DomException { code, name, message } => {
+            SafeEncodeSerializerError::Serialization(error) => Self::Serialization(error),
+            SafeEncodeSerializerError::DomException { code, name, message } => {
                 Self::DomException { code, name, message }
             }
-            IndexeddbSerializerError::CryptoStoreError(crypto_store_error) => {
+            SafeEncodeSerializerError::CryptoStoreError(crypto_store_error) => {
                 Self::CryptoStoreError(crypto_store_error)
             }
         }
@@ -287,7 +287,7 @@ impl IndexeddbCryptoStore {
     ) -> Result<Self> {
         let name = format!("{prefix:0}::matrix-sdk-crypto");
 
-        let serializer = IndexeddbSerializer::new(store_cipher);
+        let serializer = SafeEncodeSerializer::new(store_cipher);
         debug!("IndexedDbCryptoStore: opening main store {name}");
         let db = open_and_upgrade_db(&name, &serializer).await?;
 
@@ -1733,7 +1733,7 @@ struct GossipRequestIndexedDbObject {
     #[serde(
         default,
         skip_serializing_if = "std::ops::Not::not",
-        with = "crate::serialize_bool_for_indexeddb"
+        with = "crate::serializer::foreign::bool"
     )]
     unsent: bool,
 }
@@ -1766,7 +1766,7 @@ struct InboundGroupSessionIndexedDbObject {
     #[serde(
         default,
         skip_serializing_if = "std::ops::Not::not",
-        with = "crate::serialize_bool_for_indexeddb"
+        with = "crate::serializer::foreign::bool"
     )]
     needs_backup: bool,
 
@@ -1804,7 +1804,7 @@ impl InboundGroupSessionIndexedDbObject {
     /// session.
     pub async fn from_session(
         session: &InboundGroupSession,
-        serializer: &IndexeddbSerializer,
+        serializer: &SafeEncodeSerializer,
     ) -> Result<Self, CryptoStoreError> {
         let session_id =
             serializer.encode_key_as_string(keys::INBOUND_GROUP_SESSIONS_V3, session.session_id());
@@ -1837,7 +1837,7 @@ mod unit_tests {
     use ruma::{device_id, room_id, user_id};
 
     use super::InboundGroupSessionIndexedDbObject;
-    use crate::serializer::{IndexeddbSerializer, MaybeEncrypted};
+    use crate::serializer::{MaybeEncrypted, SafeEncodeSerializer};
 
     #[test]
     fn needs_backup_is_serialized_as_a_u8_in_json() {
@@ -1915,7 +1915,7 @@ mod unit_tests {
         )
         .unwrap();
 
-        InboundGroupSessionIndexedDbObject::from_session(&session, &IndexeddbSerializer::new(None))
+        InboundGroupSessionIndexedDbObject::from_session(&session, &SafeEncodeSerializer::new(None))
             .await
             .unwrap()
     }

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

@@ -0,0 +1,23 @@
+// Copyright 2025 The Matrix.org Foundation C.I.C.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+use matrix_sdk_base::{SendOutsideWasm, SyncOutsideWasm};
+
+/// A trait that combines the necessary traits needed for asynchronous runtimes,
+/// but excludes them when running in a web environment - i.e., when
+/// `#[cfg(target_family = "wasm")]`.
+pub trait AsyncErrorDeps: std::error::Error + SendOutsideWasm + SyncOutsideWasm + 'static {}
+
+impl<T> AsyncErrorDeps for T where T: std::error::Error + SendOutsideWasm + SyncOutsideWasm + 'static
+{}

crates/matrix-sdk-indexeddb/src/event_cache_store/builder.rs

@@ -12,16 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License
 
+// At the moment, this builder is not public outside of the crate, so we
+// get a few dead code warnings; however, this will eventually be a public
+// type, at which point the line below can be removed.
+#![allow(dead_code)]
+
 use std::{rc::Rc, sync::Arc};
 
 use matrix_sdk_store_encryption::StoreCipher;
 
 use crate::{
     event_cache_store::{
         error::IndexeddbEventCacheStoreError, migrations::open_and_upgrade_db,
-        serializer::IndexeddbEventCacheStoreSerializer, IndexeddbEventCacheStore,
+        IndexeddbEventCacheStore,
     },
-    serializer::IndexeddbSerializer,
+    serializer::{IndexedTypeSerializer, SafeEncodeSerializer},
 };
 
 /// A type for conveniently building an [`IndexeddbEventCacheStore`]
@@ -65,9 +70,7 @@ impl IndexeddbEventCacheStoreBuilder {
     pub async fn build(self) -> Result<IndexeddbEventCacheStore, IndexeddbEventCacheStoreError> {
         Ok(IndexeddbEventCacheStore {
             inner: Rc::new(open_and_upgrade_db(&self.database_name).await?),
-            serializer: IndexeddbEventCacheStoreSerializer::new(IndexeddbSerializer::new(
-                self.store_cipher,
-            )),
+            serializer: IndexedTypeSerializer::new(SafeEncodeSerializer::new(self.store_cipher)),
         })
     }
 }

crates/matrix-sdk-indexeddb/src/event_cache_store/error.rs

@@ -12,18 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License
 
-use matrix_sdk_base::{event_cache::store::EventCacheStoreError, SendOutsideWasm, SyncOutsideWasm};
+use matrix_sdk_base::event_cache::store::EventCacheStoreError;
+use serde::de::Error;
 use thiserror::Error;
 
-use crate::event_cache_store::transaction::IndexeddbEventCacheStoreTransactionError;
-
-/// A trait that combines the necessary traits needed for asynchronous runtimes,
-/// but excludes them when running in a web environment - i.e., when
-/// `#[cfg(target_family = "wasm")]`.
-pub trait AsyncErrorDeps: std::error::Error + SendOutsideWasm + SyncOutsideWasm + 'static {}
-
-impl<T> AsyncErrorDeps for T where T: std::error::Error + SendOutsideWasm + SyncOutsideWasm + 'static
-{}
+use crate::transaction::TransactionError;
 
 #[derive(Debug, Error)]
 pub enum IndexeddbEventCacheStoreError {
@@ -38,7 +31,7 @@ pub enum IndexeddbEventCacheStoreError {
     #[error("no max chunk id")]
     NoMaxChunkId,
     #[error("transaction: {0}")]
-    Transaction(#[from] IndexeddbEventCacheStoreTransactionError),
+    Transaction(#[from] TransactionError),
 }
 
 impl From<web_sys::DomException> for IndexeddbEventCacheStoreError {
@@ -65,3 +58,15 @@ impl From<IndexeddbEventCacheStoreError> for EventCacheStoreError {
         }
     }
 }
+
+impl From<TransactionError> for EventCacheStoreError {
+    fn from(value: TransactionError) -> Self {
+        use TransactionError::*;
+
+        match value {
+            DomException { .. } => Self::InvalidData { details: value.to_string() },
+            Serialization(e) => Self::Serialization(serde_json::Error::custom(e.to_string())),
+            ItemIsNotUnique | ItemNotFound => Self::InvalidData { details: value.to_string() },
+        }
+    }
+}

crates/matrix-sdk-indexeddb/src/event_cache_store/integration_tests.rs

@@ -26,9 +26,9 @@ use matrix_sdk_base::{
 use matrix_sdk_test::DEFAULT_TEST_ROOM_ID;
 use ruma::room_id;
 
-use crate::event_cache_store::{
-    transaction::IndexeddbEventCacheStoreTransactionError, IndexeddbEventCacheStore,
-    IndexeddbEventCacheStoreError,
+use crate::{
+    event_cache_store::{IndexeddbEventCacheStore, IndexeddbEventCacheStoreError},
+    transaction::TransactionError,
 };
 
 pub async fn test_linked_chunk_new_items_chunk(store: IndexeddbEventCacheStore) {
@@ -423,9 +423,7 @@ pub async fn test_linked_chunk_update_is_a_transaction(store: IndexeddbEventCach
     // The operation fails with a constraint violation error.
     assert_matches!(
         err,
-        IndexeddbEventCacheStoreError::Transaction(
-            IndexeddbEventCacheStoreTransactionError::DomException { .. }
-        )
+        IndexeddbEventCacheStoreError::Transaction(TransactionError::DomException { .. })
     );
 
     // If the updates have been handled transactionally, then no new chunks should