max
/
tauri-plugins-workspace
mirror of https://github.com/tauri-apps/plugins-workspace
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat(store): expose Store to Rust code (#108)

Browse Source 
* feat(store): expose Store to Rust code in a meaningful way

* manually implement Default to improve generic inference

* update readme

* rename method

* make error Send and Sync

* make `use_store` more ergonomic

* export JsonValue

* fix readme example

* fmt

---------

Co-authored-by: FabianLars <fabianlars@fabianlars.de>
pull/270/head
Jonas Kruckenberg 2 years ago committed by GitHub
parent 6d7b985b46
commit d4223f6fd2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 236 additions and 144 deletions
Show Stats Download Patch File Download Diff File

33
plugins/store/README.md
Unescape View File

@ -61,6 +61,39 @@ const val = await store.get("some-key");
assert(val, { value: 5 }); assert(val, { value: 5 });
``` ```
## Usage from Rust
You can also access Stores from Rust, you can create new stores:
```rust
use tauri_plugin_store::store::StoreBuilder;
use serde_json::json;
fn main() {
tauri::Builder::default()
.plugin(tauri_plugin_store::Builder::default().build())
.setup(|app| {
let mut store = StoreBuilder::new(app.handle(), "path/to/store.bin".parse()?).build();
store.insert("a".to_string(), json!("b")) // note that values must be serd_json::Value to be compatible with JS
})
.run(tauri::generate_context!())
.expect("error while running tauri application");
}
```
As you may have noticed, the Store crated above isn't accessible to the frontend. To interoperate with stores created by JS use the exported `with_store` method:
```rust
use tauri::Wry;
use tauri_plugin_store::with_store;
let stores = app.state::<StoreCollection<Wry>>();
let path = PathBuf::from("path/to/the/storefile");
with_store(app_handle, stores, path, |store| store.set("a".to_string(), json!("b")))
```
## Contributing ## Contributing
PRs accepted. Please make sure to read the Contributing Guide before making a pull request. PRs accepted. Please make sure to read the Contributing Guide before making a pull request.

7
plugins/store/src/error.rs
Unescape View File

@ -10,9 +10,9 @@ use std::path::PathBuf;
#[non_exhaustive] #[non_exhaustive]
pub enum Error { pub enum Error {
#[error("Failed to serialize store. {0}")] #[error("Failed to serialize store. {0}")]
Serialize(Box<dyn std::error::Error>), Serialize(Box<dyn std::error::Error + Send + Sync>),
#[error("Failed to deserialize store. {0}")] #[error("Failed to deserialize store. {0}")]
Deserialize(Box<dyn std::error::Error>), Deserialize(Box<dyn std::error::Error + Send + Sync>),
/// JSON error. /// JSON error.
#[error(transparent)] #[error(transparent)]
Json(#[from] serde_json::Error), Json(#[from] serde_json::Error),
@ -22,6 +22,9 @@ pub enum Error {
/// Store not found /// Store not found
#[error("Store \"{0}\" not found")] #[error("Store \"{0}\" not found")]
NotFound(PathBuf), NotFound(PathBuf),
/// Some Tauri API failed
#[error(transparent)]
Tauri(#[from] tauri::Error),
} }
impl Serialize for Error { impl Serialize for Error {

196
plugins/store/src/lib.rs
Unescape View File

@ -5,251 +5,201 @@
pub use error::Error; pub use error::Error;
use log::warn; use log::warn;
use serde::Serialize; use serde::Serialize;
use serde_json::Value as JsonValue; pub use serde_json::Value as JsonValue;
use std::{collections::HashMap, path::PathBuf, sync::Mutex}; use std::{
collections::HashMap,
path::{Path, PathBuf},
sync::Mutex,
};
pub use store::{Store, StoreBuilder}; pub use store::{Store, StoreBuilder};
use tauri::{ use tauri::{
plugin::{self, TauriPlugin}, plugin::{self, TauriPlugin},
AppHandle, Manager, RunEvent, Runtime, State, Window, AppHandle, Manager, RunEvent, Runtime, State,
}; };
mod error; mod error;
mod store; mod store;
#[derive(Serialize, Clone)] #[derive(Serialize, Clone)]
struct ChangePayload { struct ChangePayload<'a> {
path: PathBuf, path: &'a Path,
key: String, key: &'a str,
value: JsonValue, value: &'a JsonValue,
} }
#[derive(Default)] #[derive(Default)]
struct StoreCollection { pub struct StoreCollection<R: Runtime> {
stores: Mutex<HashMap<PathBuf, Store>>, stores: Mutex<HashMap<PathBuf, Store<R>>>,
frozen: bool, frozen: bool,
} }
fn with_store<R: Runtime, T, F: FnOnce(&mut Store) -> Result<T, Error>>( pub fn with_store<R: Runtime, T, F: FnOnce(&mut Store<R>) -> Result<T, Error>>(
app: &AppHandle<R>, app: AppHandle<R>,
collection: State<'_, StoreCollection>, collection: State<'_, StoreCollection<R>>,
path: PathBuf, path: impl AsRef<Path>,
f: F, f: F,
) -> Result<T, Error> { ) -> Result<T, Error> {
let mut stores = collection.stores.lock().expect("mutex poisoned"); let mut stores = collection.stores.lock().expect("mutex poisoned");
if !stores.contains_key(&path) { let path = path.as_ref();
if !stores.contains_key(path) {
if collection.frozen { if collection.frozen {
return Err(Error::NotFound(path)); return Err(Error::NotFound(path.to_path_buf()));
} }
let mut store = StoreBuilder::new(path.clone()).build(); let mut store = StoreBuilder::new(app, path.to_path_buf()).build();
// ignore loading errors, just use the default // ignore loading errors, just use the default
if let Err(err) = store.load(app) { if let Err(err) = store.load() {
warn!( warn!(
"Failed to load store {:?} from disk: {}. Falling back to default values.", "Failed to load store {:?} from disk: {}. Falling back to default values.",
path, err path, err
); );
} }
stores.insert(path.clone(), store); stores.insert(path.to_path_buf(), store);
} }
f(stores f(stores
.get_mut(&path) .get_mut(path)
.expect("failed to retrieve store. This is a bug!")) .expect("failed to retrieve store. This is a bug!"))
} }
#[tauri::command] #[tauri::command]
async fn set<R: Runtime>( async fn set<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
window: Window<R>, stores: State<'_, StoreCollection<R>>,
stores: State<'_, StoreCollection>,
path: PathBuf, path: PathBuf,
key: String, key: String,
value: JsonValue, value: JsonValue,
) -> Result<(), Error> { ) -> Result<(), Error> {
with_store(&app, stores, path.clone(), |store| { with_store(app, stores, path, |store| store.insert(key, value))
store.cache.insert(key.clone(), value.clone());
let _ = window.emit("store://change", ChangePayload { path, key, value });
Ok(())
})
} }
#[tauri::command] #[tauri::command]
async fn get<R: Runtime>( async fn get<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
stores: State<'_, StoreCollection>, stores: State<'_, StoreCollection<R>>,
path: PathBuf, path: PathBuf,
key: String, key: String,
) -> Result<Option<JsonValue>, Error> { ) -> Result<Option<JsonValue>, Error> {
with_store(&app, stores, path, |store| { with_store(app, stores, path, |store| Ok(store.get(key).cloned()))
Ok(store.cache.get(&key).cloned())
})
} }
#[tauri::command] #[tauri::command]
async fn has<R: Runtime>( async fn has<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
stores: State<'_, StoreCollection>, stores: State<'_, StoreCollection<R>>,
path: PathBuf, path: PathBuf,
key: String, key: String,
) -> Result<bool, Error> { ) -> Result<bool, Error> {
with_store(&app, stores, path, |store| { with_store(app, stores, path, |store| Ok(store.has(key)))
Ok(store.cache.contains_key(&key))
})
} }
#[tauri::command] #[tauri::command]
async fn delete<R: Runtime>( async fn delete<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
window: Window<R>, stores: State<'_, StoreCollection<R>>,
stores: State<'_, StoreCollection>,
path: PathBuf, path: PathBuf,
key: String, key: String,
) -> Result<bool, Error> { ) -> Result<bool, Error> {
with_store(&app, stores, path.clone(), |store| { with_store(app, stores, path, |store| store.delete(key))
let flag = store.cache.remove(&key).is_some();
if flag {
let _ = window.emit(
"store://change",
ChangePayload {
path,
key,
value: JsonValue::Null,
},
);
}
Ok(flag)
})
} }
#[tauri::command] #[tauri::command]
async fn clear<R: Runtime>( async fn clear<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
window: Window<R>, stores: State<'_, StoreCollection<R>>,
stores: State<'_, StoreCollection>,
path: PathBuf, path: PathBuf,
) -> Result<(), Error> { ) -> Result<(), Error> {
with_store(&app, stores, path.clone(), |store| { with_store(app, stores, path, |store| store.clear())
let keys = store.cache.keys().cloned().collect::<Vec<String>>();
store.cache.clear();
for key in keys {
let _ = window.emit(
"store://change",
ChangePayload {
path: path.clone(),
key,
value: JsonValue::Null,
},
);
}
Ok(())
})
} }
#[tauri::command] #[tauri::command]
async fn reset<R: Runtime>( async fn reset<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
window: Window<R>, collection: State<'_, StoreCollection<R>>,
collection: State<'_, StoreCollection>,
path: PathBuf, path: PathBuf,
) -> Result<(), Error> { ) -> Result<(), Error> {
let has_defaults = collection with_store(app, collection, path, |store| store.reset())
.stores
.lock()
.expect("mutex poisoned")
.get(&path)
.map(|store| store.defaults.is_some());
if Some(true) == has_defaults {
with_store(&app, collection, path.clone(), |store| {
if let Some(defaults) = &store.defaults {
for (key, value) in &store.cache {
if defaults.get(key) != Some(value) {
let _ = window.emit(
"store://change",
ChangePayload {
path: path.clone(),
key: key.clone(),
value: defaults.get(key).cloned().unwrap_or(JsonValue::Null),
},
);
}
}
store.cache = defaults.clone();
}
Ok(())
})
} else {
clear(app, window, collection, path).await
}
} }
#[tauri::command] #[tauri::command]
async fn keys<R: Runtime>( async fn keys<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
stores: State<'_, StoreCollection>, stores: State<'_, StoreCollection<R>>,
path: PathBuf, path: PathBuf,
) -> Result<Vec<String>, Error> { ) -> Result<Vec<String>, Error> {
with_store(&app, stores, path, |store| { with_store(app, stores, path, |store| {
Ok(store.cache.keys().cloned().collect()) Ok(store.keys().cloned().collect())
}) })
} }
#[tauri::command] #[tauri::command]
async fn values<R: Runtime>( async fn values<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
stores: State<'_, StoreCollection>, stores: State<'_, StoreCollection<R>>,
path: PathBuf, path: PathBuf,
) -> Result<Vec<JsonValue>, Error> { ) -> Result<Vec<JsonValue>, Error> {
with_store(&app, stores, path, |store| { with_store(app, stores, path, |store| {
Ok(store.cache.values().cloned().collect()) Ok(store.values().cloned().collect())
}) })
} }
#[tauri::command] #[tauri::command]
async fn entries<R: Runtime>( async fn entries<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
stores: State<'_, StoreCollection>, stores: State<'_, StoreCollection<R>>,
path: PathBuf, path: PathBuf,
) -> Result<Vec<(String, JsonValue)>, Error> { ) -> Result<Vec<(String, JsonValue)>, Error> {
with_store(&app, stores, path, |store| { with_store(app, stores, path, |store| {
Ok(store.cache.clone().into_iter().collect()) Ok(store
.entries()
.map(|(k, v)| (k.to_owned(), v.to_owned()))
.collect())
}) })
} }
#[tauri::command] #[tauri::command]
async fn length<R: Runtime>( async fn length<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
stores: State<'_, StoreCollection>, stores: State<'_, StoreCollection<R>>,
path: PathBuf, path: PathBuf,
) -> Result<usize, Error> { ) -> Result<usize, Error> {
with_store(&app, stores, path, |store| Ok(store.cache.len())) with_store(app, stores, path, |store| Ok(store.len()))
} }
#[tauri::command] #[tauri::command]
async fn load<R: Runtime>( async fn load<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
stores: State<'_, StoreCollection>, stores: State<'_, StoreCollection<R>>,
path: PathBuf, path: PathBuf,
) -> Result<(), Error> { ) -> Result<(), Error> {
with_store(&app, stores, path, |store| store.load(&app)) with_store(app, stores, path, |store| store.load())
} }
#[tauri::command] #[tauri::command]
async fn save<R: Runtime>( async fn save<R: Runtime>(
app: AppHandle<R>, app: AppHandle<R>,
stores: State<'_, StoreCollection>, stores: State<'_, StoreCollection<R>>,
path: PathBuf, path: PathBuf,
) -> Result<(), Error> { ) -> Result<(), Error> {
with_store(&app, stores, path, |store| store.save(&app)) with_store(app, stores, path, |store| store.save())
} }
#[derive(Default)] // #[derive(Default)]
pub struct Builder { pub struct Builder<R: Runtime> {
stores: HashMap<PathBuf, Store>, stores: HashMap<PathBuf, Store<R>>,
frozen: bool, frozen: bool,
} }
impl Builder { impl<R: Runtime> Default for Builder<R> {
fn default() -> Self {
Self {
stores: Default::default(),
frozen: false,
}
}
}
impl<R: Runtime> Builder<R> {
/// Registers a store with the plugin. /// Registers a store with the plugin.
/// ///
/// # Examples /// # Examples
@ -265,7 +215,7 @@ impl Builder {
/// # Ok(()) /// # Ok(())
/// # } /// # }
/// ``` /// ```
pub fn store(mut self, store: Store) -> Self { pub fn store(mut self, store: Store<R>) -> Self {
self.stores.insert(store.path.clone(), store); self.stores.insert(store.path.clone(), store);
self self
} }
@ -285,7 +235,7 @@ impl Builder {
/// # Ok(()) /// # Ok(())
/// # } /// # }
/// ``` /// ```
pub fn stores<T: IntoIterator<Item = Store>>(mut self, stores: T) -> Self { pub fn stores<T: IntoIterator<Item = Store<R>>>(mut self, stores: T) -> Self {
self.stores = stores self.stores = stores
.into_iter() .into_iter()
.map(|store| (store.path.clone(), store)) .map(|store| (store.path.clone(), store))
@ -331,7 +281,7 @@ impl Builder {
/// # Ok(()) /// # Ok(())
/// # } /// # }
/// ``` /// ```
pub fn build<R: Runtime>(mut self) -> TauriPlugin<R> { pub fn build(mut self) -> TauriPlugin<R> {
plugin::Builder::new("store") plugin::Builder::new("store")
.invoke_handler(tauri::generate_handler![ .invoke_handler(tauri::generate_handler![
set, get, has, delete, clear, reset, keys, values, length, entries, load, save set, get, has, delete, clear, reset, keys, values, length, entries, load, save
@ -339,7 +289,7 @@ impl Builder {
.setup(move |app_handle| { .setup(move |app_handle| {
for (path, store) in self.stores.iter_mut() { for (path, store) in self.stores.iter_mut() {
// ignore loading errors, just use the default // ignore loading errors, just use the default
if let Err(err) = store.load(app_handle) { if let Err(err) = store.load() {
warn!( warn!(
"Failed to load store {:?} from disk: {}. Falling back to default values.", "Failed to load store {:?} from disk: {}. Falling back to default values.",
path, err path, err
@ -356,10 +306,10 @@ impl Builder {
}) })
.on_event(|app_handle, event| { .on_event(|app_handle, event| {
if let RunEvent::Exit = event { if let RunEvent::Exit = event {
let collection = app_handle.state::<StoreCollection>(); let collection = app_handle.state::<StoreCollection<R>>();
for store in collection.stores.lock().expect("mutex poisoned").values() { for store in collection.stores.lock().expect("mutex poisoned").values() {
if let Err(err) = store.save(app_handle) { if let Err(err) = store.save() {
eprintln!("failed to save store {:?} with error {:?}", store.path, err); eprintln!("failed to save store {:?} with error {:?}", store.path, err);
} }
} }

144
plugins/store/src/store.rs
Unescape View File

@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
use crate::Error; use crate::{ChangePayload, Error};
use serde_json::Value as JsonValue; use serde_json::Value as JsonValue;
use std::{ use std::{
collections::HashMap, collections::HashMap,
@ -10,25 +10,28 @@ use std::{
io::Write, io::Write,
path::PathBuf, path::PathBuf,
}; };
use tauri::{AppHandle, Runtime}; use tauri::{AppHandle, Manager, Runtime};
type SerializeFn = fn(&HashMap<String, JsonValue>) -> Result<Vec<u8>, Box<dyn std::error::Error>>; type SerializeFn =
type DeserializeFn = fn(&[u8]) -> Result<HashMap<String, JsonValue>, Box<dyn std::error::Error>>; fn(&HashMap<String, JsonValue>) -> Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>>;
type DeserializeFn =
fn(&[u8]) -> Result<HashMap<String, JsonValue>, Box<dyn std::error::Error + Send + Sync>>;
fn default_serialize( fn default_serialize(
cache: &HashMap<String, JsonValue>, cache: &HashMap<String, JsonValue>,
) -> Result<Vec<u8>, Box<dyn std::error::Error>> { ) -> Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>> {
Ok(serde_json::to_vec(&cache)?) Ok(serde_json::to_vec(&cache)?)
} }
fn default_deserialize( fn default_deserialize(
bytes: &[u8], bytes: &[u8],
) -> Result<HashMap<String, JsonValue>, Box<dyn std::error::Error>> { ) -> Result<HashMap<String, JsonValue>, Box<dyn std::error::Error + Send + Sync>> {
serde_json::from_slice(bytes).map_err(Into::into) serde_json::from_slice(bytes).map_err(Into::into)
} }
/// Builds a [`Store`] /// Builds a [`Store`]
pub struct StoreBuilder { pub struct StoreBuilder<R: Runtime> {
app: AppHandle<R>,
path: PathBuf, path: PathBuf,
defaults: Option<HashMap<String, JsonValue>>, defaults: Option<HashMap<String, JsonValue>>,
cache: HashMap<String, JsonValue>, cache: HashMap<String, JsonValue>,
@ -36,7 +39,7 @@ pub struct StoreBuilder {
deserialize: DeserializeFn, deserialize: DeserializeFn,
} }
impl StoreBuilder { impl<R: Runtime> StoreBuilder<R> {
/// Creates a new [`StoreBuilder`]. /// Creates a new [`StoreBuilder`].
/// ///
/// # Examples /// # Examples
@ -49,8 +52,9 @@ impl StoreBuilder {
/// # Ok(()) /// # Ok(())
/// # } /// # }
/// ``` /// ```
pub fn new(path: PathBuf) -> Self { pub fn new(app: AppHandle<R>, path: PathBuf) -> Self {
Self { Self {
app,
path, path,
defaults: None, defaults: None,
cache: Default::default(), cache: Default::default(),
@ -147,8 +151,9 @@ impl StoreBuilder {
/// ///
/// # Ok(()) /// # Ok(())
/// # } /// # }
pub fn build(self) -> Store { pub fn build(self) -> Store<R> {
Store { Store {
app: self.app,
path: self.path, path: self.path,
defaults: self.defaults, defaults: self.defaults,
cache: self.cache, cache: self.cache,
@ -159,18 +164,20 @@ impl StoreBuilder {
} }
#[derive(Clone)] #[derive(Clone)]
pub struct Store { pub struct Store<R: Runtime> {
app: AppHandle<R>,
pub(crate) path: PathBuf, pub(crate) path: PathBuf,
pub(crate) defaults: Option<HashMap<String, JsonValue>>, defaults: Option<HashMap<String, JsonValue>>,
pub(crate) cache: HashMap<String, JsonValue>, cache: HashMap<String, JsonValue>,
serialize: SerializeFn, serialize: SerializeFn,
deserialize: DeserializeFn, deserialize: DeserializeFn,
} }
impl Store { impl<R: Runtime> Store<R> {
/// Update the store from the on-disk state /// Update the store from the on-disk state
pub fn load<R: Runtime>(&mut self, app: &AppHandle<R>) -> Result<(), Error> { pub fn load(&mut self) -> Result<(), Error> {
let app_dir = app let app_dir = self
.app
.path_resolver() .path_resolver()
.app_data_dir() .app_data_dir()
.expect("failed to resolve app dir"); .expect("failed to resolve app dir");
@ -184,8 +191,9 @@ impl Store {
} }
/// Saves the store to disk /// Saves the store to disk
pub fn save<R: Runtime>(&self, app: &AppHandle<R>) -> Result<(), Error> { pub fn save(&self) -> Result<(), Error> {
let app_dir = app let app_dir = self
.app
.path_resolver() .path_resolver()
.app_data_dir() .app_data_dir()
.expect("failed to resolve app dir"); .expect("failed to resolve app dir");
@ -199,9 +207,107 @@ impl Store {
Ok(()) Ok(())
} }
pub fn insert(&mut self, key: String, value: JsonValue) -> Result<(), Error> {
self.cache.insert(key.clone(), value.clone());
self.app.emit_all(
"store://change",
ChangePayload {
path: &self.path,
key: &key,
value: &value,
},
)?;
Ok(())
}
pub fn get(&self, key: impl AsRef<str>) -> Option<&JsonValue> {
self.cache.get(key.as_ref())
}
pub fn has(&self, key: impl AsRef<str>) -> bool {
self.cache.contains_key(key.as_ref())
}
pub fn delete(&mut self, key: impl AsRef<str>) -> Result<bool, Error> {
let flag = self.cache.remove(key.as_ref()).is_some();
if flag {
self.app.emit_all(
"store://change",
ChangePayload {
path: &self.path,
key: key.as_ref(),
value: &JsonValue::Null,
},
)?;
}
Ok(flag)
}
pub fn clear(&mut self) -> Result<(), Error> {
let keys: Vec<String> = self.cache.keys().cloned().collect();
self.cache.clear();
for key in keys {
self.app.emit_all(
"store://change",
ChangePayload {
path: &self.path,
key: &key,
value: &JsonValue::Null,
},
)?;
}
Ok(())
}
pub fn reset(&mut self) -> Result<(), Error> {
let has_defaults = self.defaults.is_some();
if has_defaults {
if let Some(defaults) = &self.defaults {
for (key, value) in &self.cache {
if defaults.get(key) != Some(value) {
let _ = self.app.emit_all(
"store://change",
ChangePayload {
path: &self.path,
key,
value: defaults.get(key).unwrap_or(&JsonValue::Null),
},
);
}
}
self.cache = defaults.clone();
}
Ok(())
} else {
self.clear()
}
}
pub fn keys(&self) -> impl Iterator<Item = &String> {
self.cache.keys()
}
pub fn values(&self) -> impl Iterator<Item = &JsonValue> {
self.cache.values()
}
pub fn entries(&self) -> impl Iterator<Item = (&String, &JsonValue)> {
self.cache.iter()
}
pub fn len(&self) -> usize {
self.cache.len()
}
pub fn is_empty(&self) -> bool {
self.cache.is_empty()
}
} }
impl std::fmt::Debug for Store { impl<R: Runtime> std::fmt::Debug for Store<R> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Store") f.debug_struct("Store")
.field("path", &self.path) .field("path", &self.path)

Write Preview
Loading…
Cancel
Save