refactor(sdk): explicit the case where we can't compute the push actions

Author: bnjbvr

crates/matrix-sdk-ui/src/notification_client.rs

@@ -218,8 +218,9 @@ impl NotificationClient {
 
                         sleep(Duration::from_millis(wait)).await;
 
-                        let new_event =
-                            room.decrypt_event(raw_event.cast_ref(), &push_action_ctx).await?;
+                        let new_event = room
+                            .decrypt_event(raw_event.cast_ref(), push_action_ctx.as_ref())
+                            .await?;
 
                         match new_event.kind {
                             matrix_sdk::deserialized_responses::TimelineEventKind::UnableToDecrypt {
@@ -260,7 +261,7 @@ impl NotificationClient {
 
         match encryption_sync {
             Ok(sync) => match sync.run_fixed_iterations(2, sync_permit_guard).await {
-                Ok(()) => match room.decrypt_event(raw_event.cast_ref(), &push_action_ctx).await {
+                Ok(()) => match room.decrypt_event(raw_event.cast_ref(), push_action_ctx.as_ref()).await {
                     Ok(new_event) => match new_event.kind {
                         matrix_sdk::deserialized_responses::TimelineEventKind::UnableToDecrypt {
                             utd_info, ..
@@ -516,12 +517,12 @@ impl NotificationClient {
                     raw_event = RawNotificationEvent::Timeline(timeline_event.into_raw());
                     push_actions
                 } else {
-                    room.push_context().await?.for_event(timeline_event)
+                    room.event_push_actions(timeline_event).await?
                 }
             }
             RawNotificationEvent::Invite(invite_event) => {
                 // Invite events can't be encrypted, so they should be in clear text.
-                room.push_context().await?.for_event(invite_event)
+                room.event_push_actions(invite_event).await?
             }
         };
 

crates/matrix-sdk-ui/src/timeline/traits.rs

@@ -306,7 +306,7 @@ pub(super) trait Decryptor: AsyncTraitDeps + Clone + 'static {
 impl Decryptor for Room {
     async fn decrypt_event_impl(&self, raw: &Raw<AnySyncTimelineEvent>) -> Result<TimelineEvent> {
         let push_action_ctx = self.push_context().await?;
-        self.decrypt_event(raw.cast_ref(), &push_action_ctx).await
+        self.decrypt_event(raw.cast_ref(), push_action_ctx.as_ref()).await
     }
 }
 

crates/matrix-sdk/CHANGELOG.md

@@ -12,9 +12,13 @@ All notable changes to this project will be documented in this file.
 
 ### Refactor
 
-- The `Room::push_context()` has been renamed into `Room::push_condition_room_ctx()`. The newer
+- `Room::push_context()` has been renamed into `Room::push_condition_room_ctx()`. The newer
   `Room::push_context` now returns a `matrix_sdk::Room::PushContext`, which can be used to compute
   the push actions for any event.
+  ([#4962](https://github.com/matrix-org/matrix-rust-sdk/pull/4962))
+- `Room::decrypt_event()` now requires an extra `matrix_sdk::Room::PushContext` parameter to
+  compute the push notifications for the decrypted event.
+  ([#4962](https://github.com/matrix-org/matrix-rust-sdk/pull/4962))
 
 ## [0.11.0] - 2025-04-11
 

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

@@ -196,10 +196,7 @@ const TYPING_NOTICE_RESEND_TIMEOUT: Duration = Duration::from_secs(3);
 #[derive(Debug)]
 pub struct PushContext {
     /// The Ruma context used to compute the push actions.
-    ///
-    /// May be missing if some state events were missing for the current room
-    /// (e.g. the member information for the logged-in user was missing).
-    push_condition_room_ctx: Option<PushConditionRoomCtx>,
+    push_condition_room_ctx: PushConditionRoomCtx,
 
     /// Push rules for this room, based on the push rules state event, or the
     /// global server default as defined by [`Ruleset::server_default`].
@@ -208,11 +205,8 @@ pub struct PushContext {
 
 impl PushContext {
     /// Compute the push rules for a given event.
-    ///
-    /// Will return `None` if and only if the underlying
-    /// [`PushConditionRoomCtx`] is missing.
-    pub fn for_event<T>(&self, event: &Raw<T>) -> Option<Vec<Action>> {
-        Some(self.push_rules.get_actions(event, self.push_condition_room_ctx.as_ref()?).to_owned())
+    pub fn for_event<T>(&self, event: &Raw<T>) -> Vec<Action> {
+        self.push_rules.get_actions(event, &self.push_condition_room_ctx).to_owned()
     }
 }
 
@@ -360,7 +354,10 @@ impl Room {
 
         let push_action_ctx = self.push_context().await?;
         let chunk = join_all(
-            http_response.chunk.into_iter().map(|ev| self.try_decrypt_event(ev, &push_action_ctx)),
+            http_response
+                .chunk
+                .into_iter()
+                .map(|ev| self.try_decrypt_event(ev, push_action_ctx.as_ref())),
         )
         .await;
 
@@ -471,7 +468,7 @@ impl Room {
     async fn try_decrypt_event(
         &self,
         event: Raw<AnyTimelineEvent>,
-        push_ctx: &PushContext,
+        push_ctx: Option<&PushContext>,
     ) -> TimelineEvent {
         #[cfg(feature = "e2e-encryption")]
         if let Ok(AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomEncrypted(
@@ -484,7 +481,7 @@ impl Room {
         }
 
         let mut event = TimelineEvent::new(event.cast());
-        event.push_actions = push_ctx.for_event(event.raw());
+        event.push_actions = push_ctx.map(|ctx| ctx.for_event(event.raw()));
 
         event
     }
@@ -503,7 +500,7 @@ impl Room {
 
         let raw_event = self.client.send(request).with_request_config(request_config).await?.event;
         let push_action_ctx = self.push_context().await?;
-        let event = self.try_decrypt_event(raw_event, &push_action_ctx).await;
+        let event = self.try_decrypt_event(raw_event, push_action_ctx.as_ref()).await;
 
         // Save the event into the event cache, if it's set up.
         if let Ok((cache, _handles)) = self.event_cache().await {
@@ -560,8 +557,9 @@ impl Room {
         let response = self.client.send(request).with_request_config(request_config).await?;
 
         let push_action_ctx = self.push_context().await?;
+        let push_action_ctx = push_action_ctx.as_ref();
         let target_event = if let Some(event) = response.event {
-            Some(self.try_decrypt_event(event, &push_action_ctx).await)
+            Some(self.try_decrypt_event(event, push_action_ctx).await)
         } else {
             None
         };
@@ -574,13 +572,13 @@ impl Room {
                 response
                     .events_before
                     .into_iter()
-                    .map(|ev| self.try_decrypt_event(ev, &push_action_ctx)),
+                    .map(|ev| self.try_decrypt_event(ev, push_action_ctx)),
             ),
             join_all(
                 response
                     .events_after
                     .into_iter()
-                    .map(|ev| self.try_decrypt_event(ev, &push_action_ctx)),
+                    .map(|ev| self.try_decrypt_event(ev, push_action_ctx)),
             ),
         );
 
@@ -1369,7 +1367,7 @@ impl Room {
     pub async fn decrypt_event(
         &self,
         event: &Raw<OriginalSyncRoomEncryptedEvent>,
-        push_ctx: &PushContext,
+        push_ctx: Option<&PushContext>,
     ) -> Result<TimelineEvent> {
         let machine = self.client.olm_machine().await;
         let machine = machine.as_ref().ok_or(Error::NoOlmMachine)?;
@@ -1391,7 +1389,7 @@ impl Room {
             }
         };
 
-        event.push_actions = push_ctx.for_event(event.raw());
+        event.push_actions = push_ctx.map(|ctx| ctx.for_event(event.raw()));
         Ok(event)
     }
 
@@ -2952,31 +2950,21 @@ impl Room {
 
     /// Retrieves a [`PushContext`] that can be used to compute the push
     /// actions for events.
-    pub async fn push_context(&self) -> Result<PushContext> {
-        let push_condition_room_ctx = self.push_condition_room_ctx().await?;
-        if push_condition_room_ctx.is_none() {
+    pub async fn push_context(&self) -> Result<Option<PushContext>> {
+        let Some(push_condition_room_ctx) = self.push_condition_room_ctx().await? else {
             debug!("Could not aggregate push context");
-        }
+            return Ok(None);
+        };
         let push_rules = self.client().account().push_rules().await?;
-        Ok(PushContext { push_condition_room_ctx, push_rules })
+        Ok(Some(PushContext { push_condition_room_ctx, push_rules }))
     }
 
     /// Get the push actions for the given event with the current room state.
     ///
     /// Note that it is possible that no push action is returned because the
     /// current room state does not have all the required state events.
-    #[deprecated(
-        note = "Use `Room::push_context` to retrieve a `PushContext` instead, and call `PushContext::for_event` on your event."
-    )]
     pub async fn event_push_actions<T>(&self, event: &Raw<T>) -> Result<Option<Vec<Action>>> {
-        let Some(push_context) = self.push_condition_room_ctx().await? else {
-            debug!("Could not aggregate push context");
-            return Ok(None);
-        };
-
-        let push_rules = self.client().account().push_rules().await?;
-
-        Ok(Some(push_rules.get_actions(event, &push_context).to_owned()))
+        Ok(self.push_context().await?.map(|ctx| ctx.for_event(event)))
     }
 
     /// The membership details of the (latest) invite for the logged-in user in

crates/matrix-sdk/tests/integration/client.rs

@@ -773,7 +773,7 @@ async fn test_encrypt_room_event() {
     let push_action_ctx =
         room.push_context().await.expect("We should be able to get the push action context");
     let timeline_event = room
-        .decrypt_event(&event, &push_action_ctx)
+        .decrypt_event(&event, push_action_ctx.as_ref())
         .await
         .expect("We should be able to decrypt an event that we ourselves have encrypted");
 

testing/matrix-sdk-integration-testing/src/tests/nse.rs

@@ -426,7 +426,7 @@ async fn decrypt_event(
 ) -> Option<(OwnedEventId, String)> {
     let room = client.get_room(room_id).unwrap();
     let push_action_ctx = room.push_context().await.unwrap();
-    let Ok(decrypted) = room.decrypt_event(event, &push_action_ctx).await else {
+    let Ok(decrypted) = room.decrypt_event(event, push_action_ctx.as_ref()).await else {
         return None;
     };