refactor(store)!: more reworks

.changes/store-plugin-rework-js-feat.md

@@ -0,0 +1,7 @@
+---
+"store-js": minor:feat
+---
+
+- Add `getStore`
+- Add an option to use pre-stored (de)serialize functions (registered on rust)
+- Add `LazyStore`

.changes/store-plugin-rework.md

@@ -0,0 +1,23 @@
+---
+"store": minor:breaking
+---
+
+### Breaking changes:
+
+- Renamed `StoreCollection` to `StoreState`
+- `StoreBuilder::build` now returns a `Result`
+- `StoreExt::store` now returns `Result<Arc<Store>>`
+
+### Enhancements:
+
+- Save and cancel pending auto save on drop
+- Use absolute path as store's key, fix #984
+- Share store to resource table by default
+- Enable auto save with 100ms debounce time by default
+- Use pretty json by default, close #1690
+
+### New features:
+
+- Add `get_store` to get shared stores across js and rust side
+- Add default (de)serialize functions settings `default_serialize_fn` and `default_deserialize_fn`
+- Allow js to use pre-stored (de)serialize functions registered by `register_serialize_fn` and `register_deserialize_fn`

examples/api/src-tauri/capabilities/base.json

@@ -79,10 +79,6 @@
       ],
       "deny": ["$APPDATA/db/*.stronghold"]
     },
-    "store:allow-entries",
-    "store:allow-get",
-    "store:allow-set",
-    "store:allow-save",
-    "store:allow-load"
+    "store:default"
   ]
 }

examples/api/src-tauri/src/lib.rs

@@ -67,7 +67,8 @@ pub fn run() {
                     .user_agent(&format!("Tauri API - {}", std::env::consts::OS))
                     .title("Tauri API Validation")
                     .inner_size(1000., 800.)
-                    .min_inner_size(600., 400.);
+                    .min_inner_size(600., 400.)
+                    .visible(false);
             }
 
             #[cfg(target_os = "windows")]

examples/api/src/views/Store.svelte

@@ -1,34 +1,71 @@
 <script>
-  import { Store } from "@tauri-apps/plugin-store";
+  import { LazyStore } from "@tauri-apps/plugin-store";
   import { onMount } from "svelte";
 
   export let onMessage;
 
   let key;
   let value;
 
-  const store = new Store("cache.json");
+  let store = new LazyStore("cache.json");
   let cache = {};
 
-  onMount(async () => {
-    await store.load();
-    const values = await store.entries();
-    for (const [key, value] of values) {
-      cache[key] = value;
+  async function refreshEntries() {
+    try {
+      const values = await store.entries();
+      cache = {};
+      for (const [key, value] of values) {
+        cache[key] = value;
+      }
+    } catch (error) {
+      onMessage(error);
     }
-    cache = cache;
+  }
+
+  onMount(async () => {
+    await refreshEntries();
   });
 
-  function write(key, value) {
-    store
-      .set(key, value)
-      .then(() => store.get(key))
-      .then((v) => {
-        cache[key] = v;
+  async function write(key, value) {
+    try {
+      if (value) {
+        await store.set(key, value);
+      } else {
+        await store.delete(key);
+      }
+      const v = await store.get(key);
+      if (v === undefined) {
+        delete cache[key];
         cache = cache;
-      })
-      .then(() => store.save())
-      .catch(onMessage);
+      } else {
+        cache[key] = v;
+      }
+    } catch (error) {
+      onMessage(error);
+    }
+  }
+
+  async function reset() {
+    try {
+      await store.reset();
+    } catch (error) {
+      onMessage(error);
+    }
+    await refreshEntries();
+  }
+
+  async function close() {
+    try {
+      await store.close();
+      onMessage("Store is now closed, any new operations will error out");
+    } catch (error) {
+      onMessage(error);
+    }
+  }
+
+  function reopen() {
+    store = new LazyStore("cache.json");
+    onMessage("We made a new `LazyStore` instance, operations will now work");
   }
 </script>
 
@@ -44,7 +81,12 @@
       <input class="grow input" bind:value />
     </div>
 
-    <button class="btn" on:click={() => write(key, value)}> Write </button>
+    <div>
+      <button class="btn" on:click={() => write(key, value)}>Write</button>
+      <button class="btn" on:click={() => reset()}>Reset</button>
+      <button class="btn" on:click={() => close()}>Close</button>
+      <button class="btn" on:click={() => reopen()}>Re-open</button>
+    </div>
   </div>
 
   <div>

plugins/store/README.md

@@ -68,9 +68,9 @@ fn main() {
 Afterwards all the plugin's APIs are available through the JavaScript guest bindings:
 
 ```typescript
-import { Store } from '@tauri-apps/plugin-store'
+import { createStore } from '@tauri-apps/plugin-store'
 
-const store = new Store('.settings.dat')
+const store = await createStore('settings.json')
 
 await store.set('some-key', { value: 5 })
 
@@ -81,14 +81,11 @@ if (val) {
 } else {
   console.log('val is null')
 }
-
-// This manually saves the store.
-await store.save()
 ```
 
 ### Persisting Values
 
-As seen above, values added to the store are not persisted between application loads unless the application is closed gracefully.
+Modifications made to the store are automatically saved by default
 
 You can manually save a store with:
 
@@ -103,65 +100,43 @@ However, you can also load them manually later like so:
 await store.load()
 ```
 
+### LazyStore
+
+There's also a high level API `LazyStore` which only loads the store on first access, note that the options will be ignored if a `Store` with that path has already been created
+
+```typescript
+import { LazyStore } from '@tauri-apps/plugin-store'
+
+const store = new LazyStore('settings.json')
+```
+
 ## Usage from Rust
 
 You can also create `Store` instances directly in Rust:
 
 ```rust
-use tauri_plugin_store::StoreBuilder;
+use tauri_plugin_store::StoreExt;
 use serde_json::json;
 
 fn main() {
     tauri::Builder::default()
         .plugin(tauri_plugin_store::Builder::default().build())
         .setup(|app| {
-            let mut store = StoreBuilder::new("app_data.bin").build(app.handle().clone());
-
-            // Attempt to load the store, if it's saved already.
-            store.load().expect("Failed to load store from disk");
+            // This loads the store from disk
+            let store = app.store("app_data.json")?;
 
             // Note that values must be serde_json::Value instances,
             // otherwise, they will not be compatible with the JavaScript bindings.
-            store.insert("a".to_string(), json!("b"));
-
-            // You can manually save the store after making changes.
-            // Otherwise, it will save upon graceful exit as described above.
-            store.save()
+            store.set("a".to_string(), json!("b"));
         })
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }
 ```
 
-### Loading Gracefully
-
-If you call `load` on a `Store` that hasn't yet been written to the disk, it will return an error. You must handle this error if you want to gracefully continue and use the default store until you save it to the disk. The example above shows how to do this.
-
-For example, this would cause a panic if the store has not yet been created:
-
-```rust
-store.load().unwrap();
-```
-
-Rather than silently continuing like you may expect.
-
-You should always handle the error appropriately rather than unwrapping, or you may experience unexpected app crashes:
-
-```rust
-store.load().expect("Failed to load store from disk");
-```
-
 ### Frontend Interoperability
 
-As you may have noticed, the `Store` crated above isn't accessible to the frontend. To interoperate with stores created by JavaScript use the exported `with_store` method:
-
-```rust
-use tauri::Wry;
-use tauri_plugin_store::StoreExt;
-
-let store = app.store_builder("app_data.bin").build();
-store.insert("key", "value");
-```
+The store created from both Rust side and JavaScript side are stored in the app's resource table and can be accessed by both sides, you can access it by using the same path, with `getStore` and `LazyStore` in the JavaScript side and `get_store` and `store` in the Rust side
 
 ## Contributing
 

plugins/store/build.rs

@@ -4,6 +4,9 @@
 
 const COMMANDS: &[&str] = &[
     "create_store",
+    "load",
+    "get_store",
+    "close_store",
     "set",
     "get",
     "has",
@@ -12,9 +15,9 @@ const COMMANDS: &[&str] = &[
     "reset",
     "keys",
     "values",
-    "length",
     "entries",
-    "load",
+    "length",
+    "reload",
     "save",
 ];
 

plugins/store/examples/AppSettingsManager/src-tauri/src/main.rs

@@ -5,9 +5,8 @@
 // Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-use std::time::Duration;
-
 use serde_json::json;
+use tauri::Listener;
 use tauri_plugin_store::StoreExt;
 
 mod app;
@@ -18,17 +17,11 @@ fn main() {
         .plugin(tauri_plugin_store::Builder::new().build())
         .setup(|app| {
             // Init store and load it from disk
-            let store = app
-                .handle()
-                .store_builder("settings.json")
-                .auto_save(Duration::from_millis(100))
-                .build();
-
-            // If there are no saved settings yet, this will return an error so we ignore the return value.
-            let _ = store.load();
-
+            let store = app.store("settings.json")?;
+            app.listen("store://change", |event| {
+                dbg!(event);
+            });
             let app_settings = AppSettings::load_from_store(&store);
-
             match app_settings {
                 Ok(app_settings) => {
                     let theme = app_settings.theme;

plugins/store/examples/AppSettingsManager/src-tauri/tauri.conf.json

@@ -3,6 +3,7 @@
   "version": "0.1.0",
   "identifier": "com.tauri.app-settings-manager",
   "build": {
+    "devUrl": "http://localhost:1420",
     "frontendDist": "../dist"
   },
   "app": {