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 in a meaningful way

Browse Source
pull/108/head
Jonas Kruckenberg 3 years ago
parent 4ff7843581
commit 5e3646b636
4 changed files with 184 additions and 137 deletions
Show Stats Download Patch File Download Diff File

12
Cargo.lock generated
Unescape View File

@ -235,7 +235,7 @@ checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
dependencies = [ dependencies = [
"hermit-abi 0.1.19", "hermit-abi 0.1.19",
"libc", "libc",
"winapi 0.3.9", "winapi",
] ]
[[package]] [[package]]
@ -610,7 +610,7 @@ checksum = "f4ffc801dacf156c5854b9df4f425a626539c3a6ef7893cc0c5084a23f0b6c59"
dependencies = [ dependencies = [
"atty", "atty",
"lazy_static", "lazy_static",
"winapi 0.3.9", "winapi",
] ]
[[package]] [[package]]
@ -2458,7 +2458,7 @@ checksum = "f346ff70e7dbfd675fe90590b92d59ef2de15a8779ae305ebcbfd3f0caf59be4"
dependencies = [ dependencies = [
"autocfg", "autocfg",
"bitflags", "bitflags",
"cfg-if 1.0.0", "cfg-if",
"libc", "libc",
"memoffset", "memoffset",
"pin-utils", "pin-utils",
@ -3032,7 +3032,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "22122d5ec4f9fe1b3916419b76be1e80bcb93f618d071d2edf841b137b2a2bd6" checksum = "22122d5ec4f9fe1b3916419b76be1e80bcb93f618d071d2edf841b137b2a2bd6"
dependencies = [ dependencies = [
"autocfg", "autocfg",
"cfg-if 1.0.0", "cfg-if",
"libc", "libc",
"log", "log",
"wepoll-ffi", "wepoll-ffi",
@ -4869,7 +4869,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ce65604324d3cce9b966701489fbd0cf318cb1f7bd9dd07ac9a4ee6fb791930d" checksum = "ce65604324d3cce9b966701489fbd0cf318cb1f7bd9dd07ac9a4ee6fb791930d"
dependencies = [ dependencies = [
"tempfile", "tempfile",
"winapi 0.3.9", "winapi",
] ]
[[package]] [[package]]
@ -5598,7 +5598,7 @@ dependencies = [
"static_assertions", "static_assertions",
"tracing", "tracing",
"uds_windows", "uds_windows",
"winapi 0.3.9", "winapi",
"zbus_macros", "zbus_macros",
"zbus_names", "zbus_names",
"zvariant", "zvariant",

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

@ -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 {

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

@ -6,32 +6,36 @@ pub use error::Error;
use log::warn; use log::warn;
use serde::Serialize; use serde::Serialize;
use serde_json::Value as JsonValue; 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: PathBuf,
f: F, f: F,
) -> Result<T, Error> { ) -> Result<T, Error> {
@ -41,9 +45,9 @@ fn with_store<R: Runtime, T, F: FnOnce(&mut Store) -> Result<T, Error>>(
if collection.frozen { if collection.frozen {
return Err(Error::NotFound(path)); return Err(Error::NotFound(path));
} }
let mut store = StoreBuilder::new(path.clone()).build(); let mut store = StoreBuilder::new(app, path.clone()).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
@ -60,196 +64,132 @@ fn with_store<R: Runtime, T, F: FnOnce(&mut Store) -> Result<T, Error>>(
#[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.set(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> Builder<R> {
/// Registers a store with the plugin. /// Registers a store with the plugin.
/// ///
/// # Examples /// # Examples
@ -265,7 +205,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 +225,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 +271,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 +279,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 +296,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);
} }
} }

134
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,7 +10,7 @@ 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 = fn(&HashMap<String, JsonValue>) -> Result<Vec<u8>, Box<dyn std::error::Error>>;
type DeserializeFn = fn(&[u8]) -> Result<HashMap<String, JsonValue>, Box<dyn std::error::Error>>; type DeserializeFn = fn(&[u8]) -> Result<HashMap<String, JsonValue>, Box<dyn std::error::Error>>;
@ -28,7 +28,8 @@ fn default_deserialize(
} }
/// 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 +37,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 +50,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 +149,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 +162,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 +189,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 +205,107 @@ impl Store {
Ok(()) Ok(())
} }
pub fn set(&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