feat: webstore settings table (0xMiden#1294)

* feat: add migrations and settings tables

* feat: add settings table to web store

* chore: lint

* docs: update web-client docs

* review: use Uint8Array instead of blob

* review: refactor account cmd

* chore: bump web client version

* chore: lint

* review: address comments

* review: add method to list settings keys

* merge: add comment

* feat: add listKeys

* chore: bump sdk version

* chore: fix merge

* review: rename settings accessors

* review: rename settings accessors

* chore: bump sdk version

* chore: bump sdk version

* review: add doc comments

* review: docs

* Update crates/web-client/package.json

---------

Co-authored-by: igamigo <[email protected]>
Co-authored-by: Marti <[email protected]>

Author: 3 people

crates/idxdb-store/src/js/schema.d.ts

@@ -97,6 +97,10 @@ export interface IForeignAccountCode {
     accountId: string;
     codeRoot: string;
 }
+export interface ISetting {
+    key: string;
+    value: Uint8Array;
+}
 declare const db: Dexie & {
     accountCodes: Dexie.Table<IAccountCode, string>;
     accountStorages: Dexie.Table<IAccountStorage, string>;
@@ -114,6 +118,7 @@ declare const db: Dexie & {
     partialBlockchainNodes: Dexie.Table<IPartialBlockchainNode, string>;
     tags: Dexie.Table<ITag, number>;
     foreignAccountCode: Dexie.Table<IForeignAccountCode, string>;
+    settings: Dexie.Table<ISetting, string>;
 };
 declare const accountCodes: import("dexie").Table<IAccountCode, string, IAccountCode>;
 declare const accountStorages: import("dexie").Table<IAccountStorage, string, IAccountStorage>;
@@ -131,4 +136,5 @@ declare const blockHeaders: import("dexie").Table<IBlockHeader, string, IBlockHe
 declare const partialBlockchainNodes: import("dexie").Table<IPartialBlockchainNode, string, IPartialBlockchainNode>;
 declare const tags: import("dexie").Table<ITag, number, ITag>;
 declare const foreignAccountCode: import("dexie").Table<IForeignAccountCode, string, IForeignAccountCode>;
-export { db, accountCodes, accountStorages, storageMapEntries, accountAssets, accountAuths, accounts, transactions, transactionScripts, inputNotes, outputNotes, notesScripts, stateSync, blockHeaders, partialBlockchainNodes, tags, foreignAccountCode, };
+declare const settings: import("dexie").Table<ISetting, string, ISetting>;
+export { db, accountCodes, accountStorages, storageMapEntries, accountAssets, accountAuths, accounts, transactions, transactionScripts, inputNotes, outputNotes, notesScripts, stateSync, blockHeaders, partialBlockchainNodes, tags, foreignAccountCode, settings, };

crates/idxdb-store/src/js/schema.js

@@ -0,0 +1,7 @@
+export declare function getSetting(key: string): Promise<{
+    key: string;
+    value: string;
+} | null | undefined>;
+export declare function insertSetting(key: string, value: Uint8Array): Promise<void>;
+export declare function removeSetting(key: string): Promise<void>;
+export declare function listSettingKeys(): Promise<string[] | undefined>;

crates/idxdb-store/src/js/schema.js.map

@@ -42,6 +42,7 @@ pub mod export;
 pub mod import;
 pub mod note;
 mod promise;
+pub mod settings;
 pub mod sync;
 pub mod transaction;
 
@@ -253,20 +254,20 @@ impl Store for WebStore {
     // SETTINGS
     // --------------------------------------------------------------------------------------------
 
-    async fn set_setting(&self, _key: String, _value: Vec<u8>) -> Result<(), StoreError> {
-        unimplemented!()
+    async fn set_setting(&self, key: String, value: Vec<u8>) -> Result<(), StoreError> {
+        self.set_setting(key, value).await
     }
 
-    async fn get_setting(&self, _key: String) -> Result<Option<Vec<u8>>, StoreError> {
-        unimplemented!()
+    async fn get_setting(&self, key: String) -> Result<Option<Vec<u8>>, StoreError> {
+        self.get_setting(key).await
     }
 
-    async fn remove_setting(&self, _key: String) -> Result<(), StoreError> {
-        unimplemented!()
+    async fn remove_setting(&self, key: String) -> Result<(), StoreError> {
+        self.remove_setting(key).await
     }
 
     async fn list_setting_keys(&self) -> Result<Vec<String>, StoreError> {
-        unimplemented!()
+        self.list_setting_keys().await
     }
 }
 

crates/idxdb-store/src/js/settings.d.ts

@@ -0,0 +1,21 @@
+use alloc::string::String;
+use alloc::vec::Vec;
+
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::{js_sys, wasm_bindgen};
+
+// Settings IndexedDB Operations
+#[wasm_bindgen(module = "/src/js/settings.js")]
+extern "C" {
+    #[wasm_bindgen(js_name = getSetting)]
+    pub fn idxdb_get_setting(key: String) -> js_sys::Promise;
+
+    #[wasm_bindgen(js_name = insertSetting)]
+    pub fn idxdb_insert_setting(key: String, value: Vec<u8>) -> js_sys::Promise;
+
+    #[wasm_bindgen(js_name = removeSetting)]
+    pub fn idxdb_remove_setting(key: String) -> js_sys::Promise;
+
+    #[wasm_bindgen(js_name = listSettingKeys)]
+    pub fn idxdb_list_setting_keys() -> js_sys::Promise;
+}

crates/idxdb-store/src/js/settings.js

@@ -0,0 +1,61 @@
+use alloc::string::String;
+use alloc::vec::Vec;
+
+use miden_client::store::StoreError;
+use serde_wasm_bindgen::from_value;
+use wasm_bindgen_futures::JsFuture;
+
+mod js_bindings;
+mod models;
+
+use js_bindings::{
+    idxdb_get_setting,
+    idxdb_insert_setting,
+    idxdb_list_setting_keys,
+    idxdb_remove_setting,
+};
+
+use crate::WebStore;
+use crate::settings::models::SettingValueIdxdbObject;
+
+impl WebStore {
+    pub(crate) async fn set_setting(&self, key: String, value: Vec<u8>) -> Result<(), StoreError> {
+        let promise = idxdb_insert_setting(key, value);
+        JsFuture::from(promise).await.map_err(|js_error| {
+            StoreError::DatabaseError(format!("failed to set setting value: {js_error:?}",))
+        })?;
+        Ok(())
+    }
+
+    pub(crate) async fn get_setting(&self, key: String) -> Result<Option<Vec<u8>>, StoreError> {
+        let promise = idxdb_get_setting(key);
+        let value = JsFuture::from(promise).await.map_err(|js_error| {
+            StoreError::DatabaseError(format!(
+                "failed to get setting value from idxdb: {js_error:?}",
+            ))
+        })?;
+        let setting: Option<SettingValueIdxdbObject> = from_value(value).map_err(|err| {
+            StoreError::DatabaseError(format!("failed to deserialize value from idxdb: {err:?}"))
+        })?;
+        Ok(setting.map(|setting| setting.value))
+    }
+
+    pub(crate) async fn remove_setting(&self, key: String) -> Result<(), StoreError> {
+        let promise = idxdb_remove_setting(key);
+        JsFuture::from(promise).await.map_err(|js_error| {
+            StoreError::DatabaseError(format!("failed to delete setting value: {js_error:?}",))
+        })?;
+        Ok(())
+    }
+
+    pub(crate) async fn list_setting_keys(&self) -> Result<Vec<String>, StoreError> {
+        let promise = idxdb_list_setting_keys();
+        let keys = JsFuture::from(promise).await.map_err(|js_error| {
+            StoreError::DatabaseError(format!("failed to list setting keys: {js_error:?}",))
+        })?;
+        let keys: Vec<String> = from_value(keys).map_err(|err| {
+            StoreError::DatabaseError(format!("failed to deserialize setting keys: {err:?}"))
+        })?;
+        Ok(keys)
+    }
+}

crates/idxdb-store/src/js/settings.js.map

@@ -0,0 +1,25 @@
+use alloc::string::String;
+use alloc::vec::Vec;
+
+use base64::Engine as _;
+use base64::engine::general_purpose;
+use serde::de::Error;
+use serde::{Deserialize, Deserializer, Serialize};
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SettingValueIdxdbObject {
+    pub key: String,
+    #[serde(deserialize_with = "base64_to_vec_u8_required", default)]
+    pub value: Vec<u8>,
+}
+
+fn base64_to_vec_u8_required<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let base64_str: String = Deserialize::deserialize(deserializer)?;
+    general_purpose::STANDARD
+        .decode(&base64_str)
+        .map_err(|e| Error::custom(format!("Base64 decode error: {e}")))
+}