Implement demo cipher store

Author: dani-garcia

Cargo.lock

@@ -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,5 +1,8 @@
-use bitwarden_core::platform::FingerprintRequest;
+use std::sync::Arc;
+
+use bitwarden_core::{platform::FingerprintRequest, Client};
 use bitwarden_fido::ClientFido2Ext;
+use bitwarden_vault::Cipher;
 
 use crate::error::{Error, Result};
 
@@ -38,4 +41,66 @@ impl PlatformClient {
     pub fn fido2(&self) -> fido2::ClientFido2 {
         fido2::ClientFido2(self.0.fido2())
     }
+
+    pub fn store(&self) -> StoreClient {
+        StoreClient(self.0.clone())
+    }
+}
+
+#[derive(uniffi::Object)]
+pub struct StoreClient(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::data_store::DataStore<Cipher>
+    for UniffiTraitBridge<Arc<dyn CipherStore>>
+{
+    async fn get(&self, key: String) -> Option<Cipher> {
+        self.0.get(key).await
+    }
+    async fn list(&self) -> Vec<Cipher> {
+        self.0.list().await
+    }
+    async fn set(&self, key: String, value: Cipher) {
+        self.0.set(key, value).await
+    }
+    async fn remove(&self, key: String) {
+        self.0.remove(key).await
+    }
+}
+
+#[uniffi::export(async_runtime = "tokio")]
+impl StoreClient {
+    pub async fn print_the_ciphers(&self) -> String {
+        let store = self.0.internal.get_data_store::<Cipher>().expect("msg");
+        let mut result = String::new();
+        let ciphers = store.list().await;
+        for cipher in ciphers {
+            result.push_str(&serde_json::to_string(&cipher).expect("msg"));
+            result.push('\n');
+        }
+        result
+    }
+
+    pub fn register_cipher_store(&self, store: Arc<dyn CipherStore>) -> Result<()> {
+        let store_internal = Arc::new(UniffiTraitBridge(store));
+        self.0.internal.register_data_store(store_internal);
+        Ok(())
+    }
 }

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

@@ -16,9 +16,11 @@ 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 }
+bitwarden-ffi-macros = { workspace = true }
 bitwarden-generators = { workspace = true, features = ["wasm"] }
 bitwarden-ipc = { workspace = true, features = ["wasm"] }
 bitwarden-ssh = { workspace = true, features = ["wasm"] }
@@ -29,6 +31,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,9 +1,12 @@
 extern crate console_error_panic_hook;
-use std::fmt::Display;
+use std::{fmt::Display, sync::Arc};
 
-use bitwarden_core::{Client, ClientSettings};
+use bitwarden_core::{client::data_store::DataStore, Client, ClientSettings};
 use bitwarden_error::bitwarden_error;
+use bitwarden_vault::Cipher;
 use bitwarden_vault::VaultClientExt;
+use tokio::sync::mpsc;
+use tsify_next::serde_wasm_bindgen;
 use wasm_bindgen::prelude::*;
 
 use crate::{CryptoClient, GeneratorClient, VaultClient};
@@ -51,6 +54,10 @@ impl BitwardenClient {
     pub fn generator(&self) -> GeneratorClient {
         GeneratorClient::new(self.0.clone())
     }
+
+    pub fn store(&self) -> StoreClient {
+        StoreClient::new(self.0.clone())
+    }
 }
 
 #[bitwarden_error(basic)]
@@ -61,3 +68,60 @@ impl Display for TestError {
         write!(f, "{}", self.0)
     }
 }
+
+#[wasm_bindgen]
+pub struct StoreClient(Client);
+
+impl StoreClient {
+    pub fn new(client: Client) -> Self {
+        Self(client)
+    }
+}
+
+#[wasm_bindgen(typescript_custom_section)]
+const CIPHER_STORE_CUSTOM_TS_TYPE: &'static str = r#"
+export interface CipherStore {
+    get(id: string): Promise<Cipher | null>;
+    list(): Promise<Cipher[]>;
+    set(id: string, value: Cipher): Promise<void>;
+    remove(id: string): Promise<void>;
+}
+"#;
+
+#[bitwarden_ffi_macros::extern_wasm_channel(trait_impl = "DataStore<Cipher>", async_trait = true)]
+#[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) -> Option<Cipher>;
+
+    #[wasm_bindgen(method)]
+    async fn list(this: &JSCipherStore) -> Vec<Cipher>;
+
+    #[wasm_bindgen(method)]
+    async fn set(this: &JSCipherStore, id: String, value: Cipher);
+
+    #[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_data_store::<Cipher>().expect("msg");
+        let mut result = String::new();
+        let ciphers = store.list().await;
+        for cipher in ciphers {
+            result.push_str(format!("{:?}", cipher).as_str());
+            result.push('\n');
+        }
+        result
+    }
+
+    pub fn register_cipher_store(&self, store: JSCipherStore) {
+        let store = store.create_channel_impl();
+        self.0.internal.register_data_store(Arc::new(store));
+    }
+}