IndexedDB: Add initial implementation of EventCacheStore

crates/matrix-sdk-indexeddb/CHANGELOG.md

@@ -6,6 +6,12 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased] - ReleaseDate
 
+### Features
+
+- Add `IndexeddbEventCacheStore` for providing an IndexedDB implementation
+  of the `EventCacheStore`. Expose the type through `IndexeddbEventCacheStoreBuilder`
+  which ensures object stores in IndexedDB are properly initialized.
+
 ## [0.11.0] - 2025-04-11
 
 No notable changes in this release.

crates/matrix-sdk-indexeddb/Cargo.toml

@@ -14,9 +14,10 @@ default-target = "wasm32-unknown-unknown"
 rustdoc-args = ["--cfg", "docsrs", "--generate-link-to-definition"]
 
 [features]
-default = ["e2e-encryption", "state-store"]
+default = ["e2e-encryption", "state-store", "event-cache-store"]
 state-store = ["dep:matrix-sdk-base", "growable-bloom-filter"]
 e2e-encryption = ["dep:matrix-sdk-crypto"]
+event-cache-store = ["e2e-encryption"]
 testing = ["matrix-sdk-crypto?/testing"]
 
 [dependencies]
@@ -55,10 +56,17 @@ matrix-sdk-common = { workspace = true, features = ["js"] }
 matrix-sdk-crypto = { workspace = true, features = ["js", "testing"] }
 matrix-sdk-test.workspace = true
 rand.workspace = true
-tracing-subscriber = { workspace = true, features = ["registry", "tracing-log"] }
+tracing-subscriber = { workspace = true, features = [
+    "registry",
+    "tracing-log",
+] }
 uuid.workspace = true
 wasm-bindgen-test.workspace = true
-web-sys = { workspace = true, features = ["IdbKeyRange", "Window", "Performance"] }
+web-sys = { workspace = true, features = [
+    "IdbKeyRange",
+    "Window",
+    "Performance",
+] }
 
 [lints]
 workspace = true

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

@@ -0,0 +1,47 @@
+use std::sync::Arc;
+
+use matrix_sdk_base::event_cache::store::MemoryStore;
+use matrix_sdk_store_encryption::StoreCipher;
+
+use crate::{
+    event_cache_store::{migrations::open_and_upgrade_db, IndexeddbEventCacheStore, Result},
+    serializer::IndexeddbSerializer,
+};
+
+/// Builder for [`IndexeddbEventCacheStore`]
+pub struct IndexeddbEventCacheStoreBuilder {
+    name: Option<String>,
+    store_cipher: Option<Arc<StoreCipher>>,
+}
+
+impl IndexeddbEventCacheStoreBuilder {
+    pub fn new() -> Self {
+        Self { name: None, store_cipher: None }
+    }
+
+    pub fn name(mut self, name: String) -> Self {
+        self.name = Some(name);
+        self
+    }
+
+    pub fn store_cipher(mut self, store_cipher: Arc<StoreCipher>) -> Self {
+        self.store_cipher = Some(store_cipher);
+        self
+    }
+
+    pub async fn build(self) -> Result<IndexeddbEventCacheStore> {
+        let name = self.name.unwrap_or_else(|| "event_cache".to_owned());
+        let store = IndexeddbEventCacheStore {
+            inner: open_and_upgrade_db(&name).await?,
+            serializer: IndexeddbSerializer::new(self.store_cipher),
+            media_store: MemoryStore::new(),
+        };
+        Ok(store)
+    }
+}
+
+impl Default for IndexeddbEventCacheStoreBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}

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

@@ -0,0 +1,58 @@
+// 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 indexed_db_futures::{
+    idb_object_store::IdbObjectStoreParameters,
+    request::{IdbOpenDbRequestLike, OpenDbRequest},
+    IdbDatabase, IdbKeyPath, IdbVersionChangeEvent,
+};
+use wasm_bindgen::JsValue;
+use web_sys::DomException;
+
+use crate::event_cache_store::keys;
+
+const CURRENT_DB_VERSION: u32 = 2;
+
+pub async fn open_and_upgrade_db(name: &str) -> Result<IdbDatabase, DomException> {
+    let mut db = IdbDatabase::open(name)?.await?;
+    let old_version = db.version() as u32;
+    if old_version == 1 {
+        db = setup_db(db, CURRENT_DB_VERSION).await?;
+    }
+    Ok(db)
+}
+
+async fn setup_db(db: IdbDatabase, version: u32) -> Result<IdbDatabase, DomException> {
+    let name = db.name();
+    db.close();
+
+    let db = {
+        let mut request: OpenDbRequest = IdbDatabase::open_u32(&name, version)?;
+        request.set_on_upgrade_needed(Some(
+            move |events: &IdbVersionChangeEvent| -> Result<(), JsValue> {
+                events.db().create_object_store(keys::CORE)?;
+
+                let mut params = IdbObjectStoreParameters::new();
+                params.key_path(Some(&IdbKeyPath::from("id")));
+                events.db().create_object_store_with_params(keys::LINKED_CHUNKS, &params)?;
+                events.db().create_object_store_with_params(keys::EVENTS, &params)?;
+                events.db().create_object_store_with_params(keys::GAPS, &params)?;
+                Ok(())
+            },
+        ));
+        request.await?
+    };
+
+    Ok(db)
+}