Implement SDK managed state

# Conflicts:
#	Cargo.lock
#	crates/bitwarden-state/Cargo.toml
#	crates/bitwarden-state/src/registry.rs
#	crates/bitwarden-state/src/repository.rs
#	crates/bitwarden-vault/src/cipher/cipher.rs

# Conflicts:
#	crates/bitwarden-vault/src/vault_client.rs

# Conflicts:
#	Cargo.lock
#	crates/bitwarden-state/Cargo.toml

Use bundled sqlite to solve compile issues

Update readme

Don't stringify the data in indexeddb

Remove the comment

Update readme

Author: dani-garcia

Cargo.lock

@@ -1,6 +1,9 @@
 use std::sync::Arc;
 
-use bitwarden_state::repository::{Repository, RepositoryItem};
+use bitwarden_state::{
+    registry::StateRegistryError,
+    repository::{Repository, RepositoryItem, RepositoryItemData},
+};
 
 use crate::Client;
 
@@ -25,4 +28,25 @@ impl StateClient {
     pub fn get_client_managed<T: RepositoryItem>(&self) -> Option<Arc<dyn Repository<T>>> {
         self.client.internal.repository_map.get_client_managed()
     }
+
+    /// Initialize the database for SDK managed repositories.
+    pub async fn initialize_database(
+        &self,
+        repositories: Vec<RepositoryItemData>,
+    ) -> Result<(), StateRegistryError> {
+        self.client
+            .internal
+            .repository_map
+            .initialize_database(repositories)
+            .await
+    }
+
+    /// Get a SDK managed state repository for a specific type, if it exists.
+    pub fn get_sdk_managed<
+        T: RepositoryItem + serde::ser::Serialize + serde::de::DeserializeOwned,
+    >(
+        &self,
+    ) -> Result<impl Repository<T>, StateRegistryError> {
+        self.client.internal.repository_map.get_sdk_managed()
+    }
 }

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

@@ -15,7 +15,20 @@ wasm = []
 
 [dependencies]
 async-trait = { workspace = true }
+bitwarden-error = { workspace = true }
+bitwarden-threading = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
 thiserror = { workspace = true }
+tokio = { workspace = true }
+
+[target.'cfg(target_arch="wasm32")'.dependencies]
+indexed-db = ">=0.4.2, <0.5"
+js-sys = { workspace = true }
+tsify-next = { workspace = true }
+
+[target.'cfg(not(target_arch="wasm32"))'.dependencies]
+rusqlite = { version = ">=0.36.0, <0.37", features = ["bundled"] }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["rt"] }

crates/bitwarden-state/Cargo.toml

@@ -14,7 +14,7 @@ struct Cipher {
 
 // Register `Cipher` for use with a `Repository`.
 // This should be done in the crate where `Cipher` is defined.
-bitwarden_state::register_repository_item!(Cipher, "Cipher");
+bitwarden_state::register_repository_item!(Cipher, "Cipher", version: 1);
 ```
 
 With the registration complete, the next important decision is to select where will the data be
@@ -173,3 +173,64 @@ class CipherStoreImpl: CipherStore {
 
 getClient(userId = userId).platform().store().registerCipherStore(CipherStoreImpl());
 ```
+
+## SDK-Managed State
+
+With `SDK-Managed State`, the SDK will be exclusively responsible for the data storage. This means
+that the clients don't need to make any changes themselves, as the implementation is internal to the
+SDK. To add support for an SDK managed `Repository`, it needs to be added to the initialization code
+for WASM and UniFFI. This example shows how to add support for `Cipher`s.
+
+### WASM
+
+Go to `crates/bitwarden-wasm-internal/src/platform/mod.rs` and add a line with your type, as shown:
+
+```rust,ignore
+    pub async fn initialize_state(
+        &self,
+        cipher_repository: CipherRepository,
+    ) -> Result<(), bitwarden_state::registry::StateRegistryError> {
+        let cipher = cipher_repository.into_channel_impl();
+        self.0.platform().state().register_client_managed(cipher);
+
+        let sdk_managed_repositories = vec![
+            // This should list all the SDK-managed repositories
+            <Cipher as RepositoryItem>::data(),
+            // Add your type here
+        ];
+
+        self.0
+            .platform()
+            .state()
+            .initialize_database(sdk_managed_repositories)
+            .await
+    }
+```
+
+### UniFFI
+
+Go to `crates/bitwarden-uniffi/src/platform/mod.rs` and add a line with your type, as shown:
+
+```rust,ignore
+    pub async fn initialize_state(
+        &self,
+        cipher_repository: Arc<dyn CipherRepository>,
+    ) -> Result<()> {
+        let cipher = UniffiRepositoryBridge::new(cipher_repository);
+        self.0.platform().state().register_client_managed(cipher);
+
+        let sdk_managed_repositories = vec![
+            // This should list all the SDK-managed repositories
+            <Cipher as RepositoryItem>::data(),
+            // Add your type here
+        ];
+
+        self.0
+            .platform()
+            .state()
+            .initialize_database(sdk_managed_repositories)
+            .await
+            .map_err(Error::StateRegistry)?;
+        Ok(())
+    }
+```

crates/bitwarden-state/README.md

@@ -5,3 +5,5 @@ pub mod repository;
 
 /// This module provides a registry for managing repositories of different types.
 pub mod registry;
+
+pub(crate) mod sdk_managed;