Move everything to a separate crate

dani-garcia · dani-garcia · commit 546737a68f84 · 2025-06-05T19:02:30.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -31,6 +31,7 @@ bitwarden-fido = { path = "crates/bitwarden-fido", version = "=1.0.0" }
 bitwarden-generators = { path = "crates/bitwarden-generators", version = "=1.0.0" }
 bitwarden-ipc = { path = "crates/bitwarden-ipc", version = "=1.0.0" }
 bitwarden-send = { path = "crates/bitwarden-send", version = "=1.0.0" }
+bitwarden-state = { path = "crates/bitwarden-state", version = "=1.0.0" }
 bitwarden-threading = { path = "crates/bitwarden-threading", version = "=1.0.0" }
 bitwarden-sm = { path = "bitwarden_license/bitwarden-sm", version = "=1.0.0" }
 bitwarden-ssh = { path = "crates/bitwarden-ssh", version = "=1.0.0" }
@@ -39,6 +40,7 @@ bitwarden-uuid-macro = { path = "crates/bitwarden-uuid-macro", version = "=1.0.0
 bitwarden-vault = { path = "crates/bitwarden-vault", version = "=1.0.0" }
 
 # External crates that are expected to maintain a consistent version across all crates
+async-trait = ">=0.1.80, <0.2"
 chrono = { version = ">=0.4.26, <0.5", features = [
     "clock",
     "serde",
diff --git a/crates/bitwarden-core/Cargo.toml b/crates/bitwarden-core/Cargo.toml
@@ -28,12 +28,12 @@ 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 }
 bitwarden-crypto = { workspace = true }
 bitwarden-error = { workspace = true }
+bitwarden-state = { workspace = true }
 bitwarden-uuid = { workspace = true }
 chrono = { workspace = true, features = ["std"] }
 # We don't use this directly (it's used by rand), but we need it here to enable WASM support
diff --git a/crates/bitwarden-core/src/client/client.rs b/crates/bitwarden-core/src/client/client.rs
@@ -1,6 +1,8 @@
 use std::sync::{Arc, OnceLock, RwLock};
 
 use bitwarden_crypto::KeyStore;
+#[cfg(feature = "internal")]
+use bitwarden_state::repository::RepositoryMap;
 use reqwest::header::{self, HeaderValue};
 
 use super::internal::InternalClient;
@@ -9,7 +11,6 @@ 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.
diff --git a/crates/bitwarden-core/src/client/internal.rs b/crates/bitwarden-core/src/client/internal.rs
@@ -5,6 +5,8 @@ use bitwarden_crypto::KeyStore;
 use bitwarden_crypto::SymmetricCryptoKey;
 #[cfg(feature = "internal")]
 use bitwarden_crypto::{EncString, Kdf, MasterKey, PinKey, UnsignedSharedKey};
+#[cfg(feature = "internal")]
+use bitwarden_state::repository::RepositoryMap;
 use chrono::Utc;
 use uuid::Uuid;
 
@@ -19,7 +21,6 @@ use crate::{
 #[cfg(feature = "internal")]
 use crate::{
     client::encryption_settings::EncryptionSettingsError,
-    client::repository::{Repository, RepositoryMap},
     client::{flags::Flags, login_method::UserLoginMethod},
     error::NotAuthenticatedError,
 };
@@ -66,7 +67,7 @@ pub struct InternalClient {
     pub(super) key_store: KeyStore<KeyIds>,
 
     #[cfg(feature = "internal")]
-    pub(super) repository_map: RwLock<RepositoryMap>,
+    pub(crate) repository_map: RwLock<RepositoryMap>,
 }
 
 impl InternalClient {
@@ -249,20 +250,4 @@ 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()
-    }
 }
diff --git a/crates/bitwarden-core/src/client/mod.rs b/crates/bitwarden-core/src/client/mod.rs
@@ -23,6 +23,3 @@ pub use client_settings::{ClientSettings, DeviceType};
 #[allow(missing_docs)]
 #[cfg(feature = "internal")]
 pub mod test_accounts;
-
-#[cfg(feature = "internal")]
-pub mod repository;
diff --git a/crates/bitwarden-core/src/platform/mod.rs b/crates/bitwarden-core/src/platform/mod.rs
@@ -6,6 +6,7 @@ mod generate_fingerprint;
 mod get_user_api_key;
 mod platform_client;
 mod secret_verification_request;
+mod state_client;
 
 pub use generate_fingerprint::{
     FingerprintError, FingerprintRequest, FingerprintResponse, UserFingerprintError,
@@ -14,3 +15,4 @@ pub(crate) use get_user_api_key::get_user_api_key;
 pub use get_user_api_key::{UserApiKeyError, UserApiKeyResponse};
 pub use platform_client::PlatformClient;
 pub use secret_verification_request::SecretVerificationRequest;
+pub use state_client::StateClient;
diff --git a/crates/bitwarden-core/src/platform/platform_client.rs b/crates/bitwarden-core/src/platform/platform_client.rs
@@ -33,6 +33,13 @@ impl PlatformClient {
     ) -> Result<UserApiKeyResponse, UserApiKeyError> {
         get_user_api_key(&self.client, &input).await
     }
+
+    /// Access to state functionality.
+    pub fn state(&self) -> super::StateClient {
+        super::StateClient {
+            client: self.client.clone(),
+        }
+    }
 }
 
 impl Client {
diff --git a/crates/bitwarden-core/src/platform/state_client.rs b/crates/bitwarden-core/src/platform/state_client.rs
@@ -0,0 +1,32 @@
+use std::sync::Arc;
+
+use bitwarden_state::repository::Repository;
+
+use crate::Client;
+
+/// Wrapper for state specific functionality.
+pub struct StateClient {
+    pub(crate) client: Client,
+}
+
+impl StateClient {
+    /// Register a client managed state repository for a specific type.
+    pub fn register_repository<T: 'static + Repository<V>, V: 'static>(&self, store: Arc<T>) {
+        self.client
+            .internal
+            .repository_map
+            .write()
+            .expect("RwLock is not poisoned")
+            .insert(store);
+    }
+
+    /// Get a client managed state repository for a specific type, if it exists.
+    pub fn get_repository<T: 'static>(&self) -> Option<Arc<dyn Repository<T>>> {
+        self.client
+            .internal
+            .repository_map
+            .read()
+            .expect("RwLock is not poisoned")
+            .get()
+    }
+}
diff --git a/crates/bitwarden-fido/Cargo.toml b/crates/bitwarden-fido/Cargo.toml
@@ -18,7 +18,7 @@ keywords.workspace = true
 uniffi = ["dep:uniffi", "bitwarden-core/uniffi", "bitwarden-vault/uniffi"]
 
 [dependencies]
-async-trait = ">=0.1.80, <0.2"
+async-trait = { workspace = true }
 base64 = ">=0.22.1, <0.23"
 bitwarden-core = { workspace = true }
 bitwarden-crypto = { workspace = true }
diff --git a/crates/bitwarden-state/Cargo.toml b/crates/bitwarden-state/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "bitwarden-state"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+homepage.workspace = true
+repository.workspace = true
+license-file.workspace = true
+keywords.workspace = true
+
+[features]
+uniffi = []
+wasm = []
+
+[dependencies]
+async-trait = { workspace = true }
+bitwarden-error = { workspace = true }
+log = { workspace = true }
+serde = { workspace = true }
+thiserror = { workspace = true }
+tokio = { features = ["sync", "time", "rt"], workspace = true }
+tokio-util = { version = "0.7.15" }
+
+[target.'cfg(target_arch="wasm32")'.dependencies]
+gloo-timers = { version = "0.3.0", features = ["futures"] }
+js-sys = { workspace = true }
+tsify-next = { workspace = true }
+wasm-bindgen = { workspace = true }
+wasm-bindgen-futures = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/crates/bitwarden-state/README.md b/crates/bitwarden-state/README.md
@@ -0,0 +1 @@
+# bitwarden-state
diff --git a/crates/bitwarden-state/src/lib.rs b/crates/bitwarden-state/src/lib.rs
@@ -0,0 +1,4 @@
+#![doc = include_str!("../README.md")]
+
+/// This module provides a generic repository interface for storing and retrieving items.
+pub mod repository;
diff --git a/crates/bitwarden-state/src/repository.rs b/crates/bitwarden-state/src/repository.rs
@@ -4,20 +4,45 @@ use std::{
     sync::Arc,
 };
 
+/// An error resulting from operations on a repository.
 #[derive(thiserror::Error, Debug)]
 pub enum RepositoryError {
+    /// An internal unspecified error.
     #[error("Internal error: {0}")]
     Internal(String),
 }
 
+/// This trait is used to mark types that can be stored in a repository.
+/// It provides a method to retrieve the `TypeId` of the type, which is used to
+/// differentiate between different types of entries in the repository.
+pub trait RepositoryItem: 'static {
+    /// Returns the `TypeId` of the type implementing this trait.
+    fn type_id(&self) -> TypeId {
+        TypeId::of::<Self>()
+    }
+
+    /// Returns the name of the type implementing this trait.
+    fn name(&self) -> &'static str {
+        std::any::type_name::<Self>()
+    }
+}
+
+/// This trait represents a generic repository interface, capable of storing and retrieving
+/// items using a key-value API.
 #[async_trait::async_trait]
 pub trait Repository<T>: Send + Sync {
+    /// Retrieves an item from the repository by its key.
     async fn get(&self, key: String) -> Result<Option<T>, RepositoryError>;
+    /// Lists all items in the repository.
     async fn list(&self) -> Result<Vec<T>, RepositoryError>;
+    /// Sets an item in the repository with the specified key.
     async fn set(&self, key: String, value: T) -> Result<(), RepositoryError>;
+    /// Removes an item from the repository by its key.
     async fn remove(&self, key: String) -> Result<(), RepositoryError>;
 }
 
+/// A map that holds repositories for different types, allowing for dynamic retrieval
+/// based on type identifiers.
 #[derive(Default)]
 pub struct RepositoryMap {
     stores: HashMap<TypeId, Box<dyn Any + Send + Sync>>,
@@ -32,16 +57,19 @@ impl std::fmt::Debug for RepositoryMap {
 }
 
 impl RepositoryMap {
+    /// Creates a new empty `RepositoryMap`.
     pub fn new() -> Self {
         RepositoryMap {
             stores: HashMap::new(),
         }
     }
 
+    /// Inserts a repository into the map, associating it with its type.
     pub fn insert<T: 'static>(&mut self, value: Arc<dyn Repository<T>>) {
         self.stores.insert(TypeId::of::<T>(), Box::new(value));
     }
 
+    /// Retrieves a repository from the map given its type.
     pub fn get<T: 'static>(&self) -> Option<Arc<dyn Repository<T>>> {
         self.stores
             .get(&TypeId::of::<T>())
diff --git a/crates/bitwarden-threading/Cargo.toml b/crates/bitwarden-threading/Cargo.toml
@@ -25,7 +25,7 @@ wasm-bindgen = { workspace = true }
 wasm-bindgen-futures = { workspace = true }
 
 [dev-dependencies]
-async-trait = "0.1.88"
+async-trait = { workspace = true }
 console_error_panic_hook = "0.1.7"
 js-sys = { workspace = true }
 tsify-next = { workspace = true }
diff --git a/crates/bitwarden-uniffi/Cargo.toml b/crates/bitwarden-uniffi/Cargo.toml
@@ -19,14 +19,15 @@ crate-type = ["lib", "staticlib", "cdylib"]
 bench = false
 
 [dependencies]
-async-trait = "0.1.80"
+async-trait = { workspace = true }
 bitwarden-core = { workspace = true, features = ["uniffi"] }
 bitwarden-crypto = { workspace = true, features = ["uniffi"] }
 bitwarden-exporters = { workspace = true, features = ["uniffi"] }
 bitwarden-fido = { workspace = true, features = ["uniffi"] }
 bitwarden-generators = { workspace = true, features = ["uniffi"] }
 bitwarden-send = { workspace = true, features = ["uniffi"] }
 bitwarden-ssh = { workspace = true, features = ["uniffi"] }
+bitwarden-state = { workspace = true, features = ["uniffi"] }
 bitwarden-vault = { workspace = true, features = ["uniffi"] }
 chrono = { workspace = true, features = ["std"] }
 env_logger = "0.11.1"
diff --git a/crates/bitwarden-uniffi/src/platform/mod.rs b/crates/bitwarden-uniffi/src/platform/mod.rs
@@ -44,21 +44,24 @@ impl PlatformClient {
         fido2::ClientFido2(self.0.fido2())
     }
 
-    pub fn repository(&self) -> RepositoryClient {
-        RepositoryClient(self.0.clone())
+    pub fn state(&self) -> StateClient {
+        StateClient(self.0.clone())
     }
 }
 
 #[derive(uniffi::Object)]
-pub struct RepositoryClient(Client);
+pub struct StateClient(Client);
 
 repository::create_uniffi_repository!(CipherRepository, Cipher);
 
 #[uniffi::export]
-impl RepositoryClient {
+impl StateClient {
     pub fn register_cipher_repository(&self, store: Arc<dyn CipherRepository>) -> Result<()> {
         let store_internal = UniffiRepositoryBridge::new(store);
-        self.0.internal.register_repository(store_internal);
+        self.0
+            .platform()
+            .state()
+            .register_repository(store_internal);
         Ok(())
     }
 }
diff --git a/crates/bitwarden-uniffi/src/platform/repository.rs b/crates/bitwarden-uniffi/src/platform/repository.rs
diff --git a/crates/bitwarden-vault/src/vault_client.rs b/crates/bitwarden-vault/src/vault_client.rs
diff --git a/crates/bitwarden-wasm-internal/Cargo.toml b/crates/bitwarden-wasm-internal/Cargo.toml
diff --git a/crates/bitwarden-wasm-internal/src/client.rs b/crates/bitwarden-wasm-internal/src/client.rs
diff --git a/crates/bitwarden-wasm-internal/src/platform/mod.rs b/crates/bitwarden-wasm-internal/src/platform/mod.rs
diff --git a/crates/bitwarden-wasm-internal/src/platform/repository.rs b/crates/bitwarden-wasm-internal/src/platform/repository.rs

Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,13 @@ impl PlatformClient {`
`33`	`33`	`) -> Result<UserApiKeyResponse, UserApiKeyError> {`
`34`	`34`	`get_user_api_key(&self.client, &input).await`
`35`	`35`	`}`
	`36`	`+`
	`37`	`+ /// Access to state functionality.`
	`38`	`+ pub fn state(&self) -> super::StateClient {`
	`39`	`+ super::StateClient {`
	`40`	`+ client: self.client.clone(),`
	`41`	`+ }`
	`42`	`+ }`
`36`	`43`	`}`
`37`	`44`
`38`	`45`	`impl Client {`