[PM-19479] Client-managed Repository traits (#213)

## 🎟️ Tracking

https://bitwarden.atlassian.net/browse/PM-19479

## 📔 Objective

Implement a generic trait for accessing the client application's data
storage directly. Because we want the store access to be typed, but
`bitwarden_core` isn't aware of the models, `bitwarden_core` only
implements a generic way to set and retrieve generic `impl
Repository<T>` instances, somewhat like dependency injection. Then it's
up to each team/feature crates to define which models and which stores
are available.

This feature is created in a new `bitwarden-state`, which will be
expanded by a separate PR with the addition of SDK-managed state
(Sqlite+IndexedDB). At the moment this crate contains:
- A `Repository` trait which will be implemented by the clients (and the
SDK in the future), and a `RepositoryItem` marker trait which will be
used to mark which models are meant to be used with the repositories.
- A `StateRegistry` which stores all the client-managed Repositories,
and in the future will also handle the SDK-managed repositories.
- A new `StateClient` subclient under platform that will be used by the
applications to register their Repositories. Both the WASM and UniFFI
crates also need some conversion code to implement the `Repository`
traits. I've tried to simplify it as much as possible, and hide it
behind a macro when that wasn't possible.

Some limitations on the current design:
- The current integration with web clients requires the State Provider
definition to be `UserKeyDefinition<Record<string, T>>` to match the
key-value pattern in `Repository`. This usually matches with what is
being used for vault (encrypted ciphers/folders, etc), but it might fall
short on other domains, like profile data, or user keys.
- There's no great way of ensuring that all the client-managed
Repositories have been registered, other than keeping a list. I've tried
to use the `inventory` crate to keep a global list of all the existing
implementations and then validating that they've all been registered,
but that doesn't work for WASM. We might be able to use the `inventory`
crate and just run it in tests though.

For some documentation on how to use it, you can check the README:
https://github.com/bitwarden/sdk-internal/blob/ps/state-traits/crates/bitwarden-state/README.md

The continuation of this is in
#301, which contains SDK
managed repository support. The client implementation of both these PRs
is in bitwarden/clients#14839


## ⏰ Reminders before review

- Contributor guidelines followed
- All formatters and local linters executed and passed
- Written new unit and / or integration tests where applicable
- Protected functional changes with optionality (feature flags)
- Used internationalization (i18n) for all UI strings
- CI builds passed
- Communicated to DevOps any deployment requirements
- Updated any necessary documentation (Confluence, contributing docs) or
informed the documentation
  team

## 🦮 Reviewer guidelines

<!-- Suggested interactions but feel free to use (or not) as you desire!
-->

- 👍 (`:+1:`) or similar for great changes
- 📝 (`:memo:`) or ℹ️ (`:information_source:`) for notes or general info
- ❓ (`:question:`) for questions
- 🤔 (`:thinking:`) or 💭 (`:thought_balloon:`) for more open inquiry
that's not quite a confirmed
  issue and could potentially benefit from discussion
- 🎨 (`:art:`) for suggestions / improvements
- ❌ (`:x:`) or ⚠️ (`:warning:`) for more significant problems or
concerns needing attention
- 🌱 (`:seedling:`) or ♻️ (`:recycle:`) for future improvements or
indications of technical debt
- ⛏ (`:pick:`) for minor or nitpick changes

Author: dani-garcia

Cargo.lock

@@ -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",

Cargo.toml

@@ -34,6 +34,7 @@ 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

crates/bitwarden-core/Cargo.toml

@@ -1,6 +1,8 @@
 use std::sync::{Arc, OnceLock, RwLock};
 
 use bitwarden_crypto::KeyStore;
+#[cfg(feature = "internal")]
+use bitwarden_state::registry::StateRegistry;
 use reqwest::header::{self, HeaderValue};
 
 use super::internal::InternalClient;
@@ -90,6 +92,8 @@ impl Client {
                 })),
                 external_client,
                 key_store: KeyStore::default(),
+                #[cfg(feature = "internal")]
+                repository_map: StateRegistry::new(),
             }),
         }
     }

crates/bitwarden-core/src/client/client.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::registry::StateRegistry;
 use chrono::Utc;
 use uuid::Uuid;
 
@@ -62,6 +64,9 @@ pub struct InternalClient {
     pub(crate) external_client: reqwest::Client,
 
     pub(super) key_store: KeyStore<KeyIds>,
+
+    #[cfg(feature = "internal")]
+    pub(crate) repository_map: StateRegistry,
 }
 
 impl InternalClient {

crates/bitwarden-core/src/client/internal.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;

crates/bitwarden-core/src/platform/mod.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 {

crates/bitwarden-core/src/platform/platform_client.rs

@@ -0,0 +1,28 @@
+use std::sync::Arc;
+
+use bitwarden_state::repository::{Repository, RepositoryItem};
+
+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_client_managed<T: 'static + Repository<V>, V: RepositoryItem>(
+        &self,
+        store: Arc<T>,
+    ) {
+        self.client
+            .internal
+            .repository_map
+            .register_client_managed(store)
+    }
+
+    /// Get a client managed state repository for a specific type, if it exists.
+    pub fn get_client_managed<T: RepositoryItem>(&self) -> Option<Arc<dyn Repository<T>>> {
+        self.client.internal.repository_map.get_client_managed()
+    }
+}

crates/bitwarden-core/src/platform/state_client.rs

@@ -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 }

crates/bitwarden-fido/Cargo.toml

@@ -0,0 +1,24 @@
+[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 }
+thiserror = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["rt"] }
+
+[lints]
+workspace = true