basic callback on secret stream

src/machine.rs

@@ -4,7 +4,10 @@ use std::{collections::BTreeMap, ops::Deref, time::Duration};
 
 use futures_util::{pin_mut, StreamExt};
 use js_sys::{Array, Function, Map, Promise, Set};
-use matrix_sdk_common::ruma::{self, serde::Raw, DeviceKeyAlgorithm, OwnedTransactionId, UInt};
+use matrix_sdk_common::ruma::{
+    self, events::secret::request::SecretName, serde::Raw, DeviceKeyAlgorithm, OwnedTransactionId,
+    UInt,
+};
 use matrix_sdk_crypto::{
     backups::MegolmV1BackupKey,
     store::{DeviceChanges, IdentityChanges},
@@ -1093,26 +1096,84 @@ impl OlmMachine {
             stream.for_each(move |item| send_user_identities_to_callback(callback_ref, item)).await;
         });
     }
-    /// Register a callback which will be called whenever a secret is received.
+
+    /// Register a callback which will be called whenever a secret
+    /// (`m.secret.send`) is received.
+    ///
+    /// To request a secret from other devices, a client sends an
+    /// `m.secret.request` device event with action set to request and name set
+    /// to the identifier of the secret. A device that wishes to share the
+    /// secret will reply with an m.secret.send event, encrypted using olm.
+    ///
+    /// The secrets are guaranteed to have been received over a 1-to-1 encrypted
+    /// to_device message from a verified own device.
     ///
-    /// `callback` should be a function that takes 2 arguments the secret name
-    /// and value (base64) and returns a Promise.
+    /// See https://matrix-org.github.io/matrix-rust-sdk/matrix_sdk_crypto/store/struct.Store.html#method.secrets_stream for more information.
+    ///
+    /// `callback` should be a function that takes 2 arguments the secret name.
+    /// If the secret is valid and handled on the javascript side, the secret
+    /// inbox should be cleared by calling `delete_secrets_from_inbox`.
     #[wasm_bindgen(js_name = "registerReceiveSecretCallback")]
-    pub async fn register_secret_receive_callback(&self, callback: Function) {
+    pub async fn register_receive_secret_callback(&self, callback: Function) {
         let stream = self.inner.store().secrets_stream();
-        let store = self.inner.store().clone();
-        //fire up a promise chain which will call `cb` on each result from the stream
+        // fire up a promise chain which will call `callback` on each result from the
+        // stream
         spawn_local(async move {
-            let callback_ref = &callback;
             // Pin the stream to ensure it can be safely moved across threads
             pin_mut!(stream);
             while let Some(secret) = stream.next().await {
-                send_secret_gossip_to_callback(callback_ref, &secret).await;
-                let _ = store.delete_secrets_from_inbox(&secret.secret_name).await;
+                send_secret_gossip_to_callback(&callback, &secret).await;
             }
         });
     }
 
+    /// Get all the secrets with the given secret_name we have currently
+    /// stored.
+    ///
+    /// Usually you would just register a callback with
+    /// [`register_receive_secret_callback`], but if the clients is shutdown
+    /// before handling them, this method can be used to retrieve them.
+    ///
+    /// The secrets are guaranteed to have been received over a 1-to-1 encrypted
+    /// to_device message from a verified own device.
+    ///
+    /// Returns a `Promise` for a `Set` of `String` corresponding to the secret
+    /// values.
+    ///
+    /// If the secret is valid and handled, the secret inbox should be cleared
+    /// by calling `delete_secrets_from_inbox`.
+    #[wasm_bindgen(js_name = "getSecretsFromInbox")]
+    pub async fn get_secrets_from_inbox(&self, secret_name: String) -> Promise {
+        let set = Set::new(&JsValue::UNDEFINED);
+        let me = self.inner.clone();
+
+        future_to_promise(async move {
+            let name = SecretName::from(secret_name);
+            for gossip in me.store().get_secrets_from_inbox(&name).await? {
+                set.add(&JsValue::from_str(&gossip.event.content.secret));
+            }
+            Ok(set)
+        })
+    }
+
+    /// Delete all secrets with the given secret name from the inbox.
+    ///
+    /// Should be called after handling the secrets with
+    /// `get_secrets_from_inbox`.
+    ///
+    /// # Arguments
+    ///
+    /// * `secret_name` - The name of the secret to delete.
+    #[wasm_bindgen(js_name = "deleteSecretsFromInbox")]
+    pub async fn delete_secrets_from_inbox(&self, secret_name: String) -> Promise {
+        let me = self.inner.clone();
+        future_to_promise(async move {
+            let name = SecretName::from(secret_name);
+            me.store().delete_secrets_from_inbox(&name).await?;
+            Ok(JsValue::UNDEFINED)
+        })
+    }
+
     /// Shut down the `OlmMachine`.
     ///
     /// The `OlmMachine` cannot be used after this method has been called.
@@ -1156,6 +1217,8 @@ async fn send_user_identities_to_callback(
     }
 }
 
+// helper for register_secret_receive_callback: passes the secret name and value
+// into the javascript function
 async fn send_secret_gossip_to_callback(callback: &Function, secret: &GossippedSecret) {
     match promise_result_to_future(callback.call2(
         &JsValue::NULL,
@@ -1166,7 +1229,7 @@ async fn send_secret_gossip_to_callback(callback: &Function, secret: &GossippedS
     {
         Ok(_) => (),
         Err(e) => {
-            warn!("Error calling secret gossip send callback: {:?}", e);
+            warn!("Error calling receive secret callback: {:?}", e);
         }
     }
 }