Don't stringify the data in indexeddb

dani-garcia · dani-garcia · commit b9dabb5a3312 · 2025-06-09T14:23:46.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/bitwarden-state/Cargo.toml b/crates/bitwarden-state/Cargo.toml
@@ -23,8 +23,10 @@ thiserror = { workspace = true }
 tokio = { workspace = true }
 
 [target.'cfg(target_arch="wasm32")'.dependencies]
-js-sys = { workspace = true }
 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"] }
 
diff --git a/crates/bitwarden-state/src/sdk_managed/indexed_db.rs b/crates/bitwarden-state/src/sdk_managed/indexed_db.rs
@@ -1,19 +1,27 @@
-use std::convert::Infallible;
-
 use js_sys::JsString;
+use serde::{de::DeserializeOwned, ser::Serialize};
 
 use crate::{
-    repository::RepositoryItemData,
+    repository::{RepositoryItem, RepositoryItemData},
     sdk_managed::{Database, DatabaseError},
 };
 
+#[derive(Debug, thiserror::Error)]
+#[error("IndexedDB internal error: {0}")]
+pub struct IndexedDbInternalError(String);
+impl From<tsify_next::serde_wasm_bindgen::Error> for IndexedDbInternalError {
+    fn from(err: tsify_next::serde_wasm_bindgen::Error) -> Self {
+        IndexedDbInternalError(err.to_string())
+    }
+}
+
 #[derive(Clone)]
 pub struct IndexedDbDatabase(
-    bitwarden_threading::ThreadBoundRunner<indexed_db::Database<Infallible>>,
+    bitwarden_threading::ThreadBoundRunner<indexed_db::Database<IndexedDbInternalError>>,
 );
 impl Database for IndexedDbDatabase {
     async fn initialize(registrations: &[RepositoryItemData]) -> Result<Self, DatabaseError> {
-        let factory = indexed_db::Factory::<Infallible>::get()?;
+        let factory = indexed_db::Factory::get()?;
 
         let registrations = registrations.to_vec();
 
@@ -39,7 +47,11 @@ impl Database for IndexedDbDatabase {
         Ok(IndexedDbDatabase(runner))
     }
 
-    async fn get(&self, namespace: &str, key: &str) -> Result<Option<String>, DatabaseError> {
+    async fn get<T: Serialize + DeserializeOwned + RepositoryItem>(
+        &self,
+        namespace: &str,
+        key: &str,
+    ) -> Result<Option<T>, DatabaseError> {
         let namespace = namespace.to_string();
         let key = key.to_string();
 
@@ -52,7 +64,8 @@ impl Database for IndexedDbDatabase {
                         let response = store.get(&JsString::from(key)).await?;
 
                         if let Some(value) = response {
-                            Ok(value.as_string())
+                            Ok(::tsify_next::serde_wasm_bindgen::from_value(value)
+                                .map_err(IndexedDbInternalError::from)?)
                         } else {
                             Ok(None)
                         }
@@ -64,7 +77,10 @@ impl Database for IndexedDbDatabase {
         Ok(result)
     }
 
-    async fn list(&self, namespace: &str) -> Result<Vec<String>, DatabaseError> {
+    async fn list<T: Serialize + DeserializeOwned + RepositoryItem>(
+        &self,
+        namespace: &str,
+    ) -> Result<Vec<T>, DatabaseError> {
         let namespace = namespace.to_string();
 
         let results = self
@@ -75,10 +91,13 @@ impl Database for IndexedDbDatabase {
                         let store = t.object_store(&namespace)?;
                         let results = store.get_all(None).await?;
 
-                        let items: Vec<String> = results
-                            .into_iter()
-                            .filter_map(|item| item.as_string())
-                            .collect();
+                        let mut items: Vec<T> = Vec::new();
+
+                        for value in results {
+                            let item: T = ::tsify_next::serde_wasm_bindgen::from_value(value)
+                                .map_err(IndexedDbInternalError::from)?;
+                            items.push(item);
+                        }
 
                         Ok(items)
                     })
@@ -89,20 +108,26 @@ impl Database for IndexedDbDatabase {
         Ok(results)
     }
 
-    async fn set(&self, namespace: &str, key: &str, value: String) -> Result<(), DatabaseError> {
+    async fn set<T: Serialize + DeserializeOwned + RepositoryItem>(
+        &self,
+        namespace: &str,
+        key: &str,
+        value: T,
+    ) -> Result<(), DatabaseError> {
         let namespace = namespace.to_string();
         let key = key.to_string();
-        let value = value.to_string();
 
         self.0
             .run_in_thread(move |db| async move {
                 db.transaction(&[&namespace])
                     .rw()
                     .run(|t| async move {
                         let store = t.object_store(&namespace)?;
-                        store
-                            .put_kv(&JsString::from(key), &JsString::from(value))
-                            .await?;
+
+                        let value = ::tsify_next::serde_wasm_bindgen::to_value(&value)
+                            .map_err(IndexedDbInternalError::from)?;
+
+                        store.put_kv(&JsString::from(key), &value).await?;
                         Ok(())
                     })
                     .await
diff --git a/crates/bitwarden-state/src/sdk_managed/mod.rs b/crates/bitwarden-state/src/sdk_managed/mod.rs
@@ -4,12 +4,12 @@ use thiserror::Error;
 
 use crate::repository::{Repository, RepositoryError, RepositoryItem, RepositoryItemData};
 
-#[cfg(target_arch = "wasm32")]
+//#[cfg(target_arch = "wasm32")]
 mod indexed_db;
 #[cfg(target_arch = "wasm32")]
 pub(super) type SystemDatabase = indexed_db::IndexedDbDatabase;
 #[cfg(target_arch = "wasm32")]
-type InternalError = ::indexed_db::Error<std::convert::Infallible>;
+type InternalError = ::indexed_db::Error<indexed_db::IndexedDbInternalError>;
 
 #[cfg(not(target_arch = "wasm32"))]
 mod sqlite;
@@ -24,6 +24,12 @@ pub enum DatabaseError {
     #[error(transparent)]
     ThreadBoundRunner(#[from] bitwarden_threading::CallError),
 
+    #[error("Serialization error: {0}")]
+    Serialization(#[from] serde_json::Error),
+
+    #[error("JS error: {0}")]
+    JSError(String),
+
     #[error(transparent)]
     Internal(#[from] InternalError),
 }
@@ -33,11 +39,23 @@ pub trait Database {
     where
         Self: Sized;
 
-    async fn get(&self, namespace: &str, key: &str) -> Result<Option<String>, DatabaseError>;
+    async fn get<T: Serialize + DeserializeOwned + RepositoryItem>(
+        &self,
+        namespace: &str,
+        key: &str,
+    ) -> Result<Option<T>, DatabaseError>;
 
-    async fn list(&self, namespace: &str) -> Result<Vec<String>, DatabaseError>;
+    async fn list<T: Serialize + DeserializeOwned + RepositoryItem>(
+        &self,
+        namespace: &str,
+    ) -> Result<Vec<T>, DatabaseError>;
 
-    async fn set(&self, namespace: &str, key: &str, value: String) -> Result<(), DatabaseError>;
+    async fn set<T: Serialize + DeserializeOwned + RepositoryItem>(
+        &self,
+        namespace: &str,
+        key: &str,
+        value: T,
+    ) -> Result<(), DatabaseError>;
 
     async fn remove(&self, namespace: &str, key: &str) -> Result<(), DatabaseError>;
 }
@@ -51,19 +69,14 @@ struct DBRepository<T: RepositoryItem> {
 impl<V: RepositoryItem + Serialize + DeserializeOwned> Repository<V> for DBRepository<V> {
     async fn get(&self, key: String) -> Result<Option<V>, RepositoryError> {
         let value = self.database.get(V::NAME, &key).await?;
-        Ok(value.map(|v| serde_json::from_str(&v)).transpose()?)
+        Ok(value)
     }
     async fn list(&self) -> Result<Vec<V>, RepositoryError> {
         let values = self.database.list(V::NAME).await?;
-        let mut results = Vec::new();
-        for value in values {
-            results.push(serde_json::from_str(&value)?);
-        }
-        Ok(results)
+        Ok(values)
     }
     async fn set(&self, key: String, value: V) -> Result<(), RepositoryError> {
-        let value_str = serde_json::to_string(&value)?;
-        Ok(self.database.set(V::NAME, &key, value_str).await?)
+        Ok(self.database.set(V::NAME, &key, value).await?)
     }
     async fn remove(&self, key: String) -> Result<(), RepositoryError> {
         Ok(self.database.remove(V::NAME, &key).await?)
diff --git a/crates/bitwarden-state/src/sdk_managed/sqlite.rs b/crates/bitwarden-state/src/sdk_managed/sqlite.rs
@@ -1,9 +1,10 @@
 use std::sync::Arc;
 
+use serde::{de::DeserializeOwned, ser::Serialize};
 use tokio::sync::Mutex;
 
 use crate::{
-    repository::RepositoryItemData,
+    repository::{RepositoryItem, RepositoryItemData},
     sdk_managed::{Database, DatabaseError},
 };
 
@@ -30,35 +31,53 @@ impl Database for SqliteDatabase {
         Ok(SqliteDatabase(Arc::new(Mutex::new(db))))
     }
 
-    async fn get(&self, namespace: &str, key: &str) -> Result<Option<String>, DatabaseError> {
+    async fn get<T: Serialize + DeserializeOwned + RepositoryItem>(
+        &self,
+        namespace: &str,
+        key: &str,
+    ) -> Result<Option<T>, DatabaseError> {
         let conn = self.0.lock().await;
         let mut stmt = conn.prepare("SELECT value FROM ?1 WHERE key = ?2")?;
         let mut rows = stmt.query(rusqlite::params![namespace, key])?;
 
         if let Some(row) = rows.next()? {
-            Ok(Some(row.get(0)?))
+            let value = row.get::<_, String>(0)?;
+
+            Ok(Some(serde_json::from_str(&value)?))
         } else {
             Ok(None)
         }
     }
 
-    async fn list(&self, namespace: &str) -> Result<Vec<String>, DatabaseError> {
+    async fn list<T: Serialize + DeserializeOwned + RepositoryItem>(
+        &self,
+        namespace: &str,
+    ) -> Result<Vec<T>, DatabaseError> {
         let conn = self.0.lock().await;
         let mut stmt = conn.prepare("SELECT key, value FROM ?1")?;
         let rows = stmt.query_map(rusqlite::params![namespace], |row| row.get(1))?;
 
         let mut results = Vec::new();
         for row in rows {
-            results.push(row?);
+            let value: String = row?;
+            let value: T = serde_json::from_str(&value)?;
+            results.push(value);
         }
 
         Ok(results)
     }
 
-    async fn set(&self, namespace: &str, key: &str, value: String) -> Result<(), DatabaseError> {
+    async fn set<T: Serialize + DeserializeOwned + RepositoryItem>(
+        &self,
+        namespace: &str,
+        key: &str,
+        value: T,
+    ) -> Result<(), DatabaseError> {
         let mut conn = self.0.lock().await;
         let transaction = conn.transaction()?;
 
+        let value = serde_json::to_string(&value)?;
+
         transaction.execute(
             "INSERT OR REPLACE INTO ?1 (key, value) VALUES (?2, ?3)",
             rusqlite::params![namespace, key, value],
