refactor(indexeddb): add indexing trait impls for event

Signed-off-by: Michael Goldenberg <m@mgoldenberg.net>

Author: mgoldenberg

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

@@ -120,6 +120,8 @@ pub mod v1 {
         pub const EVENTS_POSITION_KEY_PATH: &str = "position";
         pub const EVENTS_RELATION: &str = "events_relation";
         pub const EVENTS_RELATION_KEY_PATH: &str = "relation";
+        pub const EVENTS_RELATION_RELATED_EVENTS: &str = "events_relation_related_event";
+        pub const EVENTS_RELATION_RELATION_TYPES: &str = "events_relation_relation_type";
         pub const GAPS: &str = "gaps";
         pub const GAPS_KEY_PATH: &str = "id";
     }

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

@@ -29,18 +29,37 @@
 
 use matrix_sdk_base::linked_chunk::ChunkIdentifier;
 use matrix_sdk_crypto::CryptoStoreError;
-use ruma::RoomId;
+use ruma::{events::relation::RelationType, EventId, OwnedEventId, RoomId};
 use serde::{Deserialize, Serialize};
+use thiserror::Error;
 
 use crate::{
     event_cache_store::{
         migrations::current::keys,
         serializer::traits::{Indexed, IndexedKey, IndexedKeyBounds},
-        types::Chunk,
+        types::{Chunk, Event, Position},
     },
     serializer::{IndexeddbSerializer, MaybeEncrypted},
 };
 
+/// The first unicode character, and hence the lower bound for IndexedDB keys
+/// (or key components) which are represented as strings.
+///
+/// This value is useful for constructing a key range over all strings when used
+/// in conjunction with [`INDEXED_KEY_UPPER_CHARACTER`].
+const INDEXED_KEY_LOWER_CHARACTER: char = '\u{0000}';
+
+/// The last unicode character in the [Basic Multilingual Plane][1]. This seems
+/// like a reasonable place to set the upper bound for IndexedDB keys (or key
+/// components) which are represented as strings, though one could
+/// theoretically set it to `\u{10FFFF}`.
+///
+/// This value is useful for constructing a key range over all strings when used
+/// in conjunction with [`INDEXED_KEY_LOWER_CHARACTER`].
+///
+/// [1]: https://en.wikipedia.org/wiki/Plane_(Unicode)#Basic_Multilingual_Plane
+const INDEXED_KEY_UPPER_CHARACTER: char = '\u{FFFF}';
+
 /// Represents the [`LINKED_CHUNKS`][1] object store.
 ///
 /// [1]: crate::event_cache_store::migrations::v1::create_linked_chunks_object_store
@@ -206,6 +225,46 @@ pub struct IndexedEvent {
     pub content: IndexedEventContent,
 }
 
+#[derive(Debug, Error)]
+pub enum IndexedEventError {
+    #[error("no event id")]
+    NoEventId,
+    #[error("crypto store: {0}")]
+    CryptoStore(#[from] CryptoStoreError),
+}
+
+impl Indexed for Event {
+    type IndexedType = IndexedEvent;
+    type Error = IndexedEventError;
+
+    fn to_indexed(
+        &self,
+        room_id: &RoomId,
+        serializer: &IndexeddbSerializer,
+    ) -> Result<Self::IndexedType, Self::Error> {
+        let event_id = self.event_id().ok_or(Self::Error::NoEventId)?;
+        let id = IndexedEventIdKey::encode(room_id, &event_id, serializer);
+        let position = self
+            .position()
+            .map(|position| IndexedEventPositionKey::encode(room_id, &position, serializer));
+        let relation = self.relation().map(|(related_event, relation_type)| {
+            IndexedEventRelationKey::encode(
+                room_id,
+                &(related_event, RelationType::from(relation_type)),
+                serializer,
+            )
+        });
+        Ok(IndexedEvent { id, position, relation, content: serializer.maybe_encrypt_value(self)? })
+    }
+
+    fn from_indexed(
+        indexed: Self::IndexedType,
+        serializer: &IndexeddbSerializer,
+    ) -> Result<Self, Self::Error> {
+        serializer.maybe_decrypt_value(indexed.content).map_err(Into::into)
+    }
+}
+
 /// The value associated with the [primary key](IndexedEvent::id) of the
 /// [`EVENTS`][1] object store, which is constructed from:
 ///
@@ -216,6 +275,30 @@ pub struct IndexedEvent {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct IndexedEventIdKey(IndexedRoomId, IndexedEventId);
 
+impl IndexedKey<Event> for IndexedEventIdKey {
+    type KeyComponents = OwnedEventId;
+
+    fn encode(room_id: &RoomId, event_id: &OwnedEventId, serializer: &IndexeddbSerializer) -> Self {
+        let room_id = serializer.encode_key_as_string(keys::ROOMS, room_id);
+        let event_id = serializer.encode_key_as_string(keys::EVENTS, event_id);
+        Self(room_id, event_id)
+    }
+}
+
+impl IndexedKeyBounds<Event> for IndexedEventIdKey {
+    fn encode_lower(room_id: &RoomId, serializer: &IndexeddbSerializer) -> Self {
+        let room_id = serializer.encode_key_as_string(keys::ROOMS, room_id);
+        let event_id = String::from(INDEXED_KEY_LOWER_CHARACTER);
+        Self(room_id, event_id)
+    }
+
+    fn encode_upper(room_id: &RoomId, serializer: &IndexeddbSerializer) -> Self {
+        let room_id = serializer.encode_key_as_string(keys::ROOMS, room_id);
+        let event_id = String::from(INDEXED_KEY_UPPER_CHARACTER);
+        Self(room_id, event_id)
+    }
+}
+
 pub type IndexedEventId = String;
 
 /// The value associated with the [`position`](IndexedEvent::position) index of
@@ -229,6 +312,36 @@ pub type IndexedEventId = String;
 #[derive(Debug, Serialize, Deserialize)]
 pub struct IndexedEventPositionKey(IndexedRoomId, IndexedChunkId, IndexedEventPositionIndex);
 
+impl IndexedKey<Event> for IndexedEventPositionKey {
+    type KeyComponents = Position;
+
+    fn encode(room_id: &RoomId, position: &Position, serializer: &IndexeddbSerializer) -> Self {
+        let room_id = serializer.encode_key_as_string(keys::ROOMS, room_id);
+        Self(room_id, position.chunk_identifier, position.index)
+    }
+}
+
+impl IndexedKeyBounds<Event> for IndexedEventPositionKey {
+    fn encode_lower(room_id: &RoomId, serializer: &IndexeddbSerializer) -> Self {
+        <Self as IndexedKey<Event>>::encode(
+            room_id,
+            &Position { chunk_identifier: 0, index: 0 },
+            serializer,
+        )
+    }
+
+    fn encode_upper(room_id: &RoomId, serializer: &IndexeddbSerializer) -> Self {
+        <Self as IndexedKey<Event>>::encode(
+            room_id,
+            &Position {
+                chunk_identifier: js_sys::Number::MAX_SAFE_INTEGER as u64,
+                index: js_sys::Number::MAX_SAFE_INTEGER as usize,
+            },
+            serializer,
+        )
+    }
+}
+
 pub type IndexedEventPositionIndex = usize;
 
 /// The value associated with the [`relation`](IndexedEvent::relation) index of
@@ -242,6 +355,39 @@ pub type IndexedEventPositionIndex = usize;
 #[derive(Debug, Serialize, Deserialize)]
 pub struct IndexedEventRelationKey(IndexedRoomId, IndexedEventId, IndexedRelationType);
 
+impl IndexedKey<Event> for IndexedEventRelationKey {
+    type KeyComponents = (OwnedEventId, RelationType);
+
+    fn encode(
+        room_id: &RoomId,
+        (related_event_id, relation_type): &(OwnedEventId, RelationType),
+        serializer: &IndexeddbSerializer,
+    ) -> Self {
+        let room_id = serializer.encode_key_as_string(keys::ROOMS, room_id);
+        let related_event_id =
+            serializer.encode_key_as_string(keys::EVENTS_RELATION_RELATED_EVENTS, related_event_id);
+        let relation_type = serializer
+            .encode_key_as_string(keys::EVENTS_RELATION_RELATION_TYPES, relation_type.to_string());
+        Self(room_id, related_event_id, relation_type)
+    }
+}
+
+impl IndexedKeyBounds<Event> for IndexedEventRelationKey {
+    fn encode_lower(room_id: &RoomId, serializer: &IndexeddbSerializer) -> Self {
+        let room_id = serializer.encode_key_as_string(keys::ROOMS, room_id);
+        let related_event_id = String::from(INDEXED_KEY_LOWER_CHARACTER);
+        let relation_type = String::from(INDEXED_KEY_LOWER_CHARACTER);
+        Self(room_id, related_event_id, relation_type)
+    }
+
+    fn encode_upper(room_id: &RoomId, serializer: &IndexeddbSerializer) -> Self {
+        let room_id = serializer.encode_key_as_string(keys::ROOMS, room_id);
+        let related_event_id = String::from(INDEXED_KEY_UPPER_CHARACTER);
+        let relation_type = String::from(INDEXED_KEY_UPPER_CHARACTER);
+        Self(room_id, related_event_id, relation_type)
+    }
+}
+
 /// A representation of the relationship between two events (see
 /// [`RelationType`](ruma::events::relation::RelationType))
 pub type IndexedRelationType = String;

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

@@ -1,4 +1,8 @@
-use matrix_sdk_base::{deserialized_responses::TimelineEvent, linked_chunk::ChunkIdentifier};
+use matrix_sdk_base::{
+    deserialized_responses::TimelineEvent, event_cache::store::extract_event_relation,
+    linked_chunk::ChunkIdentifier,
+};
+use ruma::OwnedEventId;
 use serde::{Deserialize, Serialize};
 
 /// Representation of a [`Chunk`](matrix_sdk_base::linked_chunk::Chunk)
@@ -50,6 +54,34 @@ impl From<Event> for TimelineEvent {
     }
 }
 
+impl Event {
+    /// The [`OwnedEventId`] of the underlying event.
+    pub fn event_id(&self) -> Option<OwnedEventId> {
+        match self {
+            Event::InBand(e) => e.event_id(),
+            Event::OutOfBand(e) => e.event_id(),
+        }
+    }
+
+    /// The [`Position`] of the underlying event, if it is in a chunk.
+    pub fn position(&self) -> Option<Position> {
+        match self {
+            Event::InBand(e) => Some(e.position),
+            Event::OutOfBand(_) => None,
+        }
+    }
+
+    /// The [`OwnedEventId`] and
+    /// [`RelationType`](ruma::events::relation::RelationType) of the underlying
+    /// event as a [`String`].
+    pub fn relation(&self) -> Option<(OwnedEventId, String)> {
+        match self {
+            Event::InBand(e) => e.relation(),
+            Event::OutOfBand(e) => e.relation(),
+        }
+    }
+}
+
 /// A generic representation of an
 /// [`Event`](matrix_sdk_base::event_cache::Event) which can be stored in
 /// IndexedDB.
@@ -64,6 +96,21 @@ pub struct GenericEvent<P> {
     pub position: P,
 }
 
+impl<P> GenericEvent<P> {
+    /// The [`OwnedEventId`] of the underlying event.
+    pub fn event_id(&self) -> Option<OwnedEventId> {
+        self.content.event_id()
+    }
+
+    /// The event that the underlying event relates to, if any.
+    ///
+    /// Returns the related [`OwnedEventId`] and the
+    /// [`RelationType`](ruma::events::relation::RelationType) as a [`String`].
+    pub fn relation(&self) -> Option<(OwnedEventId, String)> {
+        extract_event_relation(self.content.raw())
+    }
+}
+
 /// A concrete instance of [`GenericEvent`] for in-band events, i.e.,
 /// events which are part of a chunk and therefore have a position.
 pub type InBandEvent = GenericEvent<Position>;