feat(event cache store): add an IndexedDB implementation

crates/matrix-sdk-indexeddb/Cargo.toml

@@ -14,8 +14,9 @@ default-target = "wasm32-unknown-unknown"
 rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
-default = ["e2e-encryption", "state-store"]
+default = ["e2e-encryption", "state-store", "event-cache-store"]
 state-store = ["dep:matrix-sdk-base", "growable-bloom-filter"]
+event-cache-store = ["dep:matrix-sdk-base", "dep:matrix-sdk-crypto"]
 e2e-encryption = ["dep:matrix-sdk-crypto"]
 testing = ["matrix-sdk-crypto?/testing"]
 

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

@@ -0,0 +1,69 @@
+use matrix_sdk_base::{event_cache::store::EventCacheStoreError, StoreError};
+use matrix_sdk_crypto::store::CryptoStoreError;
+use matrix_sdk_store_encryption::Error as EncryptionError;
+
+#[derive(Debug, thiserror::Error)]
+pub enum IndexeddbEventCacheStoreError {
+    #[error(transparent)]
+    Json(#[from] serde_json::Error),
+    #[error(transparent)]
+    Encryption(#[from] EncryptionError),
+    #[error("DomException {name} ({code}): {message}")]
+    DomException { name: String, message: String, code: u16 },
+    #[error(transparent)]
+    StoreError(#[from] StoreError),
+    #[error("Can't migrate {name} from {old_version} to {new_version} without deleting data. See MigrationConflictStrategy for ways to configure.")]
+    MigrationConflict { name: String, old_version: u32, new_version: u32 },
+    #[error(transparent)]
+    CryptoStoreError(#[from] CryptoStoreError),
+}
+
+impl From<web_sys::DomException> for IndexeddbEventCacheStoreError {
+    fn from(frm: web_sys::DomException) -> IndexeddbEventCacheStoreError {
+        IndexeddbEventCacheStoreError::DomException {
+            name: frm.name(),
+            message: frm.message(),
+            code: frm.code(),
+        }
+    }
+}
+
+impl From<IndexeddbEventCacheStoreError> for StoreError {
+    fn from(e: IndexeddbEventCacheStoreError) -> Self {
+        match e {
+            IndexeddbEventCacheStoreError::Json(e) => StoreError::Json(e),
+            IndexeddbEventCacheStoreError::StoreError(e) => e,
+            IndexeddbEventCacheStoreError::Encryption(e) => StoreError::Encryption(e),
+            _ => StoreError::backend(e),
+        }
+    }
+}
+
+impl From<IndexeddbEventCacheStoreError> for EventCacheStoreError {
+    fn from(e: IndexeddbEventCacheStoreError) -> Self {
+        match e {
+            IndexeddbEventCacheStoreError::Json(e) => EventCacheStoreError::Serialization(e),
+            IndexeddbEventCacheStoreError::StoreError(e) => {
+                EventCacheStoreError::Backend(Box::new(e))
+            }
+            IndexeddbEventCacheStoreError::Encryption(e) => EventCacheStoreError::Encryption(e),
+            _ => EventCacheStoreError::backend(e),
+        }
+    }
+}
+
+impl From<IndexeddbEventCacheStoreError> for CryptoStoreError {
+    fn from(frm: IndexeddbEventCacheStoreError) -> CryptoStoreError {
+        match frm {
+            IndexeddbEventCacheStoreError::Json(e) => CryptoStoreError::Serialization(e),
+            IndexeddbEventCacheStoreError::CryptoStoreError(e) => e,
+            _ => CryptoStoreError::backend(frm),
+        }
+    }
+}
+
+impl From<serde_wasm_bindgen::Error> for IndexeddbEventCacheStoreError {
+    fn from(e: serde_wasm_bindgen::Error) -> Self {
+        IndexeddbEventCacheStoreError::Json(serde::de::Error::custom(e.to_string()))
+    }
+}

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

@@ -0,0 +1,26 @@
+use gloo_utils::format::JsValueSerdeExt;
+use indexed_db_futures::idb_object_store::IdbObjectStore;
+use serde::{Deserialize, Serialize};
+use wasm_bindgen::JsValue;
+
+#[derive(Serialize, Deserialize)]
+struct Chunk {
+    id: String,
+    previous: Option<u64>,
+    new: u64,
+    next: Option<u64>,
+}
+
+pub async fn insert_chunk(
+    store: IdbObjectStore<'_>,
+    hashed_room_id: &String,
+    previous: Option<u64>,
+    new: u64,
+    next: Option<u64>,
+) -> Result<(), web_sys::DomException> {
+    let id = format!("{}-{}", hashed_room_id, new);
+    let chunk = Chunk { id, previous, new, next };
+    let value = JsValue::from_serde(&chunk).unwrap();
+    store.add_val(&value)?;
+    Ok(())
+}