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

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

@ -22,6 +22,9 @@ pub enum Error {
/// Store not found
#[error("Store \"{0}\" not found")]
NotFound(PathBuf),
/// Some Tauri API failed
#[error(transparent)]
Tauri(#[from] tauri::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 serde::Serialize;
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};
use tauri::{
plugin::{self, TauriPlugin},
AppHandle, Manager, RunEvent, Runtime, State, Window,
AppHandle, Manager, RunEvent, Runtime, State,
};
mod error;
mod store;
#[derive(Serialize, Clone)]
struct ChangePayload {
path: PathBuf,
key: String,
value: JsonValue,
struct ChangePayload<'a> {
path: &'a Path,
key: &'a str,
value: &'a JsonValue,
}
#[derive(Default)]
struct StoreCollection {
stores: Mutex<HashMap<PathBuf, Store>>,
pub struct StoreCollection<R: Runtime> {
stores: Mutex<HashMap<PathBuf, Store<R>>>,
frozen: bool,
}
fn with_store<R: Runtime, T, F: FnOnce(&mut Store) -> Result<T, Error>>(
app: &AppHandle<R>,
collection: State<'_, StoreCollection>,
pub fn with_store<R: Runtime, T, F: FnOnce(&mut Store<R>) -> Result<T, Error>>(
app: AppHandle<R>,
collection: State<'_, StoreCollection<R>>,
path: PathBuf,
f: F,
) -> Result<T, Error> {
@ -41,9 +45,9 @@ fn with_store<R: Runtime, T, F: FnOnce(&mut Store) -> Result<T, Error>>(
if collection.frozen {
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
if let Err(err) = store.load(app) {
if let Err(err) = store.load() {
warn!(
"Failed to load store {:?} from disk: {}. Falling back to default values.",
path, err
@ -60,196 +64,132 @@ fn with_store<R: Runtime, T, F: FnOnce(&mut Store) -> Result<T, Error>>(
#[tauri::command]
async fn set<R: Runtime>(
app: AppHandle<R>,
window: Window<R>,
stores: State<'_, StoreCollection>,
stores: State<'_, StoreCollection<R>>,
path: PathBuf,
key: String,
value: JsonValue,
) -> Result<(), Error> {
with_store(&app, stores, path.clone(), |store| {
store.cache.insert(key.clone(), value.clone());
let _ = window.emit("store://change", ChangePayload { path, key, value });
Ok(())
})
with_store(app, stores, path, |store| store.set(key, value))
}
#[tauri::command]
async fn get<R: Runtime>(
app: AppHandle<R>,
stores: State<'_, StoreCollection>,
stores: State<'_, StoreCollection<R>>,
path: PathBuf,
key: String,
) -> Result<Option<JsonValue>, Error> {
with_store(&app, stores, path, |store| {
Ok(store.cache.get(&key).cloned())
})
with_store(app, stores, path, |store| Ok(store.get(key).cloned()))
}
#[tauri::command]
async fn has<R: Runtime>(
app: AppHandle<R>,
stores: State<'_, StoreCollection>,
stores: State<'_, StoreCollection<R>>,
path: PathBuf,
key: String,
) -> Result<bool, Error> {
with_store(&app, stores, path, |store| {
Ok(store.cache.contains_key(&key))
})
with_store(app, stores, path, |store| Ok(store.has(key)))
}
#[tauri::command]
async fn delete<R: Runtime>(
app: AppHandle<R>,
window: Window<R>,
stores: State<'_, StoreCollection>,
stores: State<'_, StoreCollection<R>>,
path: PathBuf,
key: String,
) -> Result<bool, Error> {
with_store(&app, stores, path.clone(), |store| {
let flag = store.cache.remove(&key).is_some();
if flag {
let _ = window.emit(
"store://change",
ChangePayload {
path,
key,
value: JsonValue::Null,
},
);
}
Ok(flag)
})
with_store(app, stores, path, |store| store.delete(key))
}
#[tauri::command]
async fn clear<R: Runtime>(
app: AppHandle<R>,
window: Window<R>,
stores: State<'_, StoreCollection>,
stores: State<'_, StoreCollection<R>>,
path: PathBuf,
) -> Result<(), Error> {
with_store(&app, stores, path.clone(), |store| {
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(())
})
with_store(app, stores, path, |store| store.clear())
}
#[tauri::command]
async fn reset<R: Runtime>(
app: AppHandle<R>,
window: Window<R>,
collection: State<'_, StoreCollection>,
collection: State<'_, StoreCollection<R>>,
path: PathBuf,
) -> Result<(), Error> {
let has_defaults = collection
.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
}
with_store(app, collection, path, |store| store.reset())
}
#[tauri::command]
async fn keys<R: Runtime>(
app: AppHandle<R>,
stores: State<'_, StoreCollection>,
stores: State<'_, StoreCollection<R>>,
path: PathBuf,
) -> Result<Vec<String>, Error> {
with_store(&app, stores, path, |store| {
Ok(store.cache.keys().cloned().collect())
with_store(app, stores, path, |store| {
Ok(store.keys().cloned().collect())
})
}
#[tauri::command]
async fn values<R: Runtime>(
app: AppHandle<R>,
stores: State<'_, StoreCollection>,
stores: State<'_, StoreCollection<R>>,
path: PathBuf,
) -> Result<Vec<JsonValue>, Error> {
with_store(&app, stores, path, |store| {
Ok(store.cache.values().cloned().collect())
with_store(app, stores, path, |store| {
Ok(store.values().cloned().collect())
})
}
#[tauri::command]
async fn entries<R: Runtime>(
app: AppHandle<R>,
stores: State<'_, StoreCollection>,
stores: State<'_, StoreCollection<R>>,
path: PathBuf,
) -> Result<Vec<(String, JsonValue)>, Error> {
with_store(&app, stores, path, |store| {
Ok(store.cache.clone().into_iter().collect())
with_store(app, stores, path, |store| {
Ok(store
.entries()
.map(|(k, v)| (k.to_owned(), v.to_owned()))
.collect())
})
}
#[tauri::command]
async fn length<R: Runtime>(
app: AppHandle<R>,
stores: State<'_, StoreCollection>,
stores: State<'_, StoreCollection<R>>,
path: PathBuf,
) -> Result<usize, Error> {
with_store(&app, stores, path, |store| Ok(store.cache.len()))
with_store(app, stores, path, |store| Ok(store.len()))
}
#[tauri::command]
async fn load<R: Runtime>(
app: AppHandle<R>,
stores: State<'_, StoreCollection>,
stores: State<'_, StoreCollection<R>>,
path: PathBuf,
) -> Result<(), Error> {
with_store(&app, stores, path, |store| store.load(&app))
with_store(app, stores, path, |store| store.load())
}
#[tauri::command]
async fn save<R: Runtime>(
app: AppHandle<R>,
stores: State<'_, StoreCollection>,
stores: State<'_, StoreCollection<R>>,
path: PathBuf,
) -> Result<(), Error> {
with_store(&app, stores, path, |store| store.save(&app))
with_store(app, stores, path, |store| store.save())
}
#[derive(Default)]
pub struct Builder {
stores: HashMap<PathBuf, Store>,
pub struct Builder<R: Runtime> {
stores: HashMap<PathBuf, Store<R>>,
frozen: bool,
}
impl Builder {
impl<R: Runtime> Builder<R> {
/// Registers a store with the plugin.
///
/// # Examples
@ -265,7 +205,7 @@ impl Builder {
/// # 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
}
@ -285,7 +225,7 @@ impl Builder {
/// # 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
.into_iter()
.map(|store| (store.path.clone(), store))
@ -331,7 +271,7 @@ impl Builder {
/// # Ok(())
/// # }
/// ```
pub fn build<R: Runtime>(mut self) -> TauriPlugin<R> {
pub fn build(mut self) -> TauriPlugin<R> {
plugin::Builder::new("store")
.invoke_handler(tauri::generate_handler![
set, get, has, delete, clear, reset, keys, values, length, entries, load, save
@ -339,7 +279,7 @@ impl Builder {
.setup(move |app_handle| {
for (path, store) in self.stores.iter_mut() {
// ignore loading errors, just use the default
if let Err(err) = store.load(app_handle) {
if let Err(err) = store.load() {
warn!(
"Failed to load store {:?} from disk: {}. Falling back to default values.",
path, err
@ -356,10 +296,10 @@ impl Builder {
})
.on_event(|app_handle, 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() {
if let Err(err) = store.save(app_handle) {
if let Err(err) = store.save() {
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: MIT
use crate::Error;
use crate::{ChangePayload, Error};
use serde_json::Value as JsonValue;
use std::{
collections::HashMap,
@ -10,7 +10,7 @@ use std::{
io::Write,
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 DeserializeFn = fn(&[u8]) -> Result<HashMap<String, JsonValue>, Box<dyn std::error::Error>>;
@ -28,7 +28,8 @@ fn default_deserialize(
}
/// Builds a [`Store`]
pub struct StoreBuilder {
pub struct StoreBuilder<R: Runtime> {
app: AppHandle<R>,
path: PathBuf,
defaults: Option<HashMap<String, JsonValue>>,
cache: HashMap<String, JsonValue>,
@ -36,7 +37,7 @@ pub struct StoreBuilder {
deserialize: DeserializeFn,
}
impl StoreBuilder {
impl<R: Runtime> StoreBuilder<R> {
/// Creates a new [`StoreBuilder`].
///
/// # Examples
@ -49,8 +50,9 @@ impl StoreBuilder {
/// # Ok(())
/// # }
/// ```
pub fn new(path: PathBuf) -> Self {
pub fn new(app: AppHandle<R>, path: PathBuf) -> Self {
Self {
app,
path,
defaults: None,
cache: Default::default(),
@ -147,8 +149,9 @@ impl StoreBuilder {
///
/// # Ok(())
/// # }
pub fn build(self) -> Store {
pub fn build(self) -> Store<R> {
Store {
app: self.app,
path: self.path,
defaults: self.defaults,
cache: self.cache,
@ -159,18 +162,20 @@ impl StoreBuilder {
}
#[derive(Clone)]
pub struct Store {
pub struct Store<R: Runtime> {
app: AppHandle<R>,
pub(crate) path: PathBuf,
pub(crate) defaults: Option<HashMap<String, JsonValue>>,
pub(crate) cache: HashMap<String, JsonValue>,
defaults: Option<HashMap<String, JsonValue>>,
cache: HashMap<String, JsonValue>,
serialize: SerializeFn,
deserialize: DeserializeFn,
}
impl Store {
impl<R: Runtime> Store<R> {
/// Update the store from the on-disk state
pub fn load<R: Runtime>(&mut self, app: &AppHandle<R>) -> Result<(), Error> {
let app_dir = app
pub fn load(&mut self) -> Result<(), Error> {
let app_dir = self
.app
.path_resolver()
.app_data_dir()
.expect("failed to resolve app dir");
@ -184,8 +189,9 @@ impl Store {
}
/// Saves the store to disk
pub fn save<R: Runtime>(&self, app: &AppHandle<R>) -> Result<(), Error> {
let app_dir = app
pub fn save(&self) -> Result<(), Error> {
let app_dir = self
.app
.path_resolver()
.app_data_dir()
.expect("failed to resolve app dir");
@ -199,9 +205,107 @@ impl Store {
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 {
f.debug_struct("Store")
.field("path", &self.path)

Write Preview
Loading…
Cancel
Save