POC state traits

Author: dani-garcia

Cargo.lock

@@ -28,6 +28,7 @@ wasm = [
 ] # WASM support
 
 [dependencies]
+async-trait = ">=0.1.80, <0.2"
 base64 = ">=0.22.1, <0.23"
 bitwarden-api-api = { workspace = true }
 bitwarden-api-identity = { workspace = true }

crates/bitwarden-core/Cargo.toml

@@ -82,6 +82,8 @@ impl Client {
                 })),
                 external_client,
                 key_store: KeyStore::default(),
+
+                cipher_store: RwLock::new(None),
             },
         }
     }

crates/bitwarden-core/src/client/client.rs

@@ -60,6 +60,8 @@ pub struct InternalClient {
     pub(crate) external_client: reqwest::Client,
 
     pub(super) key_store: KeyStore<KeyIds>,
+
+    pub(super) cipher_store: RwLock<Option<Arc<dyn CipherStore>>>,
 }
 
 impl InternalClient {
@@ -219,4 +221,27 @@ impl InternalClient {
     ) -> Result<(), EncryptionSettingsError> {
         EncryptionSettings::set_org_keys(org_keys, &self.key_store)
     }
+
+    pub fn register_cipher_store(&self, store: Arc<dyn CipherStore>) {
+        self.cipher_store
+            .write()
+            .expect("RwLock is not poisoned")
+            .replace(store);
+    }
+
+    pub fn get_cipher_store(&self) -> Option<Arc<dyn CipherStore>> {
+        self.cipher_store
+            .read()
+            .expect("RwLock is not poisoned")
+            .clone()
+    }
+}
+
+// TODO: We can't expose the store as returning a bitwarden_vault::Cipher to avoid a circular dependency, we'll fix that at some point somehow
+#[async_trait::async_trait]
+pub trait CipherStore: std::fmt::Debug + Send + Sync {
+    async fn get(&self, key: &str) -> Option<String>;
+    async fn list(&self) -> Vec<String>;
+    async fn set(&self, key: &str, value: String);
+    async fn remove(&self, key: &str);
 }

crates/bitwarden-core/src/client/internal.rs

@@ -32,6 +32,7 @@ chrono = { workspace = true, features = ["std"] }
 env_logger = "0.11.1"
 log = { workspace = true }
 schemars = { workspace = true, optional = true }
+serde_json = { workspace = true }
 thiserror = { workspace = true }
 uniffi = { workspace = true }
 uuid = { workspace = true }

crates/bitwarden-uniffi/Cargo.toml

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use bitwarden_core::platform::FingerprintRequest;
+use bitwarden_vault::Cipher;
 
 use crate::{
     error::{Error, Result},
@@ -44,4 +45,76 @@ impl PlatformClient {
     pub fn fido2(self: Arc<Self>) -> Arc<fido2::ClientFido2> {
         Arc::new(fido2::ClientFido2(self.0.clone()))
     }
+
+    pub fn store(self: Arc<Self>) -> StoreClient {
+        StoreClient(self.0.clone())
+    }
+}
+
+#[derive(uniffi::Object)]
+pub struct StoreClient(pub(crate) Arc<Client>);
+
+#[uniffi::export(with_foreign)]
+#[async_trait::async_trait]
+pub trait CipherStore: Send + Sync {
+    async fn get(&self, id: String) -> Option<Cipher>;
+    async fn list(&self) -> Vec<Cipher>;
+    async fn set(&self, id: String, value: Cipher);
+    async fn remove(&self, id: String);
+}
+
+impl<T> std::fmt::Debug for UniffiTraitBridge<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("UniffiTraitBridge").finish()
+    }
+}
+
+struct UniffiTraitBridge<T>(T);
+
+#[async_trait::async_trait]
+impl bitwarden_core::client::internal::CipherStore for UniffiTraitBridge<Arc<dyn CipherStore>> {
+    async fn get(&self, key: &str) -> Option<String> {
+        self.0
+            .get(key.to_string())
+            .await
+            .map(|cipher| serde_json::to_string(&cipher).expect("Failed to serialize cipher"))
+    }
+    async fn list(&self) -> Vec<String> {
+        self.0
+            .list()
+            .await
+            .into_iter()
+            .map(|cipher| serde_json::to_string(&cipher).expect("Failed to serialize cipher"))
+            .collect()
+    }
+    async fn set(&self, key: &str, value: String) {
+        self.0
+            .set(key.to_string(), serde_json::from_str(&value).expect("msg"))
+            .await
+    }
+    async fn remove(&self, key: &str) {
+        self.0.remove(key.to_string()).await
+    }
+}
+
+#[uniffi::export(async_runtime = "tokio")]
+impl StoreClient {
+    pub async fn print_the_ciphers(&self) -> String {
+        let store = self.0 .0.internal.get_cipher_store().expect("msg");
+        let mut result = String::new();
+        let ciphers = store.list().await;
+        for cipher in ciphers {
+            result.push_str(&cipher);
+            result.push('\n');
+        }
+        result
+    }
+
+    pub fn register_cipher_store(&self, store: Arc<dyn CipherStore>) -> Result<()> {
+        let store_internal: Arc<dyn bitwarden_core::client::internal::CipherStore> =
+            Arc::new(UniffiTraitBridge(store));
+
+        self.0 .0.internal.register_cipher_store(store_internal);
+        Ok(())
+    }
 }

crates/bitwarden-uniffi/src/platform/mod.rs

@@ -16,6 +16,7 @@ keywords.workspace = true
 crate-type = ["cdylib"]
 
 [dependencies]
+async-trait = ">=0.1.80, <0.2"
 bitwarden-core = { workspace = true, features = ["wasm", "internal"] }
 bitwarden-crypto = { workspace = true, features = ["wasm"] }
 bitwarden-error = { workspace = true }
@@ -28,6 +29,8 @@ console_log = { version = "1.0.0", features = ["color"] }
 js-sys = "0.3.68"
 log = "0.4.20"
 serde_json = ">=1.0.96, <2.0"
+tokio = { features = ["sync", "rt"], workspace = true }
+tsify-next = { workspace = true }
 # When upgrading wasm-bindgen, make sure to update the version in the workflows!
 wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
 wasm-bindgen-futures = "0.4.41"

crates/bitwarden-wasm-internal/Cargo.toml

@@ -1,8 +1,11 @@
 extern crate console_error_panic_hook;
-use std::{fmt::Display, rc::Rc};
+use std::{fmt::Display, rc::Rc, sync::Arc};
 
-use bitwarden_core::{Client, ClientSettings};
+use bitwarden_core::{client::internal::CipherStore, Client, ClientSettings};
 use bitwarden_error::bitwarden_error;
+use bitwarden_vault::Cipher;
+use js_sys::{Array, JsString, Promise};
+use tokio::sync::{mpsc, oneshot};
 use wasm_bindgen::prelude::*;
 
 use crate::{CryptoClient, VaultClient};
@@ -47,6 +50,10 @@ impl BitwardenClient {
     pub fn vault(&self) -> VaultClient {
         VaultClient::new(self.0.clone())
     }
+
+    pub fn store(&self) -> StoreClient {
+        StoreClient::new(self.0.clone())
+    }
 }
 
 #[bitwarden_error(basic)]
@@ -57,3 +64,160 @@ impl Display for TestError {
         write!(f, "{}", self.0)
     }
 }
+
+#[wasm_bindgen]
+pub struct StoreClient(Rc<Client>);
+
+impl StoreClient {
+    pub fn new(client: Rc<Client>) -> Self {
+        Self(client)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ChannelCipherStore {
+    sender: mpsc::Sender<StoreCommand>,
+}
+
+pub enum StoreCommand {
+    Get {
+        id: String,
+        respond_to: oneshot::Sender<Option<String>>,
+    },
+    List {
+        respond_to: oneshot::Sender<Vec<String>>,
+    },
+    Set {
+        id: String,
+        value: String,
+    },
+    Remove {
+        id: String,
+    },
+}
+
+#[async_trait::async_trait]
+impl CipherStore for ChannelCipherStore {
+    async fn get(&self, id: &str) -> Option<String> {
+        let (tx, rx) = oneshot::channel();
+        let cmd = StoreCommand::Get {
+            id: id.to_string(),
+            respond_to: tx,
+        };
+        let _ = self.sender.send(cmd).await;
+        rx.await.expect("")
+    }
+
+    async fn list(&self) -> Vec<String> {
+        let (tx, rx) = oneshot::channel();
+        let cmd = StoreCommand::List { respond_to: tx };
+        let _ = self.sender.send(cmd).await;
+        rx.await.expect("")
+    }
+
+    async fn set(&self, id: &str, value: String) {
+        let cmd = StoreCommand::Set {
+            id: id.to_string(),
+            value,
+        };
+        self.sender.send(cmd).await.expect("");
+    }
+
+    async fn remove(&self, id: &str) {
+        let cmd = StoreCommand::Remove { id: id.to_string() };
+        self.sender.send(cmd).await.expect("");
+    }
+}
+
+#[wasm_bindgen(typescript_custom_section)]
+const CIPHER_STORE_CUSTOM_TS_TYPE: &'static str = r#"
+export interface CipherStore {
+    get(id: string): Promise<string | null>;
+    list(): Promise<string[]>;
+    set(id: string, value: string): Promise<void>;
+    remove(id: string): Promise<void>;
+}
+"#;
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_name = CipherStore, typescript_type = "CipherStore")]
+    pub type JSCipherStore;
+
+    #[wasm_bindgen(method)]
+    async fn get(this: &JSCipherStore, id: String) -> JsValue;
+
+    #[wasm_bindgen(method)]
+    async fn list(this: &JSCipherStore) -> Array;
+
+    #[wasm_bindgen(method)]
+    async fn set(this: &JSCipherStore, id: String, value: String);
+
+    #[wasm_bindgen(method)]
+    async fn remove(this: &JSCipherStore, id: String);
+}
+
+#[wasm_bindgen]
+impl StoreClient {
+    pub async fn print_the_ciphers(&self) -> String {
+        let store = self.0.internal.get_cipher_store().expect("msg");
+        let mut result = String::new();
+        let ciphers = store.list().await;
+        for cipher in ciphers {
+            result.push_str(&cipher);
+            result.push('\n');
+        }
+        result
+    }
+
+    pub fn register_cipher_store(
+        &self,
+        store: JSCipherStore,
+        //  get: js_sys::Function,
+        //  list: js_sys::Function,
+        //  save: js_sys::Function,
+        //  delete: js_sys::Function,
+    ) {
+        let (tx, mut rx) = mpsc::channel::<StoreCommand>(32);
+
+        wasm_bindgen_futures::spawn_local(async move {
+            fn resolve_value(val: JsValue) -> Option<JsValue> {
+                if val.is_null() || val.is_undefined() {
+                    None
+                } else {
+                    Some(val)
+                }
+            }
+
+            while let Some(cmd) = rx.recv().await {
+                match cmd {
+                    StoreCommand::Get { id, respond_to } => {
+                        let result = store.get(id).await;
+                        let result = resolve_value(result).map(|v| v.try_into().expect(""));
+                        let _ = respond_to.send(result);
+                    }
+                    StoreCommand::List { respond_to } => {
+                        let result = store.list().await;
+
+                        let result: Vec<String> = result
+                            .into_iter()
+                            .map(|v| v.as_string().expect("msg"))
+                            .collect();
+
+                        let _ = respond_to.send(result);
+                    }
+                    StoreCommand::Set { id, value } => {
+                        store.set(id, value).await;
+                    }
+                    StoreCommand::Remove { id } => {
+                        store.remove(id).await;
+                    }
+                }
+            }
+        });
+
+        let store = ChannelCipherStore { sender: tx };
+
+        self.0.internal.register_cipher_store(Arc::new(store));
+    }
+}