refactor(indexeddb): add types and migrations for storing media via event cache

Signed-off-by: Michael Goldenberg <[email protected]>

Author: mgoldenberg

Cargo.lock

@@ -32,6 +32,7 @@ js-sys.workspace = true
 matrix-sdk-base = { workspace = true, features = ["js"], optional = true }
 matrix-sdk-crypto = { workspace = true, features = ["js"], optional = true }
 matrix-sdk-store-encryption.workspace = true
+rmp-serde.workspace = true
 ruma.workspace = true
 serde.workspace = true
 serde-wasm-bindgen = "0.6.5"

crates/matrix-sdk-indexeddb/Cargo.toml

@@ -131,6 +131,8 @@ pub mod v1 {
         pub const GAPS: &str = "gaps";
         pub const GAPS_KEY_PATH: &str = "id";
         pub const MEDIA_RETENTION_POLICY_KEY: &str = "media_retention_policy";
+        pub const MEDIA: &str = "media";
+        pub const MEDIA_KEY_PATH: &str = "id";
     }
 
     /// Create all object stores and indices for v1 database
@@ -140,6 +142,7 @@ pub mod v1 {
         create_linked_chunks_object_store(db)?;
         create_events_object_store(db)?;
         create_gaps_object_store(db)?;
+        create_media_object_store(db)?;
         Ok(())
     }
 
@@ -218,4 +221,14 @@ pub mod v1 {
         let _ = db.create_object_store_with_params(keys::GAPS, &object_store_params)?;
         Ok(())
     }
+
+    /// Create an object store for tracking information about media.
+    ///
+    /// * Primary Key - `id`
+    fn create_media_object_store(db: &IdbDatabase) -> Result<(), DomException> {
+        let mut object_store_params = IdbObjectStoreParameters::new();
+        object_store_params.key_path(Some(&keys::MEDIA_KEY_PATH.into()));
+        let _ = db.create_object_store_with_params(keys::MEDIA, &object_store_params)?;
+        Ok(())
+    }
 }

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

@@ -30,8 +30,9 @@
 use std::sync::LazyLock;
 
 use matrix_sdk_base::{
-    event_cache::store::media::MediaRetentionPolicy,
+    event_cache::store::media::{IgnoreMediaRetentionPolicy, MediaRetentionPolicy},
     linked_chunk::{ChunkIdentifier, LinkedChunkId},
+    media::{MediaRequestParameters, UniqueKey},
 };
 use matrix_sdk_crypto::CryptoStoreError;
 use ruma::{events::relation::RelationType, EventId, OwnedEventId, RoomId};
@@ -45,7 +46,7 @@ use crate::{
             Indexed, IndexedKey, IndexedKeyBounds, IndexedKeyComponentBounds,
             IndexedPrefixKeyBounds, IndexedPrefixKeyComponentBounds,
         },
-        types::{Chunk, Event, Gap, Lease, Position},
+        types::{Chunk, Event, Gap, Lease, Media, Position},
     },
     serializer::{IndexeddbSerializer, MaybeEncrypted},
 };
@@ -281,6 +282,14 @@ pub type IndexedGapContent = MaybeEncrypted;
 /// A (possibly) encrypted representation of a [`MediaRetentionPolicy`]
 pub type IndexedMediaRetentionPolicyContent = MaybeEncrypted;
 
+/// A (possibly) encrypted representation of a [`MediaMetadata`][1]
+///
+/// [1]: crate::event_cache_store::types::MediaMetadata
+pub type IndexedMediaMetadata = MaybeEncrypted;
+
+/// A (possibly) encrypted representation of [`Media::content`]
+pub type IndexedMediaContent = Vec<u8>;
+
 /// Represents the [`LEASES`][1] object store.
 ///
 /// [1]: crate::event_cache_store::migrations::v1::create_lease_object_store
@@ -883,3 +892,77 @@ impl IndexedKey<MediaRetentionPolicy> for IndexedCoreIdKey {
         serializer.encode_key_as_string(keys::CORE, keys::MEDIA_RETENTION_POLICY_KEY)
     }
 }
+
+/// Represents the [`MEDIA`][1] object store.
+///
+/// [1]: crate::event_cache_store::migrations::v1::create_media_object_store
+#[derive(Debug, Serialize, Deserialize)]
+pub struct IndexedMedia {
+    /// The primary key of the object store
+    pub id: IndexedMediaIdKey,
+    /// The (possibly) encrypted metadata - i.e., [`MediaMetadata`][1]
+    ///
+    /// [1]: crate::event_cache_store::types::MediaMetadata
+    pub metadata: IndexedMediaMetadata,
+    /// The (possibly) encrypted content - i.e., [`Media::content`]
+    pub content: IndexedMediaContent,
+}
+
+#[derive(Debug, Error)]
+pub enum IndexedMediaError {
+    #[error("crypto store: {0}")]
+    CryptoStore(#[from] CryptoStoreError),
+    #[error("serialization: {0}")]
+    Serialization(#[from] rmp_serde::encode::Error),
+    #[error("deserialization: {0}")]
+    Deserialization(#[from] rmp_serde::decode::Error),
+}
+
+impl Indexed for Media {
+    const OBJECT_STORE: &'static str = keys::MEDIA;
+
+    type IndexedType = IndexedMedia;
+    type Error = IndexedMediaError;
+
+    fn to_indexed(
+        &self,
+        serializer: &IndexeddbSerializer,
+    ) -> Result<Self::IndexedType, Self::Error> {
+        let content = rmp_serde::to_vec_named(&serializer.maybe_encrypt_value(&self.content)?)?;
+        Ok(Self::IndexedType {
+            id: <IndexedMediaIdKey as IndexedKey<Self>>::encode(
+                &self.metadata.request_parameters,
+                serializer,
+            ),
+            metadata: serializer.maybe_encrypt_value(&self.metadata)?,
+            content,
+        })
+    }
+
+    fn from_indexed(
+        indexed: Self::IndexedType,
+        serializer: &IndexeddbSerializer,
+    ) -> Result<Self, Self::Error> {
+        Ok(Self {
+            metadata: serializer.maybe_decrypt_value(indexed.metadata)?,
+            content: serializer.maybe_decrypt_value(rmp_serde::from_slice(&indexed.content)?)?,
+        })
+    }
+}
+
+/// The primary key of the [`MEDIA`][1] object store, which is constructed from:
+///
+/// - The (possibly) hashed value returned by
+///   [`MediaRequestParameters::unique_key`]
+///
+/// [1]: crate::event_cache_store::migrations::v1::create_media_object_store
+#[derive(Debug, Serialize, Deserialize)]
+pub struct IndexedMediaIdKey(String);
+
+impl IndexedKey<Media> for IndexedMediaIdKey {
+    type KeyComponents<'a> = &'a MediaRequestParameters;
+
+    fn encode(components: Self::KeyComponents<'_>, serializer: &IndexeddbSerializer) -> Self {
+        Self(serializer.encode_key_as_string(keys::MEDIA, components.unique_key()))
+    }
+}