Add generic repository support

Implement demo cipher repository

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

@@ -9,6 +9,7 @@ use crate::client::flags::Flags;
 use crate::client::{
     client_settings::ClientSettings,
     internal::{ApiConfigurations, Tokens},
+    repository::RepositoryMap,
 };
 
 /// The main struct to interact with the Bitwarden SDK.
@@ -86,6 +87,8 @@ impl Client {
                 })),
                 external_client,
                 key_store: KeyStore::default(),
+                #[cfg(feature = "internal")]
+                repository_map: RwLock::new(RepositoryMap::default()),
             }),
         }
     }

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

@@ -19,6 +19,7 @@ use crate::{
 #[cfg(feature = "internal")]
 use crate::{
     client::encryption_settings::EncryptionSettingsError,
+    client::repository::{Repository, RepositoryMap},
     client::{flags::Flags, login_method::UserLoginMethod},
     error::NotAuthenticatedError,
 };
@@ -60,6 +61,9 @@ pub struct InternalClient {
     pub(crate) external_client: reqwest::Client,
 
     pub(super) key_store: KeyStore<KeyIds>,
+
+    #[cfg(feature = "internal")]
+    pub(super) repository_map: RwLock<RepositoryMap>,
 }
 
 impl InternalClient {
@@ -223,4 +227,20 @@ impl InternalClient {
     ) -> Result<(), EncryptionSettingsError> {
         EncryptionSettings::set_org_keys(org_keys, &self.key_store)
     }
+
+    #[cfg(feature = "internal")]
+    pub fn register_repository<T: 'static + Repository<V>, V: 'static>(&self, store: Arc<T>) {
+        self.repository_map
+            .write()
+            .expect("RwLock is not poisoned")
+            .insert(store);
+    }
+
+    #[cfg(feature = "internal")]
+    pub fn get_repository<T: 'static>(&self) -> Option<Arc<dyn Repository<T>>> {
+        self.repository_map
+            .read()
+            .expect("RwLock is not poisoned")
+            .get()
+    }
 }

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

@@ -18,3 +18,6 @@ pub use client_settings::{ClientSettings, DeviceType};
 
 #[cfg(feature = "internal")]
 pub mod test_accounts;
+
+#[cfg(feature = "internal")]
+pub mod repository;

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

@@ -0,0 +1,119 @@
+use std::{
+    any::{Any, TypeId},
+    collections::HashMap,
+    sync::Arc,
+};
+
+#[derive(thiserror::Error, Debug)]
+pub enum RepositoryError {
+    #[error("Internal error: {0}")]
+    Internal(String),
+}
+
+#[async_trait::async_trait]
+pub trait Repository<T>: Send + Sync {
+    async fn get(&self, key: String) -> Result<Option<T>, RepositoryError>;
+    async fn list(&self) -> Result<Vec<T>, RepositoryError>;
+    async fn set(&self, key: String, value: T) -> Result<(), RepositoryError>;
+    async fn remove(&self, key: String) -> Result<(), RepositoryError>;
+}
+
+#[derive(Default)]
+pub struct RepositoryMap {
+    stores: HashMap<TypeId, Box<dyn Any + Send + Sync>>,
+}
+
+impl std::fmt::Debug for RepositoryMap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RepositoryMap")
+            .field("stores", &self.stores.keys())
+            .finish()
+    }
+}
+
+impl RepositoryMap {
+    pub fn new() -> Self {
+        RepositoryMap {
+            stores: HashMap::new(),
+        }
+    }
+
+    pub fn insert<T: 'static>(&mut self, value: Arc<dyn Repository<T>>) {
+        self.stores.insert(TypeId::of::<T>(), Box::new(value));
+    }
+
+    pub fn get<T: 'static>(&self) -> Option<Arc<dyn Repository<T>>> {
+        self.stores
+            .get(&TypeId::of::<T>())
+            .and_then(|boxed| boxed.downcast_ref::<Arc<dyn Repository<T>>>())
+            .map(Arc::clone)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    macro_rules! impl_repository {
+        ($name:ident, $ty:ty) => {
+            #[async_trait::async_trait]
+            impl Repository<$ty> for $name {
+                async fn get(&self, _key: String) -> Result<Option<$ty>, RepositoryError> {
+                    Ok(Some(self.0.clone()))
+                }
+                async fn list(&self) -> Result<Vec<$ty>, RepositoryError> {
+                    unimplemented!()
+                }
+                async fn set(&self, _key: String, _value: $ty) -> Result<(), RepositoryError> {
+                    unimplemented!()
+                }
+                async fn remove(&self, _key: String) -> Result<(), RepositoryError> {
+                    unimplemented!()
+                }
+            }
+        };
+    }
+
+    #[derive(PartialEq, Eq, Debug)]
+    struct TestA(usize);
+    #[derive(PartialEq, Eq, Debug)]
+    struct TestB(String);
+    #[derive(PartialEq, Eq, Debug)]
+    struct TestC(Vec<u8>);
+
+    impl_repository!(TestA, usize);
+    impl_repository!(TestB, String);
+    impl_repository!(TestC, Vec<u8>);
+
+    #[tokio::test]
+    async fn test_repository_map() {
+        let a = Arc::new(TestA(145832));
+        let b = Arc::new(TestB("test".to_string()));
+        let c = Arc::new(TestC(vec![1, 2, 3, 4, 5, 6, 7, 8, 9]));
+
+        let mut map = RepositoryMap::new();
+
+        async fn get<T: 'static>(map: &RepositoryMap) -> Option<T> {
+            map.get::<T>().unwrap().get(String::new()).await.unwrap()
+        }
+
+        assert!(map.get::<usize>().is_none());
+        assert!(map.get::<String>().is_none());
+        assert!(map.get::<Vec<u8>>().is_none());
+
+        map.insert(a.clone());
+        assert_eq!(get(&map).await, Some(a.0));
+        assert!(map.get::<String>().is_none());
+        assert!(map.get::<Vec<u8>>().is_none());
+
+        map.insert(b.clone());
+        assert_eq!(get(&map).await, Some(a.0));
+        assert_eq!(get(&map).await, Some(b.0.clone()));
+        assert!(map.get::<Vec<u8>>().is_none());
+
+        map.insert(c.clone());
+        assert_eq!(get(&map).await, Some(a.0));
+        assert_eq!(get(&map).await, Some(b.0.clone()));
+        assert_eq!(get(&map).await, Some(c.0.clone()));
+    }
+}

crates/bitwarden-core/src/client/repository.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,9 +1,14 @@
-use bitwarden_core::platform::FingerprintRequest;
+use std::sync::Arc;
+
+use bitwarden_core::{platform::FingerprintRequest, Client};
 use bitwarden_fido::ClientFido2Ext;
+use bitwarden_vault::Cipher;
+use repository::UniffiRepositoryBridge;
 
 use crate::error::{Error, Result};
 
 mod fido2;
+mod repository;
 
 #[derive(uniffi::Object)]
 pub struct PlatformClient(pub(crate) bitwarden_core::Client);
@@ -38,4 +43,22 @@ impl PlatformClient {
     pub fn fido2(&self) -> fido2::ClientFido2 {
         fido2::ClientFido2(self.0.fido2())
     }
+
+    pub fn repository(&self) -> RepositoryClient {
+        RepositoryClient(self.0.clone())
+    }
+}
+
+#[derive(uniffi::Object)]
+pub struct RepositoryClient(Client);
+
+repository::create_uniffi_repository!(CipherRepository, Cipher);
+
+#[uniffi::export]
+impl RepositoryClient {
+    pub fn register_cipher_repository(&self, store: Arc<dyn CipherRepository>) -> Result<()> {
+        let store_internal = UniffiRepositoryBridge::new(store);
+        self.0.internal.register_repository(store_internal);
+        Ok(())
+    }
 }

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

@@ -0,0 +1,104 @@
+use std::sync::Arc;
+
+pub struct UniffiRepositoryBridge<T>(pub T);
+
+impl<T: ?Sized> UniffiRepositoryBridge<Arc<T>> {
+    pub fn new(store: Arc<T>) -> Arc<Self> {
+        Arc::new(UniffiRepositoryBridge(store))
+    }
+}
+
+impl<T: std::fmt::Debug> std::fmt::Debug for UniffiRepositoryBridge<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+#[derive(uniffi::Error, thiserror::Error, Debug)]
+#[uniffi(flat_error)]
+pub enum RepositoryError {
+    #[error("Internal error: {0}")]
+    Internal(String),
+}
+
+// Need to implement this From<> impl in order to handle unexpected callback errors.  See the
+// following page in the Uniffi user guide:
+// <https://mozilla.github.io/uniffi-rs/foreign_traits.html#error-handling>
+impl From<uniffi::UnexpectedUniFFICallbackError> for RepositoryError {
+    fn from(e: uniffi::UnexpectedUniFFICallbackError) -> Self {
+        Self::Internal(e.reason)
+    }
+}
+
+impl From<RepositoryError> for bitwarden_core::client::repository::RepositoryError {
+    fn from(e: RepositoryError) -> Self {
+        match e {
+            RepositoryError::Internal(msg) => Self::Internal(msg),
+        }
+    }
+}
+
+macro_rules! create_uniffi_repository {
+    ($name:ident, $ty:ty) => {
+        #[uniffi::export(with_foreign)]
+        #[async_trait::async_trait]
+        pub trait $name: Send + Sync {
+            async fn get(
+                &self,
+                id: String,
+            ) -> Result<Option<$ty>, $crate::platform::repository::RepositoryError>;
+            async fn list(&self)
+                -> Result<Vec<$ty>, $crate::platform::repository::RepositoryError>;
+            async fn set(
+                &self,
+                id: String,
+                value: $ty,
+            ) -> Result<(), $crate::platform::repository::RepositoryError>;
+            async fn remove(
+                &self,
+                id: String,
+            ) -> Result<(), $crate::platform::repository::RepositoryError>;
+
+            async fn has(
+                &self,
+                id: String,
+            ) -> Result<bool, $crate::platform::repository::RepositoryError> {
+                match self.get(id).await {
+                    Ok(x) => Ok(x.is_some()),
+                    Err(e) => Err(e),
+                }
+            }
+        }
+
+        #[async_trait::async_trait]
+        impl bitwarden_core::client::repository::Repository<$ty>
+            for $crate::platform::repository::UniffiRepositoryBridge<Arc<dyn $name>>
+        {
+            async fn get(
+                &self,
+                key: String,
+            ) -> Result<Option<$ty>, bitwarden_core::client::repository::RepositoryError> {
+                self.0.get(key).await.map_err(Into::into)
+            }
+            async fn list(
+                &self,
+            ) -> Result<Vec<$ty>, bitwarden_core::client::repository::RepositoryError> {
+                self.0.list().await.map_err(Into::into)
+            }
+            async fn set(
+                &self,
+                key: String,
+                value: $ty,
+            ) -> Result<(), bitwarden_core::client::repository::RepositoryError> {
+                self.0.set(key, value).await.map_err(Into::into)
+            }
+            async fn remove(
+                &self,
+                key: String,
+            ) -> Result<(), bitwarden_core::client::repository::RepositoryError> {
+                self.0.remove(key).await.map_err(Into::into)
+            }
+        }
+    };
+}
+pub(super) use create_uniffi_repository;

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

@@ -60,4 +60,8 @@ impl VaultClient {
             .generate_totp_cipher_view(view, time)
             .map_err(Error::Totp)?)
     }
+
+    pub async fn print_the_ciphers(&self) -> String {
+        self.0.print_the_ciphers().await
+    }
 }