refactor(indexeddb): add migrations and types for media last access index

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

Author: mgoldenberg

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

@@ -137,6 +137,8 @@ pub mod v1 {
         pub const MEDIA_SOURCE_KEY_PATH: &str = "source";
         pub const MEDIA_CONTENT_SIZE: &str = "media_content_size";
         pub const MEDIA_CONTENT_SIZE_KEY_PATH: &str = "content_size";
+        pub const MEDIA_LAST_ACCESS: &str = "media_last_access";
+        pub const MEDIA_LAST_ACCESS_KEY_PATH: &str = "last_access";
     }
 
     /// Create all object stores and indices for v1 database
@@ -233,6 +235,8 @@ pub mod v1 {
     ///   media
     /// * Index - `content_size` - tracks the size of the media content and
     ///   whether to ignore the [`MediaRetentionPolicy`][2]
+    /// * Index - `last_access` - tracks the last time the associated media was
+    ///   accessed
     ///
     /// [1]: ruma::events::room::MediaSource
     /// [2]: matrix_sdk_base::event_cache::store::media::MediaRetentionPolicy
@@ -242,6 +246,7 @@ pub mod v1 {
         let media = db.create_object_store_with_params(keys::MEDIA, &object_store_params)?;
         media.create_index(keys::MEDIA_SOURCE, &keys::MEDIA_SOURCE_KEY_PATH.into())?;
         media.create_index(keys::MEDIA_CONTENT_SIZE, &keys::MEDIA_CONTENT_SIZE_KEY_PATH.into())?;
+        media.create_index(keys::MEDIA_LAST_ACCESS, &keys::MEDIA_LAST_ACCESS_KEY_PATH.into())?;
         Ok(())
     }
 }

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

@@ -27,7 +27,7 @@
 //! These types mimic the structure of the object stores and indices created in
 //! [`crate::event_cache_store::migrations`].
 
-use std::sync::LazyLock;
+use std::{sync::LazyLock, time::Duration};
 
 use matrix_sdk_base::{
     event_cache::store::media::{IgnoreMediaRetentionPolicy, MediaRetentionPolicy},
@@ -154,6 +154,22 @@ static INDEXED_KEY_UPPER_EVENT_POSITION: LazyLock<Position> = LazyLock::new(|| P
     index: INDEXED_KEY_UPPER_EVENT_INDEX,
 });
 
+/// The minimum possible [`Duration`].
+///
+/// This value is useful for constructing a key range over all keys which
+/// contain time-related values when used in conjunction with
+/// [`INDEXED_KEY_UPPER_DURATION`].
+const INDEXED_KEY_LOWER_DURATION: Duration = Duration::ZERO;
+
+/// A [`Duration`] constructed with [`js_sys::Number::MAX_SAFE_INTEGER`]
+/// seconds.
+///
+/// This value is useful for constructing a key range over all keys which
+/// contain time-related values in seconds when used in conjunction with
+/// [`INDEXED_KEY_LOWER_DURATION`].
+const INDEXED_KEY_UPPER_DURATION_SECONDS: Duration =
+    Duration::from_secs(js_sys::Number::MAX_SAFE_INTEGER as u64);
+
 /// Representation of a range of keys of type `K`. This is loosely
 /// correlated with [IDBKeyRange][1], with a few differences.
 ///
@@ -300,6 +316,10 @@ pub type IndexedMediaContent = Vec<u8>;
 /// is suitable for use in an IndexedDB key
 pub type IndexedMediaContentSize = usize;
 
+/// A representation of time in seconds since the [Unix
+/// Epoch](std::time::UNIX_EPOCH) which is suitable for use in an IndexedDB key
+pub type IndexedSecondsSinceUnixEpoch = u64;
+
 /// Represents the [`LEASES`][1] object store.
 ///
 /// [1]: crate::event_cache_store::migrations::v1::create_lease_object_store
@@ -919,6 +939,7 @@ pub struct IndexedMedia {
     /// The (possibly) encrypted metadata - i.e., [`MediaMetadata`][1]
     ///
     /// [1]: crate::event_cache_store::types::MediaMetadata
+    pub last_access: IndexedMediaLastAccessKey,
     pub metadata: IndexedMediaMetadata,
     /// The (possibly) encrypted content - i.e., [`Media::content`]
     pub content: IndexedMediaContent,
@@ -958,6 +979,10 @@ impl Indexed for Media {
                 (self.metadata.ignore_policy, content.len()),
                 serializer,
             ),
+            last_access: IndexedMediaLastAccessKey::encode(
+                (self.metadata.ignore_policy, self.metadata.last_access),
+                serializer,
+            ),
             metadata: serializer.maybe_encrypt_value(&self.metadata)?,
             content,
         })
@@ -1070,3 +1095,54 @@ impl<'a> IndexedPrefixKeyComponentBounds<'a, Media, IgnoreMediaRetentionPolicy>
         (prefix, IndexedMediaContentSize::MAX)
     }
 }
+
+/// The value associated with the [`last_access`](IndexedMedia::last_access)
+/// index of the [`MEDIA`][1] object store, which is constructed from:
+///
+/// - The value of [`IgnoreMediaRetentionPolicy`]
+/// - The last time the associated [`IndexedMedia`] was accessed (in seconds
+///   since the Unix Epoch)
+///
+/// [1]: crate::event_cache_store::migrations::v1::create_media_object_store
+#[derive(Debug, Serialize, Deserialize)]
+pub struct IndexedMediaLastAccessKey(
+    #[serde(with = "ignore_media_retention_policy")] IgnoreMediaRetentionPolicy,
+    IndexedSecondsSinceUnixEpoch,
+);
+
+impl IndexedKey<Media> for IndexedMediaLastAccessKey {
+    type KeyComponents<'a> = (IgnoreMediaRetentionPolicy, Duration);
+
+    fn encode(
+        (ignore_policy, last_access): Self::KeyComponents<'_>,
+        _: &IndexeddbSerializer,
+    ) -> Self {
+        Self(ignore_policy, last_access.as_secs())
+    }
+}
+
+impl IndexedKeyComponentBounds<Media> for IndexedMediaLastAccessKey {
+    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 IndexedMediaLastAccessKey
+{
+    fn lower_key_components_with_prefix(
+        prefix: IgnoreMediaRetentionPolicy,
+    ) -> Self::KeyComponents<'a> {
+        (prefix, INDEXED_KEY_LOWER_DURATION)
+    }
+
+    fn upper_key_components_with_prefix(
+        prefix: IgnoreMediaRetentionPolicy,
+    ) -> Self::KeyComponents<'a> {
+        (prefix, INDEXED_KEY_UPPER_DURATION_SECONDS)
+    }
+}