refactor(indexeddb): add migrations and types for media content size index

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

Author: mgoldenberg

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

@@ -133,6 +133,8 @@ pub mod v1 {
         pub const MEDIA_RETENTION_POLICY_KEY: &str = "media_retention_policy";
         pub const MEDIA: &str = "media";
         pub const MEDIA_KEY_PATH: &str = "id";
+        pub const MEDIA_CONTENT_SIZE: &str = "media_content_size";
+        pub const MEDIA_CONTENT_SIZE_KEY_PATH: &str = "content_size";
     }
 
     /// Create all object stores and indices for v1 database
@@ -225,10 +227,15 @@ pub mod v1 {
     /// Create an object store for tracking information about media.
     ///
     /// * Primary Key - `id`
+    /// * Index - `content_size` - tracks the size of the media content and
+    ///   whether to ignore the [`MediaRetentionPolicy`][1]
+    ///
+    /// [1]: matrix_sdk_base::event_cache::store::media::MediaRetentionPolicy
     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)?;
+        let media = db.create_object_store_with_params(keys::MEDIA, &object_store_params)?;
+        media.create_index(keys::MEDIA_CONTENT_SIZE, &keys::MEDIA_CONTENT_SIZE_KEY_PATH.into())?;
         Ok(())
     }
 }

crates/matrix-sdk-indexeddb/src/event_cache_store/serializer/types.rs

@@ -42,9 +42,12 @@ use thiserror::Error;
 use crate::{
     event_cache_store::{
         migrations::current::keys,
-        serializer::traits::{
-            Indexed, IndexedKey, IndexedKeyBounds, IndexedKeyComponentBounds,
-            IndexedPrefixKeyBounds, IndexedPrefixKeyComponentBounds,
+        serializer::{
+            foreign::ignore_media_retention_policy,
+            traits::{
+                Indexed, IndexedKey, IndexedKeyBounds, IndexedKeyComponentBounds,
+                IndexedPrefixKeyBounds, IndexedPrefixKeyComponentBounds,
+            },
         },
         types::{Chunk, Event, Gap, Lease, Media, Position},
     },
@@ -290,6 +293,10 @@ pub type IndexedMediaMetadata = MaybeEncrypted;
 /// A (possibly) encrypted representation of [`Media::content`]
 pub type IndexedMediaContent = Vec<u8>;
 
+/// A representation of the size in bytes of the [`IndexedMediaContent`] which
+/// is suitable for use in an IndexedDB key
+pub type IndexedMediaContentSize = usize;
+
 /// Represents the [`LEASES`][1] object store.
 ///
 /// [1]: crate::event_cache_store::migrations::v1::create_lease_object_store
@@ -900,6 +907,9 @@ impl IndexedKey<MediaRetentionPolicy> for IndexedCoreIdKey {
 pub struct IndexedMedia {
     /// The primary key of the object store
     pub id: IndexedMediaIdKey,
+    /// The size (in bytes) of the media content and whether to ignore the
+    /// [`MediaRetentionPolicy`]
+    pub content_size: IndexedMediaContentSizeKey,
     /// The (possibly) encrypted metadata - i.e., [`MediaMetadata`][1]
     ///
     /// [1]: crate::event_cache_store::types::MediaMetadata
@@ -934,6 +944,10 @@ impl Indexed for Media {
                 &self.metadata.request_parameters,
                 serializer,
             ),
+            content_size: IndexedMediaContentSizeKey::encode(
+                (self.metadata.ignore_policy, content.len()),
+                serializer,
+            ),
             metadata: serializer.maybe_encrypt_value(&self.metadata)?,
             content,
         })
@@ -966,3 +980,66 @@ impl IndexedKey<Media> for IndexedMediaIdKey {
         Self(serializer.encode_key_as_string(keys::MEDIA, components.unique_key()))
     }
 }
+
+/// The value associated with the [`content_size`](IndexedMedia::content_size)
+/// index of the [`MEDIA`][1] object store, which is constructed from:
+///
+/// - The value of [`IgnoreMediaRetentionPolicy`]
+/// - The size in bytes of the associated [`IndexedMedia::content`]
+///
+/// [1]: crate::event_cache_store::migrations::v1::create_media_object_store
+#[derive(Debug, Serialize, Deserialize)]
+pub struct IndexedMediaContentSizeKey(
+    #[serde(with = "ignore_media_retention_policy")] IgnoreMediaRetentionPolicy,
+    IndexedMediaContentSize,
+);
+
+impl IndexedMediaContentSizeKey {
+    /// Returns whether the associated [`IndexedMedia`] record should ignore the
+    /// global [`MediaRetentionPolicy`]
+    pub fn ignore_policy(&self) -> bool {
+        self.0.is_yes()
+    }
+
+    /// Returns the size in bytes of the associated [`IndexedMedia::content`]
+    pub fn content_size(&self) -> usize {
+        self.1
+    }
+}
+
+impl IndexedKey<Media> for IndexedMediaContentSizeKey {
+    type KeyComponents<'a> = (IgnoreMediaRetentionPolicy, IndexedMediaContentSize);
+
+    fn encode(
+        (ignore_policy, content_size): Self::KeyComponents<'_>,
+        _: &IndexeddbSerializer,
+    ) -> Self {
+        Self(ignore_policy, content_size)
+    }
+}
+
+impl IndexedKeyComponentBounds<Media> for IndexedMediaContentSizeKey {
+    fn lower_key_components() -> Self::KeyComponents<'static> {
+        Self::lower_key_components_with_prefix(IgnoreMediaRetentionPolicy::No)
+    }
+
+    fn upper_key_components() -> Self::KeyComponents<'static> {
+        Self::lower_key_components_with_prefix(IgnoreMediaRetentionPolicy::Yes)
+    }
+}
+
+impl<'a> IndexedPrefixKeyComponentBounds<'a, Media, IgnoreMediaRetentionPolicy>
+    for IndexedMediaContentSizeKey
+{
+    fn lower_key_components_with_prefix(
+        prefix: IgnoreMediaRetentionPolicy,
+    ) -> Self::KeyComponents<'a> {
+        (prefix, IndexedMediaContentSize::MIN)
+    }
+
+    fn upper_key_components_with_prefix(
+        prefix: IgnoreMediaRetentionPolicy,
+    ) -> Self::KeyComponents<'a> {
+        (prefix, IndexedMediaContentSize::MAX)
+    }
+}