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

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

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

crates/bitwarden-state/Cargo.toml

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

crates/bitwarden-state/src/lib.rs

@@ -1,15 +1,25 @@
 use std::{
     any::{Any, TypeId},
     collections::HashMap,
-    sync::{Arc, RwLock},
+    sync::{Arc, OnceLock, RwLock},
 };
 
-use crate::repository::{Repository, RepositoryItem};
+use bitwarden_error::bitwarden_error;
+use serde::{de::DeserializeOwned, Serialize};
+use thiserror::Error;
+
+use crate::{
+    repository::{Repository, RepositoryItem, RepositoryItemData},
+    sdk_managed::{Database, SystemDatabase},
+};
 
 /// A registry that contains repositories for different types of items.
 /// These repositories can be either managed by the client or by the SDK itself.
 pub struct StateRegistry {
+    sdk_managed: RwLock<Vec<RepositoryItemData>>,
     client_managed: RwLock<HashMap<TypeId, Box<dyn Any + Send + Sync>>>,
+
+    database: OnceLock<SystemDatabase>,
 }
 
 impl std::fmt::Debug for StateRegistry {
@@ -18,13 +28,58 @@ impl std::fmt::Debug for StateRegistry {
     }
 }
 
+#[allow(missing_docs)]
+#[bitwarden_error(flat)]
+#[derive(Debug, Error)]
+pub enum StateRegistryError {
+    #[error("Database is already initialized")]
+    DatabaseAlreadyInitialized,
+    #[error("Database is not initialized")]
+    DatabaseNotInitialized,
+
+    #[error(transparent)]
+    Database(#[from] crate::sdk_managed::DatabaseError),
+}
+
 impl StateRegistry {
     /// Creates a new empty `StateRegistry`.
     #[allow(clippy::new_without_default)]
     pub fn new() -> Self {
         StateRegistry {
             client_managed: RwLock::new(HashMap::new()),
+            database: OnceLock::new(),
+            sdk_managed: RwLock::new(Vec::new()),
+        }
+    }
+
+    // TODO: Ideally we'd do this in new, but that would mean making the client initialization
+    // async.
+    // TODO: This function needs to be provided some configuration to know where to open the
+    // database. For Sqlite:
+    // - A folder path where the files will be stored.
+    // - A user ID to create a unique database file per user?
+    //
+    // For WASM indexedDB:
+    // - A database name to use for the indexedDB (Some prefix to avoid conflicts + user ID?)
+
+    /// Initializes the database used for sdk-managed repositories.
+    pub async fn initialize_database(
+        &self,
+        repositories: Vec<RepositoryItemData>,
+    ) -> Result<(), StateRegistryError> {
+        if self.database.get().is_some() {
+            return Err(StateRegistryError::DatabaseAlreadyInitialized);
         }
+        let _ = self
+            .database
+            .set(SystemDatabase::initialize(&repositories).await?);
+
+        *self
+            .sdk_managed
+            .write()
+            .expect("RwLock should not be poisoned") = repositories.clone();
+
+        Ok(())
     }
 
     /// Registers a client-managed repository into the map, associating it with its type.
@@ -44,6 +99,17 @@ impl StateRegistry {
             .and_then(|boxed| boxed.downcast_ref::<Arc<dyn Repository<T>>>())
             .map(Arc::clone)
     }
+
+    /// Retrieves a SDK-managed repository from the database.
+    pub fn get_sdk_managed<T: RepositoryItem + Serialize + DeserializeOwned>(
+        &self,
+    ) -> Result<impl Repository<T>, StateRegistryError> {
+        if let Some(db) = self.database.get() {
+            Ok(db.get_repository::<T>()?)
+        } else {
+            Err(StateRegistryError::DatabaseNotInitialized)
+        }
+    }
 }
 
 #[cfg(test)]
@@ -83,9 +149,9 @@ mod tests {
     #[derive(PartialEq, Eq, Debug)]
     struct TestItem<T>(T);
 
-    register_repository_item!(TestItem<usize>, "TestItem<usize>");
-    register_repository_item!(TestItem<String>, "TestItem<String>");
-    register_repository_item!(TestItem<Vec<u8>>, "TestItem<Vec<u8>>");
+    register_repository_item!(TestItem<usize>, "TestItem<usize>", version: 1);
+    register_repository_item!(TestItem<String>, "TestItem<String>", version: 1);
+    register_repository_item!(TestItem<Vec<u8>>, "TestItem<Vec<u8>>", version: 1);
 
     impl_repository!(TestA, TestItem<usize>);
     impl_repository!(TestB, TestItem<String>);