[PM-12612] SDK-Managed Repository support (#301)

## 🎟️ Tracking

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

## 📔 Objective

A continuation of #213,
this PR implements some simple SDK managed data store based on SQLite
(on non-wasm) and IndexedDB (on wasm).

Both databases are wrapped in a `Database` trait and conditionally
compiled based on platform. Then from each database we can get multiple
`Repository` implementations that can be used to read and write data
persistently. Each repository is mapped to a separate table in SQLite
and Object Store in IndexedDb.

Some limitations of the current system:
- The database currently needs to be initialized as a separate step to
both the SdkClient and the client-managed repositories, I feel like
ideally we can do that as part of Client initialization, but that would
require us to make initialization async. I've left that for the future.
- Currently we don't have any indexes beyond the main key, but both
sqlite and indexeddb support adding more.
- The current structure doesn't have any migration capabilities, which
are required for indexeddb to create the object stores, this PR
temporarily adds version numbers to the `register_repository_item`
calls, just to get something working, but note that this is removed in
#410 and replaced with a
better migration system.

## ⏰ 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

---------

Co-authored-by: Andreas Coroiu <[email protected]>

Author: dani-garcia

Cargo.lock

@@ -1,8 +1,9 @@
 use std::sync::Arc;
 
 use bitwarden_state::{
-    registry::RepositoryNotFoundError,
-    repository::{Repository, RepositoryItem},
+    registry::{RepositoryNotFoundError, StateRegistryError},
+    repository::{Repository, RepositoryItem, RepositoryItemData},
+    DatabaseConfiguration,
 };
 
 use crate::Client;
@@ -30,4 +31,26 @@ impl StateClient {
     ) -> Result<Arc<dyn Repository<T>>, RepositoryNotFoundError> {
         self.client.internal.repository_map.get_client_managed()
     }
+
+    /// Initialize the database for SDK managed repositories.
+    pub async fn initialize_database(
+        &self,
+        configuration: DatabaseConfiguration,
+        repositories: Vec<RepositoryItemData>,
+    ) -> Result<(), StateRegistryError> {
+        self.client
+            .internal
+            .repository_map
+            .initialize_database(configuration, 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

@@ -11,11 +11,24 @@ keywords.workspace = true
 
 [features]
 uniffi = []
-wasm = []
+wasm = ["bitwarden-threading/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 = { workspace = true }
+
+[target.'cfg(not(target_arch="wasm32"))'.dependencies]
+rusqlite = { version = ">=0.37.0, <0.38", features = ["bundled"] }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["rt"] }

crates/bitwarden-state/Cargo.toml

@@ -27,6 +27,10 @@ stored:
 - If the SDK itself will handle data storage, we call that approach `SDK-Managed State`. The
   implementation of this is will a work in progress.
 
+Note that these approaches aren't mutually exclusive: a repository item can use both client and SDK
+managed state at the same time. However, this mixed approach is only recommended during migration
+scenarios to avoid potential confusion.
+
 ## Client-Managed State
 
 With `Client-Managed State` the application and SDK will both access the same data pool, which
@@ -53,7 +57,7 @@ impl StateClient {
 }
 ```
 
-#### How to use it on web clients
+#### How to initialize Client-Managed State on the web clients
 
 Once we have the function defined in `bitwarden-wasm-internal`, we can use it from the web clients.
 For that, the first thing we need to do is create a mapper between the client and SDK types. This
@@ -113,7 +117,7 @@ impl StateClient {
 }
 ```
 
-#### How to use it on iOS
+#### How to initialize Client-Managed State on iOS
 
 Once we have the function defined in `bitwarden-uniffi`, we can use it from the iOS application:
 
@@ -144,7 +148,7 @@ let store = CipherStoreImpl(cipherDataStore: self.cipherDataStore, userId: userI
 try await self.clientService.platform().store().registerCipherStore(store: store);
 ```
 
-### How to use it on Android
+### How to initialize Client-Managed State on Android
 
 Once we have the function defined in `bitwarden-uniffi`, we can use it from the Android application:
 
@@ -173,3 +177,70 @@ 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.
+
+### How to initialize SDK-Managed State on WASM
+
+Go to `crates/bitwarden-wasm-internal/src/platform/mod.rs` and add a line with your type, as shown
+below. In this example we're registering `Cipher` as both client and SDK managed to show how both
+are done, but you can also just do one or the other.
+
+```rust,ignore
+    pub async fn initialize_state(
+        &self,
+        cipher_repository: CipherRepository,
+    ) -> Result<(), bitwarden_state::registry::StateRegistryError> {
+        let cipher = cipher_repository.into_channel_impl();
+        // Register the provided repository as client managed state
+        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
+    }
+```
+
+### How to initialize SDK-Managed State on UniFFI
+
+Go to `crates/bitwarden-uniffi/src/platform/mod.rs` and add a line with your type, as shown below.
+In this example we're registering `Cipher` as both client and SDK managed to show how both are done,
+but you can also just do one or the other.
+
+```rust,ignore
+    pub async fn initialize_state(
+        &self,
+        cipher_repository: Arc<dyn CipherRepository>,
+    ) -> Result<()> {
+        let cipher = UniffiRepositoryBridge::new(cipher_repository);
+        // Register the provided repository as client managed state
+        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,7 @@ pub mod repository;
 
 /// This module provides a registry for managing repositories of different types.
 pub mod registry;
+
+pub(crate) mod sdk_managed;
+
+pub use sdk_managed::DatabaseConfiguration;