feat(sdk): Add support for event types with prefix for event handlers

Signed-off-by: Kévin Commaille <zecakeh@tedomum.fr>

Author: zecakeh

crates/matrix-sdk/src/event_handler/maps.rs

@@ -17,16 +17,19 @@ use std::{
     collections::{btree_map, BTreeMap},
 };
 
-use ruma::{OwnedRoomId, RoomId};
+use ruma::{events::StaticEventTypePart, OwnedRoomId, RoomId};
 
 use super::{EventHandlerFn, EventHandlerHandle, EventHandlerWrapper, HandlerKind};
 
 #[derive(Default)]
 pub(super) struct EventHandlerMaps {
     by_kind: BTreeMap<HandlerKind, Vec<EventHandlerWrapper>>,
     by_kind_type: BTreeMap<KindTypeWrap, Vec<EventHandlerWrapper>>,
+    by_kind_type_prefix: BTreeMap<HandlerKind, BTreeMap<&'static str, Vec<EventHandlerWrapper>>>,
     by_kind_roomid: BTreeMap<KindRoomId, Vec<EventHandlerWrapper>>,
     by_kind_type_roomid: BTreeMap<KindTypeRoomIdWrap, Vec<EventHandlerWrapper>>,
+    by_kind_type_prefix_roomid:
+        BTreeMap<KindRoomId, BTreeMap<&'static str, Vec<EventHandlerWrapper>>>,
 }
 
 impl EventHandlerMaps {
@@ -40,12 +43,27 @@ impl EventHandlerMaps {
             Key::KindType(key) => {
                 self.by_kind_type.entry(key).or_default().push(wrapper);
             }
+            Key::KindTypePrefix(outer_key, inner_key) => {
+                self.by_kind_type_prefix
+                    .entry(outer_key)
+                    .or_default()
+                    .entry(inner_key)
+                    .or_default()
+                    .push(wrapper);
+            }
             Key::KindRoomId(key) => {
                 self.by_kind_roomid.entry(key).or_default().push(wrapper);
             }
             Key::KindTypeRoomId(key) => {
                 self.by_kind_type_roomid.entry(key).or_default().push(wrapper)
             }
+            Key::KindTypePrefixRoomId(outer_key, inner_key) => self
+                .by_kind_type_prefix_roomid
+                .entry(outer_key)
+                .or_default()
+                .entry(inner_key)
+                .or_default()
+                .push(wrapper),
         }
     }
 
@@ -61,7 +79,16 @@ impl EventHandlerMaps {
         let kind_type_kv = self
             .by_kind_type
             .get_key_value(&KindType { ev_kind, ev_type })
-            .map(|(key, handlers)| (Some(key.0.ev_type), handlers));
+            .map(|(key, handlers)| (Some(StaticEventTypePart::Full(key.0.ev_type)), handlers));
+        let kind_type_prefix_kv = self
+            .by_kind_type_prefix
+            .get_key_value(&ev_kind)
+            .and_then(|(_, inner_map)| {
+                inner_map.iter().find(|(ev_type_prefix, _)| ev_type.starts_with(**ev_type_prefix))
+            })
+            .map(|(ev_type_prefix, handlers)| {
+                (Some(StaticEventTypePart::Prefix(ev_type_prefix)), handlers)
+            });
         let maybe_roomid_kvs = room_id
             .map(|r_id| {
                 let room_id = r_id.to_owned();
@@ -74,15 +101,33 @@ impl EventHandlerMaps {
                 let kind_type_roomid_kv = self
                     .by_kind_type_roomid
                     .get_key_value(&KindTypeRoomId { ev_kind, ev_type, room_id })
-                    .map(|(key, handlers)| (Some(key.0.ev_type), handlers));
+                    .map(|(key, handlers)| {
+                        (Some(StaticEventTypePart::Full(key.0.ev_type)), handlers)
+                    });
 
-                [kind_roomid_kv, kind_type_roomid_kv]
+                let room_id = r_id.to_owned();
+                let kind_type_prefix_roomid_kv = self
+                    .by_kind_type_prefix_roomid
+                    .get_key_value(&KindRoomId { ev_kind, room_id })
+                    .and_then(|(_, inner_map)| {
+                        inner_map
+                            .iter()
+                            .find(|(ev_type_prefix, _)| ev_type.starts_with(**ev_type_prefix))
+                    })
+                    .map(|(ev_type_prefix, handlers)| {
+                        (Some(StaticEventTypePart::Prefix(ev_type_prefix)), handlers)
+                    });
+
+                [kind_roomid_kv, kind_type_roomid_kv, kind_type_prefix_roomid_kv]
             })
             .into_iter()
             .flatten();
 
-        [kind_kv, kind_type_kv].into_iter().chain(maybe_roomid_kvs).flatten().flat_map(
-            move |(ev_type, handlers)| {
+        [kind_kv, kind_type_kv, kind_type_prefix_kv]
+            .into_iter()
+            .chain(maybe_roomid_kvs)
+            .flatten()
+            .flat_map(move |(ev_type, handlers)| {
                 handlers.iter().map(move |wrap| {
                     let handle = EventHandlerHandle {
                         ev_kind,
@@ -93,8 +138,7 @@ impl EventHandlerMaps {
 
                     (handle, &*wrap.handler_fn)
                 })
-            },
-        )
+            })
     }
 
     pub fn remove(&mut self, handle: EventHandlerHandle) {
@@ -113,6 +157,21 @@ impl EventHandlerMaps {
                 }
             }
         }
+        fn remove_nested_entry<K1: Ord, K2: Ord>(
+            map: &mut BTreeMap<K1, BTreeMap<K2, Vec<EventHandlerWrapper>>>,
+            outer_key: K1,
+            inner_key: K2,
+            handler_id: u64,
+        ) {
+            if let btree_map::Entry::Occupied(mut o) = map.entry(outer_key) {
+                let v = o.get_mut();
+                remove_entry(v, inner_key, handler_id);
+
+                if v.is_empty() {
+                    o.remove();
+                }
+            }
+        }
 
         let handler_id = handle.handler_id;
         match Key::new(handle) {
@@ -122,12 +181,28 @@ impl EventHandlerMaps {
             Key::KindType(key) => {
                 remove_entry(&mut self.by_kind_type, key, handler_id);
             }
+            Key::KindTypePrefix(outer_key, inner_key) => {
+                remove_nested_entry(
+                    &mut self.by_kind_type_prefix,
+                    outer_key,
+                    inner_key,
+                    handler_id,
+                );
+            }
             Key::KindRoomId(key) => {
                 remove_entry(&mut self.by_kind_roomid, key, handler_id);
             }
             Key::KindTypeRoomId(key) => {
                 remove_entry(&mut self.by_kind_type_roomid, key, handler_id);
             }
+            Key::KindTypePrefixRoomId(outer_key, inner_key) => {
+                remove_nested_entry(
+                    &mut self.by_kind_type_prefix_roomid,
+                    outer_key,
+                    inner_key,
+                    handler_id,
+                );
+            }
         }
     }
 
@@ -140,21 +215,38 @@ impl EventHandlerMaps {
 enum Key {
     Kind(HandlerKind),
     KindType(KindTypeWrap),
+    KindTypePrefix(HandlerKind, &'static str),
     KindRoomId(KindRoomId),
     KindTypeRoomId(KindTypeRoomIdWrap),
+    KindTypePrefixRoomId(KindRoomId, &'static str),
 }
 
 impl Key {
     fn new(handle: EventHandlerHandle) -> Self {
         let EventHandlerHandle { ev_kind, ev_type, room_id, .. } = handle;
         match (ev_type, room_id) {
             (None, None) => Key::Kind(ev_kind),
-            (Some(ev_type), None) => Key::KindType(KindTypeWrap(KindType { ev_kind, ev_type })),
+            (Some(ev_type), None) => match ev_type {
+                StaticEventTypePart::Full(ev_type) => {
+                    Key::KindType(KindTypeWrap(KindType { ev_kind, ev_type }))
+                }
+                StaticEventTypePart::Prefix(ev_type_prefix) => {
+                    Key::KindTypePrefix(ev_kind, ev_type_prefix)
+                }
+            },
             (None, Some(room_id)) => Key::KindRoomId(KindRoomId { ev_kind, room_id }),
-            (Some(ev_type), Some(room_id)) => {
-                let inner = KindTypeRoomId { ev_kind, ev_type, room_id };
-                Key::KindTypeRoomId(KindTypeRoomIdWrap(inner))
-            }
+            (Some(ev_type), Some(room_id)) => match ev_type {
+                StaticEventTypePart::Full(ev_type) => {
+                    Key::KindTypeRoomId(KindTypeRoomIdWrap(KindTypeRoomId {
+                        ev_kind,
+                        ev_type,
+                        room_id,
+                    }))
+                }
+                StaticEventTypePart::Prefix(ev_type_prefix) => {
+                    Key::KindTypePrefixRoomId(KindRoomId { ev_kind, room_id }, ev_type_prefix)
+                }
+            },
         }
     }
 }

crates/matrix-sdk/src/event_handler/mod.rs

@@ -58,7 +58,12 @@ use matrix_sdk_base::{
 };
 use matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent;
 use pin_project_lite::pin_project;
-use ruma::{events::AnySyncStateEvent, push::Action, serde::Raw, OwnedRoomId};
+use ruma::{
+    events::{AnySyncStateEvent, StaticEventTypePart},
+    push::Action,
+    serde::Raw,
+    OwnedRoomId,
+};
 use serde::{de::DeserializeOwned, Deserialize};
 use serde_json::value::RawValue as RawJsonValue;
 use tracing::{debug, error, field::debug, instrument, warn};
@@ -157,7 +162,7 @@ pub trait SyncEvent {
     #[doc(hidden)]
     const KIND: HandlerKind;
     #[doc(hidden)]
-    const TYPE: Option<&'static str>;
+    const TYPE: Option<StaticEventTypePart>;
 }
 
 pub(crate) struct EventHandlerWrapper {
@@ -170,7 +175,7 @@ pub(crate) struct EventHandlerWrapper {
 #[derive(Clone, Debug)]
 pub struct EventHandlerHandle {
     pub(crate) ev_kind: HandlerKind,
-    pub(crate) ev_type: Option<&'static str>,
+    pub(crate) ev_type: Option<StaticEventTypePart>,
     pub(crate) room_id: Option<OwnedRoomId>,
     pub(crate) handler_id: u64,
 }
@@ -254,17 +259,17 @@ pub struct EventHandlerData<'a> {
 /// It is not meant to be implemented outside of matrix-sdk.
 pub trait EventHandlerResult: Sized {
     #[doc(hidden)]
-    fn print_error(&self, event_type: Option<&str>);
+    fn print_error(&self, event_type: Option<StaticEventTypePart>);
 }
 
 impl EventHandlerResult for () {
-    fn print_error(&self, _event_type: Option<&str>) {}
+    fn print_error(&self, _event_type: Option<StaticEventTypePart>) {}
 }
 
 impl<E: fmt::Debug + fmt::Display + 'static> EventHandlerResult for Result<(), E> {
-    fn print_error(&self, event_type: Option<&str>) {
+    fn print_error(&self, event_type: Option<StaticEventTypePart>) {
         let msg_fragment = match event_type {
-            Some(event_type) => format!(" for `{event_type}`"),
+            Some(event_type) => format!(" for `{event_type:?}`"),
             None => "".to_owned(),
         };
 
@@ -312,13 +317,13 @@ impl Client {
                     }
                     Ok(None) => {
                         error!(
-                            event_type = Ev::TYPE, event_kind = ?Ev::KIND,
+                            event_type = ?Ev::TYPE, event_kind = ?Ev::KIND,
                             "Event handler has an invalid context argument",
                         );
                     }
                     Err(e) => {
                         warn!(
-                            event_type = Ev::TYPE, event_kind = ?Ev::KIND,
+                            event_type = ?Ev::TYPE, event_kind = ?Ev::KIND,
                             "Failed to deserialize event, skipping event handler.\n
                              Deserialization error: {e}",
                         );
@@ -715,6 +720,7 @@ mod tests {
         event_factory::{EventFactory, PreviousMembership},
         InvitedRoomBuilder, JoinedRoomBuilder, DEFAULT_TEST_ROOM_ID,
     };
+    use serde::{Deserialize, Serialize};
     use stream_assert::{assert_closed, assert_pending, assert_ready};
     #[cfg(target_family = "wasm")]
     wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
@@ -733,11 +739,13 @@ mod tests {
     use ruma::{
         event_id,
         events::{
+            macros::EventContent,
             room::{
                 member::{MembershipState, OriginalSyncRoomMemberEvent, StrippedRoomMemberEvent},
                 name::OriginalSyncRoomNameEvent,
                 power_levels::OriginalSyncRoomPowerLevelsEvent,
             },
+            secret_storage::key::SecretStorageKeyEvent,
             typing::SyncTypingEvent,
             AnySyncStateEvent, AnySyncTimelineEvent, AnyToDeviceEvent,
         },
@@ -1310,4 +1318,95 @@ mod tests {
 
         Ok(())
     }
+
+    #[async_test]
+    #[allow(dependency_on_unit_never_type_fallback)]
+    async fn test_observe_events_with_type_prefix() -> crate::Result<()> {
+        let client = logged_in_client(None).await;
+
+        let observable = client.observe_events::<SecretStorageKeyEvent, ()>();
+
+        let mut subscriber = observable.subscribe();
+
+        assert_pending!(subscriber);
+
+        let mut response_builder = SyncResponseBuilder::new();
+        let response = response_builder
+            .add_global_account_data_bulk([Raw::new(&json!({
+                "content": {
+                    "algorithm": "m.secret_storage.v1.aes-hmac-sha2",
+                    "iv": "gH2iNpiETFhApvW6/FFEJQ",
+                    "mac": "9Lw12m5SKDipNghdQXKjgpfdj1/K7HFI2brO+UWAGoM",
+                    "passphrase": {
+                        "algorithm": "m.pbkdf2",
+                        "salt": "IuLnH7S85YtZmkkBJKwNUKxWF42g9O1H",
+                        "iterations": 10,
+                    },
+                },
+                "type": "m.secret_storage.key.foobar",
+            }))
+            .unwrap()
+            .cast()])
+            .build_sync_response();
+        client.process_sync(response).await?;
+
+        let (secret_storage_key, ()) = assert_ready!(subscriber);
+
+        assert_eq!(secret_storage_key.content.key_id, "foobar");
+
+        assert_pending!(subscriber);
+
+        drop(observable);
+        assert_closed!(subscriber);
+
+        Ok(())
+    }
+
+    #[async_test]
+    #[allow(dependency_on_unit_never_type_fallback)]
+    async fn test_observe_room_events_with_type_prefix() -> crate::Result<()> {
+        // To create an event handler for a room account data event type with prefix, we
+        // need to create a custom event type, none exist in the Matrix specification
+        // yet.
+        #[derive(Debug, Clone, EventContent, Deserialize, Serialize)]
+        #[ruma_event(type = "fake.event.*", kind = RoomAccountData)]
+        struct AccountDataWithPrefixEventContent {
+            #[ruma_event(type_fragment)]
+            #[serde(skip)]
+            key_id: String,
+        }
+
+        let room_id = room_id!("!r0.matrix.org");
+        let client = logged_in_client(None).await;
+
+        let observable = client.observe_room_events::<AccountDataWithPrefixEvent, Room>(room_id);
+
+        let mut subscriber = observable.subscribe();
+
+        assert_pending!(subscriber);
+
+        let mut response_builder = SyncResponseBuilder::new();
+        let response = response_builder
+            .add_joined_room(
+                JoinedRoomBuilder::new(room_id).add_account_data_bulk([Raw::new(&json!({
+                    "content": {},
+                    "type": "fake.event.foobar",
+                }))
+                .unwrap()
+                .cast()]),
+            )
+            .build_sync_response();
+        client.process_sync(response).await?;
+
+        let (secret_storage_key, _room) = assert_ready!(subscriber);
+
+        assert_eq!(secret_storage_key.content.key_id, "foobar");
+
+        assert_pending!(subscriber);
+
+        drop(observable);
+        assert_closed!(subscriber);
+
+        Ok(())
+    }
 }