Drop conversion of DecryptedRoomEvent into TimelineEvent (#243)

matrix-org/matrix-rust-sdk@5a1909a removes the implicit conversion from DecryptedRoomEvent to TimelineEvent that we'd been relying on since d7eca6f (which in turn was due to matrix-org/matrix-rust-sdk@1d1863d).

It turns out we don't really need to go via TimelineEvent. We can strip out the conversion, and then strip out some redundant Options.

Author: richvdh

CHANGELOG.md

@@ -20,6 +20,9 @@
     the same event successfully decrypted.
     ([#236](https://github.com/matrix-org/matrix-rust-sdk-crypto-wasm/pull/236))
 
+-   A number of the properties and methods on `DecryptedRoomEvent` no longer return `undefined`
+    ([#243](https://github.com/matrix-org/matrix-rust-sdk-crypto-wasm/pull/243))
+
 # matrix-sdk-crypto-wasm v14.2.1
 
 Update matrix-sdk-crypto to `0.11.1`, which includes:

src/machine.rs

@@ -10,12 +10,9 @@ use std::{
 
 use futures_util::{pin_mut, Stream, StreamExt};
 use js_sys::{Array, Function, JsString, Map, Promise, Set};
-use matrix_sdk_common::{
-    deserialized_responses::TimelineEvent,
-    ruma::{
-        self, events::secret::request::SecretName, serde::Raw, OneTimeKeyAlgorithm, OwnedDeviceId,
-        OwnedTransactionId, OwnedUserId, UInt,
-    },
+use matrix_sdk_common::ruma::{
+    self, events::secret::request::SecretName, serde::Raw, OneTimeKeyAlgorithm, OwnedDeviceId,
+    OwnedTransactionId, OwnedUserId, UInt,
 };
 use matrix_sdk_crypto::{
     backups::MegolmV1BackupKey,
@@ -505,13 +502,12 @@ impl OlmMachine {
             responses::DecryptedRoomEvent,
             MegolmDecryptionError,
         >(async move {
-            let room_event: TimelineEvent = me
+            let decrypted = me
                 .decrypt_room_event(&event, room_id.as_ref(), &decryption_settings)
                 .await
-                .map_err(MegolmDecryptionError::from)?
-                .into();
+                .map_err(MegolmDecryptionError::from)?;
 
-            responses::DecryptedRoomEvent::try_from(room_event).map_err(
+            responses::DecryptedRoomEvent::try_from(decrypted).map_err(
                 |e: UnsupportedAlgorithmError| {
                     // This happens if we somehow encounter a room event whose encryption info we
                     // don't understand (e.g., it is encrypted with Olm rather than

src/responses.rs

@@ -158,38 +158,38 @@ pub struct DecryptedRoomEvent {
     #[wasm_bindgen(readonly)]
     pub event: JsString,
 
-    encryption_info: Option<EncryptionInfo>,
+    encryption_info: EncryptionInfo,
 }
 
 #[wasm_bindgen]
 impl DecryptedRoomEvent {
     /// The user ID of the event sender, note this is untrusted data
     /// unless the `verification_state` is as well trusted.
     #[wasm_bindgen(getter)]
-    pub fn sender(&self) -> Option<identifiers::UserId> {
-        Some(self.encryption_info.as_ref()?.sender.clone())
+    pub fn sender(&self) -> identifiers::UserId {
+        self.encryption_info.sender.clone()
     }
 
     /// The device ID of the device that sent us the event, note this
     /// is untrusted data unless `verification_state` is as well
     /// trusted.
     #[wasm_bindgen(getter, js_name = "senderDevice")]
     pub fn sender_device(&self) -> Option<identifiers::DeviceId> {
-        self.encryption_info.as_ref()?.sender_device.clone()
+        self.encryption_info.sender_device.clone()
     }
 
     /// The Curve25519 key of the device that created the megolm
     /// decryption key originally.
     #[wasm_bindgen(getter, js_name = "senderCurve25519Key")]
-    pub fn sender_curve25519_key(&self) -> Option<JsString> {
-        Some(self.encryption_info.as_ref()?.sender_curve25519_key_base64.as_str().into())
+    pub fn sender_curve25519_key(&self) -> String {
+        self.encryption_info.sender_curve25519_key_base64.as_str().to_owned()
     }
 
     /// The signing Ed25519 key that have created the megolm key that
     /// was used to decrypt this session.
     #[wasm_bindgen(getter, js_name = "senderClaimedEd25519Key")]
     pub fn sender_claimed_ed25519_key(&self) -> Option<JsString> {
-        Some(self.encryption_info.as_ref()?.sender_claimed_ed25519_key.as_ref()?.as_str().into())
+        Some(self.encryption_info.sender_claimed_ed25519_key.as_ref()?.as_str().into())
     }
 
     /// Returns an empty array
@@ -210,23 +210,19 @@ impl DecryptedRoomEvent {
     /// decryption. It may change in the future if a device gets
     /// verified or deleted.
     #[wasm_bindgen(js_name = "shieldState")]
-    pub fn shield_state(&self, strict: bool) -> Option<encryption::ShieldState> {
-        Some(self.encryption_info.as_ref()?.shield_state(strict))
+    pub fn shield_state(&self, strict: bool) -> encryption::ShieldState {
+        self.encryption_info.shield_state(strict)
     }
 }
 
-impl TryFrom<matrix_sdk_common::deserialized_responses::TimelineEvent> for DecryptedRoomEvent {
+impl TryFrom<matrix_sdk_common::deserialized_responses::DecryptedRoomEvent> for DecryptedRoomEvent {
     type Error = UnsupportedAlgorithmError;
 
     fn try_from(
-        value: matrix_sdk_common::deserialized_responses::TimelineEvent,
+        value: matrix_sdk_common::deserialized_responses::DecryptedRoomEvent,
     ) -> Result<Self, Self::Error> {
-        let encryption_info = match value.encryption_info() {
-            None => None,
-            Some(encryption_info) => Some(encryption_info.clone().try_into()?),
-        };
-
-        Ok(Self { event: value.raw().json().get().to_owned().into(), encryption_info })
+        let encryption_info = value.encryption_info.clone().try_into()?;
+        Ok(Self { event: value.event.json().get().into(), encryption_info })
     }
 }