create new indexeddb connection for each query on wasm, implement active (#451)

identity in a persistent way, use static context,use different collection for files,fix build

Author: zupzup

CHANGELOG.md

@@ -1,5 +1,14 @@
 # 0.3.1
 
+
+* Persist active Identity to DB for WASM
+* Change indexed-db name to "data"
+* Use a different indexed-db collection for files, named "files"
+* Create a new indexeddb database connection for each query to avoid transaction overlapping
+* Removed timezone db api
+* Persist base64 string instead of bytes for images, for more efficiency
+* Added Retry-sending for Nostr block events
+* Added block propagation via Nostr
 * Added a caching layer for bills, heavily improving performance
 * Added `error` logs for all errors returned from the API for the WASM version
 * Added `log_level` to Config, which defaults to `info`

crates/bcr-ebill-api/src/external/time.rs

@@ -1,32 +1,15 @@
 use crate::util;
-use log::error;
 use serde::Deserialize;
 
-/// Documented at https://timezonedb.com/references/get-time-zone
 #[derive(Deserialize, Debug)]
 pub struct TimeApi {
     pub timestamp: u64,
 }
 
 impl TimeApi {
     pub async fn get_atomic_time() -> Self {
-        match reqwest::get("https://vip.timezonedb.com/v2.1/get-time-zone?key=AY3Q7V1JPPNX&format=json&fields=timestamp&by=zone&zone=UTC")
-            .await
-            {
-                Err(e) => {
-                    handle_error(e)
-                },
-                Ok(result) => result.json().await.unwrap_or_else(|e| {
-                    handle_error(e)
-                }),
-            }
+        let utc_now = util::date::now();
+        let timestamp = utc_now.timestamp() as u64;
+        TimeApi { timestamp }
     }
 }
-
-fn handle_error(e: reqwest::Error) -> TimeApi {
-    // if there is an error with the API, fall back to local timestamp
-    error!("Error while fetching atomic time from API: {e}");
-    let utc_now = util::date::now();
-    let timestamp = utc_now.timestamp() as u64;
-    TimeApi { timestamp }
-}

crates/bcr-ebill-api/src/service/identity_service.rs

@@ -11,6 +11,7 @@ use crate::data::{
 use crate::persistence::file_upload::FileUploadStoreApi;
 use crate::persistence::identity::IdentityChainStoreApi;
 use async_trait::async_trait;
+use bcr_ebill_core::identity::ActiveIdentityState;
 use log::info;
 use std::sync::Arc;
 
@@ -61,6 +62,15 @@ pub trait IdentityServiceApi: Send + Sync {
         file_name: &str,
         private_key: &str,
     ) -> Result<Vec<u8>>;
+
+    /// gets the currently set identity
+    async fn get_current_identity(&self) -> Result<ActiveIdentityState>;
+
+    /// sets the active identity to the given personal node id
+    async fn set_current_personal_identity(&self, node_id: &str) -> Result<()>;
+
+    /// sets the active identity to the given company node id
+    async fn set_current_company_identity(&self, node_id: &str) -> Result<()>;
 }
 
 /// The identity service is responsible for managing the local identity
@@ -345,6 +355,32 @@ impl IdentityServiceApi for IdentityService {
         let decrypted = util::crypto::decrypt_ecies(&read_file, private_key)?;
         Ok(decrypted)
     }
+
+    async fn get_current_identity(&self) -> Result<ActiveIdentityState> {
+        let active_identity = self.store.get_current_identity().await?;
+        Ok(active_identity)
+    }
+
+    async fn set_current_personal_identity(&self, node_id: &str) -> Result<()> {
+        self.store
+            .set_current_identity(&ActiveIdentityState {
+                personal: node_id.to_owned(),
+                company: None,
+            })
+            .await?;
+        Ok(())
+    }
+
+    async fn set_current_company_identity(&self, node_id: &str) -> Result<()> {
+        let active_identity = self.store.get_current_identity().await?;
+        self.store
+            .set_current_identity(&ActiveIdentityState {
+                personal: active_identity.personal,
+                company: Some(node_id.to_owned()),
+            })
+            .await?;
+        Ok(())
+    }
 }
 
 #[cfg(test)]

crates/bcr-ebill-api/src/tests/mod.rs

@@ -13,7 +13,7 @@ pub mod tests {
         },
         company::{Company, CompanyKeys},
         contact::{Contact, ContactType, IdentityPublicData},
-        identity::{Identity, IdentityWithAll},
+        identity::{ActiveIdentityState, Identity, IdentityWithAll},
         notification::{ActionType, Notification, NotificationType},
         util::crypto::BcrKeys,
     };
@@ -136,6 +136,8 @@ pub mod tests {
             async fn get_key_pair(&self) -> Result<BcrKeys>;
             async fn get_or_create_key_pair(&self) -> Result<BcrKeys>;
             async fn get_seedphrase(&self) -> Result<String>;
+            async fn get_current_identity(&self) -> Result<ActiveIdentityState>;
+            async fn set_current_identity(&self, identity_state: &ActiveIdentityState) -> Result<()>;
         }
     }
 

crates/bcr-ebill-core/src/identity.rs

@@ -46,3 +46,9 @@ impl Identity {
         self.name.clone()
     }
 }
+
+#[derive(Clone, Debug)]
+pub struct ActiveIdentityState {
+    pub personal: String,
+    pub company: Option<String>,
+}

crates/bcr-ebill-core/src/util/mod.rs

@@ -3,8 +3,8 @@ pub mod date;
 
 pub use crypto::BcrKeys;
 
-use bitcoin::hashes::sha256;
 use bitcoin::hashes::Hash;
+use bitcoin::hashes::sha256;
 use thiserror::Error;
 use uuid::Uuid;
 

crates/bcr-ebill-persistence/Cargo.toml

@@ -23,6 +23,7 @@ getrandom = { version = "0.3.1", features = ["wasm_js"] } # needed for wasm buil
 # Enable "kv-indxdb" only for WebAssembly (wasm32)
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 surrealdb = { version = "2.2", default-features = false, features = ["kv-indxdb"] }
+base64 = "0.22"
 
 # Enable "protocol-ws" for all other targets
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
@@ -32,6 +33,7 @@ tokio.workspace = true
 [dev-dependencies]
 surrealdb = { version = "2.2.0", features = ["kv-mem"], default-features = false }
 tokio.workspace = true
+base64 = "0.22"
 
 [features]
 embedded-db = ["surrealdb/kv-rocksdb"]

crates/bcr-ebill-persistence/src/constants.rs

@@ -21,3 +21,17 @@ pub const DB_SEARCH_TERM: &str = "search_term";
 
 pub const DB_ENTITY_ID: &str = "entity_id";
 pub const DB_FILE_NAME: &str = "file_name";
+
+#[cfg(target_arch = "wasm32")]
+pub const SURREAL_DB_CON_INDXDB_DATA: &str = "indxdb://data";
+#[cfg(target_arch = "wasm32")]
+pub const SURREAL_DB_INDXDB_DB_DATA: &str = "data";
+#[cfg(target_arch = "wasm32")]
+pub const SURREAL_DB_INDXDB_NS_DATA: &str = "";
+
+#[cfg(target_arch = "wasm32")]
+pub const SURREAL_DB_CON_INDXDB_FILES: &str = "indxdb://files";
+#[cfg(target_arch = "wasm32")]
+pub const SURREAL_DB_INDXDB_DB_FILES: &str = "files";
+#[cfg(target_arch = "wasm32")]
+pub const SURREAL_DB_INDXDB_NS_FILES: &str = "";

crates/bcr-ebill-persistence/src/db/backup.rs

@@ -1,5 +1,7 @@
 use std::path::Path;
 
+#[cfg(target_arch = "wasm32")]
+use super::get_new_surreal_db;
 use crate::backup::BackupStoreApi;
 
 use super::Result;
@@ -8,20 +10,31 @@ use futures::StreamExt;
 use surrealdb::{Surreal, engine::any::Any};
 
 pub struct SurrealBackupStore {
+    #[allow(dead_code)]
     db: Surreal<Any>,
 }
 
 impl SurrealBackupStore {
     pub fn new(db: Surreal<Any>) -> Self {
         Self { db }
     }
+
+    #[cfg(target_arch = "wasm32")]
+    async fn db(&self) -> Result<Surreal<Any>> {
+        get_new_surreal_db().await
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    async fn db(&self) -> Result<Surreal<Any>> {
+        Ok(self.db.clone())
+    }
 }
 
 #[async_trait]
 impl BackupStoreApi for SurrealBackupStore {
     /// returns the whole database as a byte vector backup ready for encryption
     async fn backup(&self) -> Result<Vec<u8>> {
-        let mut stream = self.db.export(()).await?;
+        let mut stream = self.db().await?.export(()).await?;
         let mut buffer = Vec::new();
         while let Some(Ok(chunk)) = stream.next().await {
             buffer.extend_from_slice(&chunk);
@@ -30,12 +43,16 @@ impl BackupStoreApi for SurrealBackupStore {
     }
 
     async fn restore(&self, file_path: &Path) -> Result<()> {
-        self.db.import(file_path).await?;
+        self.db().await?.import(file_path).await?;
         Ok(())
     }
 
     async fn drop_db(&self, name: &str) -> Result<()> {
-        let _ = self.db.query(format!("REMOVE DATABASE {}", name)).await?;
+        let _ = self
+            .db()
+            .await?
+            .query(format!("REMOVE DATABASE {}", name))
+            .await?;
         Ok(())
     }
 }