add web impl, add surreal impl for wasm, add tests and test harness (#439)

Author: zupzup

crates/bcr-ebill-api/Cargo.toml

@@ -28,6 +28,9 @@ bcr-ebill-core = { path = "../bcr-ebill-core" }
 bcr-ebill-persistence = { path = "../bcr-ebill-persistence" }
 bcr-ebill-transport = { path = "../bcr-ebill-transport" }
 
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+tokio.workspace = true
+
 [dev-dependencies]
 mockall = "0.13.1"
 nostr-relay-builder = "0.39.0"

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

@@ -1,10 +1,9 @@
 use crate::Config;
 use bcr_ebill_persistence::{
-    BackupStoreApi, ContactStoreApi, FileUploadStore, NostrEventOffsetStoreApi,
-    NotificationStoreApi, SurrealBackupStore, SurrealBillChainStore, SurrealBillStore,
-    SurrealCompanyChainStore, SurrealCompanyStore, SurrealContactStore, SurrealDbConfig,
-    SurrealIdentityChainStore, SurrealIdentityStore, SurrealNostrEventOffsetStore,
-    SurrealNotificationStore,
+    BackupStoreApi, ContactStoreApi, NostrEventOffsetStoreApi, NotificationStoreApi,
+    SurrealBackupStore, SurrealBillChainStore, SurrealBillStore, SurrealCompanyChainStore,
+    SurrealCompanyStore, SurrealContactStore, SurrealDbConfig, SurrealIdentityChainStore,
+    SurrealIdentityStore, SurrealNostrEventOffsetStore, SurrealNotificationStore,
     bill::{BillChainStoreApi, BillStoreApi},
     company::{CompanyChainStoreApi, CompanyStoreApi},
     file_upload::FileUploadStoreApi,
@@ -15,6 +14,7 @@ use log::error;
 use std::sync::Arc;
 
 pub use bcr_ebill_persistence::Error;
+#[cfg(not(target_arch = "wasm32"))]
 pub use bcr_ebill_persistence::backup;
 pub use bcr_ebill_persistence::bill;
 pub use bcr_ebill_persistence::company;
@@ -47,11 +47,22 @@ pub async fn get_db_context(conf: &Config) -> bcr_ebill_persistence::Result<DbCo
     let db = get_surreal_db(&surreal_db_config).await?;
 
     let company_store = Arc::new(SurrealCompanyStore::new(db.clone()));
+    #[cfg(target_arch = "wasm32")]
     let file_upload_store =
-        Arc::new(FileUploadStore::new(&conf.data_dir, "files", "temp_upload").await?);
+        Arc::new(bcr_ebill_persistence::db::file_upload::FileUploadStore::new(db.clone()));
+
+    #[cfg(not(target_arch = "wasm32"))]
+    let file_upload_store = Arc::new(
+        bcr_ebill_persistence::file_upload::FileUploadStore::new(
+            &conf.data_dir,
+            "files",
+            "temp_upload",
+        )
+        .await?,
+    );
 
     if let Err(e) = file_upload_store.cleanup_temp_uploads().await {
-        error!("Error cleaning up temp upload folder for bill: {e}");
+        error!("Error cleaning up temp uploads: {e}");
     }
 
     let contact_store = Arc::new(SurrealContactStore::new(db.clone()));

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

@@ -1,3 +1,4 @@
+#![cfg(not(target_arch = "wasm32"))]
 use std::{path::Path, sync::Arc};
 
 use crate::{
@@ -8,6 +9,11 @@ use crate::{
 use super::{Error, Result};
 #[cfg(test)]
 use mockall::automock;
+use tokio::{
+    fs::File,
+    io::{AsyncReadExt, AsyncWriteExt},
+    sync::watch,
+};
 
 /// Allows to backup and restore the database as an encrypted file.
 #[cfg_attr(test, automock)]
@@ -25,18 +31,21 @@ pub struct BackupService {
     store: Arc<dyn BackupStoreApi>,
     identity_store: Arc<dyn IdentityStoreApi>,
     surreal_db_config: SurrealDbConfig,
+    reboot_sender: watch::Sender<bool>,
 }
 
 impl BackupService {
     pub fn new(
         store: Arc<dyn BackupStoreApi>,
         identity_store: Arc<dyn IdentityStoreApi>,
         surreal_db_config: SurrealDbConfig,
+        reboot_sender: watch::Sender<bool>,
     ) -> Self {
         Self {
             store,
             identity_store,
             surreal_db_config,
+            reboot_sender,
         }
     }
 
@@ -66,21 +75,23 @@ impl BackupServiceApi for BackupService {
     }
 
     async fn restore(&self, file_path: &Path) -> Result<()> {
-        // TODO WASM: implement without file system access
-        let _private_key = self
+        let private_key = self
             .identity_store
             .get_key_pair()
             .await?
             .get_private_key_string();
-        let _buffer: Vec<u8> = vec![];
-        // let mut file = File::open(file_path).await?;
-        // file.read_to_end(&mut buffer).await?;
-        // let decrypted_bytes = util::crypto::decrypt_ecies(&buffer, &private_key)?;
+        let mut buffer = vec![];
+        let mut file = File::open(file_path).await?;
+        file.read_to_end(&mut buffer).await?;
+        let decrypted_bytes = util::crypto::decrypt_ecies(&buffer, &private_key)?;
         let out_path = file_path.with_file_name("restore.surql");
-        // let mut out = File::create(out_path.as_path()).await?;
-        // out.write_all(&decrypted_bytes).await?;
+        let mut out = File::create(out_path.as_path()).await?;
+        out.write_all(&decrypted_bytes).await?;
         self.store.drop_db(&self.surreal_db_config.database).await?;
         self.store.restore(out_path.as_path()).await?;
+        self.reboot_sender
+            .send(true)
+            .expect("Can initiate a reboot");
         Ok(())
     }
 }
@@ -117,8 +128,13 @@ mod tests {
             .returning(|| Ok(vec![0, 1, 0, 1, 0, 0, 1, 0]))
             .once();
 
-        let service =
-            BackupService::new(Arc::new(store), Arc::new(identity_store), surreal_db_config);
+        let (tx, _) = watch::channel(false);
+        let service = BackupService::new(
+            Arc::new(store),
+            Arc::new(identity_store),
+            surreal_db_config,
+            tx,
+        );
 
         let result = service.backup().await;
         assert!(result.is_ok());
@@ -136,9 +152,13 @@ mod tests {
 
         identity_store.expect_get_key_pair().never();
         store.expect_backup().never();
-
-        let service =
-            BackupService::new(Arc::new(store), Arc::new(identity_store), surreal_db_config);
+        let (tx, _) = watch::channel(false);
+        let service = BackupService::new(
+            Arc::new(store),
+            Arc::new(identity_store),
+            surreal_db_config,
+            tx,
+        );
 
         let result = service.backup().await;
         assert!(result.is_err());
@@ -173,7 +193,7 @@ DEFINE TABLE bill_chain TYPE ANY SCHEMALESS PERMISSIONS NONE;";
 
         let temp_dir = env::temp_dir();
         let file_path = temp_dir.join("test.surql");
-        let mut test_file = tokio::fs::File::create(file_path.as_path()).await.unwrap();
+        let mut test_file = File::create(file_path.as_path()).await.unwrap();
         test_file.write_all(&encrypted_bytes).await.unwrap();
 
         identity_store
@@ -189,10 +209,18 @@ DEFINE TABLE bill_chain TYPE ANY SCHEMALESS PERMISSIONS NONE;";
 
         store.expect_restore().returning(|_| Ok(())).once();
 
-        let service =
-            BackupService::new(Arc::new(store), Arc::new(identity_store), surreal_db_config);
+        let (tx, mut rx) = watch::channel(false);
+        let service = BackupService::new(
+            Arc::new(store),
+            Arc::new(identity_store),
+            surreal_db_config,
+            tx,
+        );
 
         let result = service.restore(&temp_dir.join("test.surql")).await;
         assert!(result.is_ok());
+
+        let should_reboot = *rx.borrow_and_update();
+        assert!(should_reboot);
     }
 }

crates/bcr-ebill-persistence/Cargo.toml

@@ -27,6 +27,7 @@ surrealdb = { version = "2.2", default-features = false, features = ["kv-indxdb"
 # Enable "protocol-ws" for all other targets
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 surrealdb = { version = "2.2", default-features = false, features = ["protocol-ws"] }
+tokio.workspace = true
 
 [dev-dependencies]
 surrealdb = { version = "2.2.0", features = ["kv-mem"], default-features = false }

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

@@ -14,3 +14,6 @@ pub const DB_OP_CODE: &str = "op_code";
 pub const DB_COMPANY_ID: &str = "company_id";
 pub const DB_BILL_ID: &str = "bill_id";
 pub const DB_SEARCH_TERM: &str = "search_term";
+
+pub const DB_ENTITY_ID: &str = "entity_id";
+pub const DB_FILE_NAME: &str = "file_name";