feat(event cache store): add an IndexedDB implementation

Cargo.toml

@@ -96,6 +96,7 @@ url = "2.5.4"
 uuid = "1.12.1"
 vodozemac = { version = "0.9.0", features = ["insecure-pk-encryption"] }
 wasm-bindgen = "0.2.84"
+wasm-bindgen-futures = "0.4.24"
 wasm-bindgen-test = "0.3.33"
 web-sys = "0.3.69"
 wiremock = "0.6.2"

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"]
 
@@ -32,13 +33,16 @@ matrix-sdk-crypto = { workspace = true, features = ["js"], optional = true }
 matrix-sdk-store-encryption = { workspace = true }
 ruma = { workspace = true }
 serde = { workspace = true }
+rmp-serde = { workspace = true }
 serde_json = { workspace = true }
 serde-wasm-bindgen = "0.6.5"
 thiserror = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 wasm-bindgen = { workspace = true }
-web-sys = { workspace = true, features = ["IdbKeyRange"] }
+wasm-bindgen-futures = { workspace = true }
+gloo-timers = { version = "0.3", features = ["futures"] }
+web-sys = { workspace = true, features = ["IdbKeyRange", "Blob", "BlobPropertyBag"] }
 hkdf = { workspace = true }
 zeroize = { workspace = true }
 sha2 = { workspace = true }

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

@@ -0,0 +1,72 @@
+use super::{
+    migrations::MigrationConflictStrategy, operations::get_media_retention_policy,
+    IndexeddbEventCacheStore, Result,
+};
+use crate::event_cache_store::{
+    indexeddb_serializer::IndexeddbSerializer, migrations::open_and_upgrade_db,
+};
+use matrix_sdk_base::event_cache::store::media::{MediaRetentionPolicy, MediaService};
+use matrix_sdk_store_encryption::StoreCipher;
+use std::sync::Arc;
+
+/// Builder for [`IndexeddbEventCacheStore`]
+// #[derive(Debug)] // TODO StoreCipher cannot be derived
+pub struct IndexeddbEventCacheStoreBuilder {
+    name: Option<String>,
+    store_cipher: Option<Arc<StoreCipher>>,
+    migration_conflict_strategy: MigrationConflictStrategy,
+}
+
+impl IndexeddbEventCacheStoreBuilder {
+    pub fn new() -> Self {
+        Self {
+            name: None,
+            store_cipher: None,
+            migration_conflict_strategy: MigrationConflictStrategy::BackupAndDrop,
+        }
+    }
+
+    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
+    }
+
+    /// The strategy to use when a merge conflict is found.
+    ///
+    /// See [`MigrationConflictStrategy`] for details.
+    pub fn migration_conflict_strategy(mut self, value: MigrationConflictStrategy) -> Self {
+        self.migration_conflict_strategy = value;
+        self
+    }
+
+    pub async fn build(self) -> Result<IndexeddbEventCacheStore> {
+        // let migration_strategy = self.migration_conflict_strategy.clone();
+        let name = self.name.unwrap_or_else(|| "event_cache".to_owned());
+
+        let serializer = IndexeddbSerializer::new(self.store_cipher.clone());
+        let inner = open_and_upgrade_db(&name, &serializer).await?;
+
+        let media_service = MediaService::new();
+        let policy: Option<MediaRetentionPolicy> = get_media_retention_policy(&inner).await?;
+        media_service.restore(policy);
+
+        let store = IndexeddbEventCacheStore {
+            inner,
+            store_cipher: self.store_cipher,
+            serializer,
+            media_service: Arc::new(media_service),
+        };
+        Ok(store)
+    }
+}
+
+impl Default for IndexeddbEventCacheStoreBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}

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

@@ -0,0 +1,83 @@
+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),
+    #[error("Uknown Chunk Type {0}")]
+    UnknownChunkType(String),
+}
+
+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()))
+    }
+}
+
+impl From<rmp_serde::encode::Error> for IndexeddbEventCacheStoreError {
+    fn from(e: rmp_serde::encode::Error) -> Self {
+        IndexeddbEventCacheStoreError::Json(serde::ser::Error::custom(e.to_string()))
+    }
+}
+
+impl From<rmp_serde::decode::Error> for IndexeddbEventCacheStoreError {
+    fn from(e: rmp_serde::decode::Error) -> Self {
+        IndexeddbEventCacheStoreError::Json(serde::de::Error::custom(e.to_string()))
+    }
+}