feat: add persistance for the storage (#65)

Author: naderramez

hoddor/src/file_system.rs

@@ -1,26 +1,12 @@
-use crate::console::log;
 use crate::errors::VaultError;
-use crate::global::get_global_scope;
+use crate::{console::log, global::get_storage_manager};
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::JsFuture;
 
-use web_sys::{
-    self, FileSystemDirectoryHandle, FileSystemFileHandle, FileSystemGetFileOptions,
-    WorkerGlobalScope,
-};
+use web_sys::{self, FileSystemDirectoryHandle, FileSystemFileHandle, FileSystemGetFileOptions};
 
 pub async fn get_root_directory_handle() -> Result<FileSystemDirectoryHandle, VaultError> {
-    let global = get_global_scope()?;
-
-    let storage = if let Ok(worker) = global.clone().dyn_into::<WorkerGlobalScope>() {
-        worker.navigator().storage()
-    } else if let Ok(window) = global.dyn_into::<web_sys::Window>() {
-        window.navigator().storage()
-    } else {
-        return Err(VaultError::IoError {
-            message: "Could not access navigator",
-        });
-    };
+    let storage = get_storage_manager()?;
 
     let dir_promise = storage.get_directory();
     let dir_handle = JsFuture::from(dir_promise)

hoddor/src/global.rs

@@ -1,7 +1,7 @@
 use crate::errors::VaultError;
 use wasm_bindgen::prelude::JsValue;
 use wasm_bindgen::prelude::*;
-use web_sys::{self, Window, WorkerGlobalScope};
+use web_sys::{self, StorageManager, Window, WorkerGlobalScope};
 
 pub fn get_global_scope() -> Result<JsValue, VaultError> {
     // Try worker scope first
@@ -22,3 +22,19 @@ pub fn window() -> Window {
         .dyn_into::<Window>()
         .expect("Unable to retrieve window")
 }
+
+pub fn get_storage_manager() -> Result<StorageManager, VaultError> {
+    let global = get_global_scope()?;
+
+    let storage = if let Ok(worker) = global.clone().dyn_into::<WorkerGlobalScope>() {
+        worker.navigator().storage()
+    } else if let Ok(window) = global.dyn_into::<web_sys::Window>() {
+        window.navigator().storage()
+    } else {
+        return Err(VaultError::IoError {
+            message: "Could not access navigator",
+        });
+    };
+
+    Ok(storage)
+}

hoddor/src/lib.rs

@@ -7,6 +7,7 @@ pub mod file_system;
 pub mod global;
 pub mod lock;
 pub mod measure;
+pub mod persistence;
 pub mod signaling;
 pub mod sync;
 pub mod vault;

hoddor/src/persistence.rs

@@ -0,0 +1,48 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use wasm_bindgen_futures::JsFuture;
+
+use crate::{errors::VaultError, global::get_storage_manager};
+
+static PERSISTENCE_REQUESTED: AtomicBool = AtomicBool::new(false);
+
+pub fn has_requested_persistence() -> bool {
+    PERSISTENCE_REQUESTED.load(Ordering::Relaxed)
+}
+
+pub fn mark_persistence_requested() {
+    PERSISTENCE_REQUESTED.store(true, Ordering::Relaxed);
+}
+
+pub async fn request_persistence_storage() -> Result<bool, VaultError> {
+    mark_persistence_requested();
+
+    let storage = get_storage_manager()?;
+
+    let persist_promise = if let Ok(promise) = storage.persist() {
+        promise
+    } else {
+        return Err(VaultError::JsError(
+            "Unable to obtain a local storage shelf".to_string(),
+        ));
+    };
+
+    let result = JsFuture::from(persist_promise).await?;
+
+    Ok(result.as_bool().unwrap_or(false))
+}
+
+pub async fn check_storage_persistence() -> Result<bool, VaultError> {
+    let storage = get_storage_manager()?;
+    let persisted_promise = if let Ok(promise) = storage.persisted() {
+        promise
+    } else {
+        return Err(VaultError::JsError(
+            "Unable to obtain a local storage shelf".to_string(),
+        ));
+    };
+    let result = JsFuture::from(persisted_promise).await?;
+    let is_persisted = result.as_bool().unwrap_or(false);
+
+    Ok(is_persisted)
+}

hoddor/src/vault.rs

@@ -9,6 +9,9 @@ use crate::file_system::{
 use crate::lock::acquire_vault_lock;
 use crate::measure::get_performance;
 use crate::measure::time_it;
+use crate::persistence::{
+    check_storage_persistence, has_requested_persistence, request_persistence_storage,
+};
 use crate::sync::{get_sync_manager, OperationType, SyncMessage};
 use crate::webrtc::{AccessLevel, WebRtcPeer};
 use std::cell::RefCell;
@@ -289,7 +292,7 @@ pub async fn upsert_vault(
                     operation,
                     Some(vault.metadata.clone()),
                     Some(vault.identity_salts.clone()),
-                    Some(vault.username_pk.clone())
+                    Some(vault.username_pk.clone()),
                 );
 
                 let peers = sync_manager.get_peers_mut();
@@ -689,12 +692,9 @@ pub async fn import_vault(vault_name: &str, data: JsValue) -> Result<(), JsValue
 
 pub async fn get_vault(vault_name: &str) -> Result<(FileSystemDirectoryHandle, Vault), JsValue> {
     let dirname = get_vault_dirname(vault_name);
-    read_vault_with_name(&dirname).await.map_err(|_| {
-        JsValue::from_str(&format!(
-            "Vault '{}' does not exist",
-            vault_name
-        ))
-    })
+    read_vault_with_name(&dirname)
+        .await
+        .map_err(|_| JsValue::from_str(&format!("Vault '{}' does not exist", vault_name)))
 }
 
 pub async fn read_vault_with_name(
@@ -836,6 +836,24 @@ pub async fn save_vault(
     dir_handle: &FileSystemDirectoryHandle,
     vault: Vault,
 ) -> Result<(), VaultError> {
+    if !has_requested_persistence() {
+        let is_persisted = check_storage_persistence().await.unwrap_or(false);
+
+        if !is_persisted {
+            let result = request_persistence_storage().await;
+
+            match result {
+                Ok(is_granted) => {
+                    console::log(&format!("persistence request granted: {}", is_granted));
+                }
+                Err(VaultError::JsError(message)) => {
+                    console::error(&message);
+                }
+                _ => {}
+            }
+        }
+    }
+
     let mut namespace_data = Vec::new();
     for (namespace, data) in &vault.namespaces {
         let namespace_json = serde_json::to_string(&data).map_err(|_| VaultError::IoError {
@@ -1316,7 +1334,7 @@ pub async fn update_vault_from_sync(vault_name: &str, vault_data: &[u8]) -> Resu
                     .unwrap_or_else(IdentitySalts::new),
                 username_pk: match sync_msg.username_pk {
                     Some(username_pk) => username_pk,
-                    None => HashMap::new()
+                    None => HashMap::new(),
                 },
                 namespaces: HashMap::new(),
                 sync_enabled: true,

playground/src/components/VaultsActions.tsx

@@ -3,6 +3,7 @@ import Upload, { RcFile } from 'antd/es/upload';
 import { useState } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 
+import { create_vault } from '../../../hoddor/pkg/hoddor';
 import { actions } from './../store/app.actions';
 import { appSelectors } from './../store/app.selectors';
 import { VaultWorker } from './../vault';
@@ -21,7 +22,7 @@ export const VaultsActions = () => {
   const [isModalOpen, setIsModalOpen] = useState(false);
 
   const handleCreation = async (value: FieldType) => {
-    await vaultWorker.createVault(value.vaultName || 'default');
+    await create_vault(value.vaultName || 'default');
     dispatch(actions.setVaults(await vaultWorker.listVaults()));
 
     messageApi.success(`Vault ${value.vaultName} created.`);
@@ -61,7 +62,7 @@ export const VaultsActions = () => {
         );
 
         dispatch(actions.setVaults(await vaultWorker.listVaults()));
-        
+
         messageApi.success(`Vault ${vaultName} imported.`);
       } catch (error) {
         messageApi.error(`Failed to import vault ${vaultName}: ${error}`);

playground/src/components/VaultsMenu.tsx

@@ -2,9 +2,9 @@ import { Menu } from 'antd';
 import { useEffect } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 
+import { VaultWorker } from '../vault';
 import { actions } from './../store/app.actions';
 import { appSelectors } from './../store/app.selectors';
-import { VaultWorker } from '../vault';
 
 const vaultWorker = new VaultWorker();
 
@@ -20,7 +20,7 @@ export const VaultsMenu = () => {
     if (!vaults.length) {
       getVaultsList();
     }
-  }, [vaults]);
+  }, [vaults.length]);
 
   return (
     !!vaults.length && (