Give all ProcessedToDevice variants a rawEvent property (#246)

Turns out that being able to access our best guess as to the event content,
irrespective of the variant, is useful.

Follow-up on #236

Author: richvdh

CHANGELOG.md

@@ -23,7 +23,7 @@
     `ProcessedToDeviceEvent` instead of a JSON-encoded list of JSON-encoded events.
     This allows making the difference between an event that was sent in clear and
     the same event successfully decrypted.
-    ([#236](https://github.com/matrix-org/matrix-rust-sdk-crypto-wasm/pull/236))
+    ([#236](https://github.com/matrix-org/matrix-rust-sdk-crypto-wasm/pull/236)), ([#246](https://github.com/matrix-org/matrix-rust-sdk-crypto-wasm/pull/246))
 
 -   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))

src/types.rs

@@ -388,15 +388,15 @@ pub enum ProcessedToDeviceEventType {
 #[wasm_bindgen]
 #[derive(Debug, Clone)]
 pub struct DecryptedToDeviceEvent {
-    /// A JSON-encoded object containing the decrypted event, as if it had been
-    /// sent in the clear.
+    /// The decrypted event, as if it had been sent in the clear, encoded as
+    /// JSON.
     ///
     /// Typically contains properties `type`, `sender` and `content`.
     ///
     /// (For room keys or secrets, some part of the content might have been
     /// zeroized).
-    #[wasm_bindgen(readonly, getter_with_clone, js_name = "decryptedRawEvent")]
-    pub decrypted_raw_event: JsString,
+    #[wasm_bindgen(readonly, getter_with_clone, js_name = "rawEvent")]
+    pub raw_event: JsString,
 
     /// The encryption information for the event.
     #[wasm_bindgen(readonly, getter_with_clone, js_name = "encryptionInfo")]
@@ -417,8 +417,8 @@ impl DecryptedToDeviceEvent {
 #[wasm_bindgen]
 #[derive(Debug, Clone)]
 pub struct PlainTextToDeviceEvent {
-    /// A JSON-encoded object containing the Matrix to-device message with
-    /// `type`, `sender` and `content` fields.
+    /// The to-device message, containing `type`, `sender` and `content` fields,
+    /// encoded as JSON.
     #[wasm_bindgen(readonly, getter_with_clone, js_name = "rawEvent")]
     pub raw_event: JsString,
 }
@@ -437,10 +437,10 @@ impl PlainTextToDeviceEvent {
 #[wasm_bindgen]
 #[derive(Debug, Clone)]
 pub struct UTDToDeviceEvent {
-    /// A JSON-encoded object containing the original message of type
-    /// `m.room.encrypted` that failed to be decrypted.
-    #[wasm_bindgen(readonly, getter_with_clone, js_name = "wireEvent")]
-    pub wire_event: JsString,
+    /// The original message (of type `m.room.encrypted`) that failed to be
+    /// decrypted, encoded as JSON.
+    #[wasm_bindgen(readonly, getter_with_clone, js_name = "rawEvent")]
+    pub raw_event: JsString,
     // TODO: Add some OlmError in the future
 }
 
@@ -459,10 +459,9 @@ impl UTDToDeviceEvent {
 #[wasm_bindgen]
 #[derive(Debug, Clone)]
 pub struct InvalidToDeviceEvent {
-    /// A JSON-encoded object containing the original message as received from
-    /// sync.
-    #[wasm_bindgen(readonly, getter_with_clone, js_name = "wireEvent")]
-    pub wire_event: JsString,
+    /// The original message as received from sync, encoded as JSON.
+    #[wasm_bindgen(readonly, getter_with_clone, js_name = "rawEvent")]
+    pub raw_event: JsString,
     // TODO: Add some error information here?
 }
 
@@ -498,11 +497,10 @@ pub fn processed_to_device_event_to_js_value(
     let result = match processed_to_device_event {
         matrix_sdk_crypto::types::ProcessedToDeviceEvent::Decrypted { raw, encryption_info } => {
             match encryption_info.try_into() {
-                Ok(encryption_info) => DecryptedToDeviceEvent {
-                    decrypted_raw_event: raw.json().get().into(),
-                    encryption_info,
+                Ok(encryption_info) => {
+                    DecryptedToDeviceEvent { raw_event: raw.json().get().into(), encryption_info }
+                        .into()
                 }
-                .into(),
                 Err(e) => {
                     // This can only happen if we receive an encrypted to-device event which is
                     // encrypted with an algorithm we don't recognise. This
@@ -516,13 +514,13 @@ pub fn processed_to_device_event_to_js_value(
             }
         }
         matrix_sdk_crypto::types::ProcessedToDeviceEvent::UnableToDecrypt(utd) => {
-            UTDToDeviceEvent { wire_event: utd.json().get().into() }.into()
+            UTDToDeviceEvent { raw_event: utd.json().get().into() }.into()
         }
         matrix_sdk_crypto::types::ProcessedToDeviceEvent::PlainText(plain) => {
             PlainTextToDeviceEvent { raw_event: plain.json().get().into() }.into()
         }
         matrix_sdk_crypto::types::ProcessedToDeviceEvent::Invalid(invalid) => {
-            InvalidToDeviceEvent { wire_event: invalid.json().get().into() }.into()
+            InvalidToDeviceEvent { raw_event: invalid.json().get().into() }.into()
         }
     };
     Some(result)

tests/machine.test.ts

@@ -1643,7 +1643,7 @@ describe(OlmMachine.name, () => {
             const processed = receivedToDeviceArray[0];
             expect(processed.type).toEqual(ProcessedToDeviceEventType.PlainText);
             expect(processed).toBeInstanceOf(PlainTextToDeviceEvent);
-            const toDeviceEvent = JSON.parse((processed as PlainTextToDeviceEvent).rawEvent);
+            const toDeviceEvent = JSON.parse(processed.rawEvent);
 
             expect(toDeviceEvent.sender).toEqual("@alice:example.com");
             expect(toDeviceEvent.type).toEqual("custom.type");
@@ -1684,7 +1684,7 @@ describe(OlmMachine.name, () => {
             const processed = receivedToDeviceArray[0];
             expect(processed.type).toEqual(ProcessedToDeviceEventType.UnableToDecrypt);
             expect(processed).toBeInstanceOf(UTDToDeviceEvent);
-            const toDeviceEvent = JSON.parse((processed as UTDToDeviceEvent).wireEvent);
+            const toDeviceEvent = JSON.parse(processed.rawEvent);
 
             expect(toDeviceEvent.sender).toEqual("@bob:example.org");
             expect(toDeviceEvent.type).toEqual("m.room.encrypted");
@@ -1737,14 +1737,14 @@ describe(OlmMachine.name, () => {
             const processed0 = receivedToDeviceArray[0];
             expect(processed0.type).toEqual(ProcessedToDeviceEventType.Invalid);
             expect(processed0).toBeInstanceOf(InvalidToDeviceEvent);
-            const toDeviceEvent0 = JSON.parse((processed0 as InvalidToDeviceEvent).wireEvent);
+            const toDeviceEvent0 = JSON.parse(processed0.rawEvent);
             expect(toDeviceEvent0.sender).toEqual("@alice:example.com");
             expect(toDeviceEvent0.content).toBeDefined();
             expect(toDeviceEvent0.type).toBeUndefined();
 
             const processed1 = receivedToDeviceArray[1];
             expect(processed1.type).toEqual(ProcessedToDeviceEventType.Invalid);
-            const toDeviceEvent1 = JSON.parse((processed1 as InvalidToDeviceEvent).wireEvent);
+            const toDeviceEvent1 = JSON.parse(processed1.rawEvent);
             expect(toDeviceEvent1.sender).toEqual("@bob:example.org");
             expect(toDeviceEvent1.type).toEqual("m.room.encrypted");
         });
@@ -1846,7 +1846,7 @@ describe(OlmMachine.name, () => {
             const processed = receivedToDeviceArray[0];
             expect(processed.type).toEqual(ProcessedToDeviceEventType.Decrypted);
             expect(processed).toBeInstanceOf(DecryptedToDeviceEvent);
-            const toDeviceEvent = JSON.parse((processed as DecryptedToDeviceEvent).decryptedRawEvent);
+            const toDeviceEvent = JSON.parse(processed.rawEvent);
 
             expect(toDeviceEvent.sender).toEqual("@alice:example.org");
             expect(toDeviceEvent.type).toEqual("custom.type");