mirror of
https://github.com/tauri-apps/plugins-workspace.git
synced 2026-06-06 13:53:54 +02:00
copy plugin sources
This commit is contained in:
Jonas Kruckenberg
@@ -0,0 +1,34 @@
|
||||
// Copyright 2021 Tauri Programme within The Commons Conservancy
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
use serde::{Serialize, Serializer};
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// The error types.
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
#[non_exhaustive]
|
||||
pub enum Error {
|
||||
#[error("Failed to serialize store. {0}")]
|
||||
Serialize(Box<dyn std::error::Error>),
|
||||
#[error("Failed to deserialize store. {0}")]
|
||||
Deserialize(Box<dyn std::error::Error>),
|
||||
/// JSON error.
|
||||
#[error(transparent)]
|
||||
Json(#[from] serde_json::Error),
|
||||
/// IO error.
|
||||
#[error(transparent)]
|
||||
Io(#[from] std::io::Error),
|
||||
/// Store not found
|
||||
#[error("Store \"{0}\" not found")]
|
||||
NotFound(PathBuf),
|
||||
}
|
||||
|
||||
impl Serialize for Error {
|
||||
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
|
||||
where
|
||||
S: Serializer,
|
||||
{
|
||||
serializer.serialize_str(self.to_string().as_ref())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,370 @@
|
||||
// Copyright 2021 Tauri Programme within The Commons Conservancy
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
pub use error::Error;
|
||||
use log::warn;
|
||||
use serde::Serialize;
|
||||
use serde_json::Value as JsonValue;
|
||||
use std::{collections::HashMap, path::PathBuf, sync::Mutex};
|
||||
pub use store::{Store, StoreBuilder};
|
||||
use tauri::{
|
||||
plugin::{self, TauriPlugin},
|
||||
AppHandle, Manager, RunEvent, Runtime, State, Window,
|
||||
};
|
||||
|
||||
mod error;
|
||||
mod store;
|
||||
|
||||
#[derive(Serialize, Clone)]
|
||||
struct ChangePayload {
|
||||
path: PathBuf,
|
||||
key: String,
|
||||
value: JsonValue,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct StoreCollection {
|
||||
stores: Mutex<HashMap<PathBuf, Store>>,
|
||||
frozen: bool,
|
||||
}
|
||||
|
||||
fn with_store<R: Runtime, T, F: FnOnce(&mut Store) -> Result<T, Error>>(
|
||||
app: &AppHandle<R>,
|
||||
collection: State<'_, StoreCollection>,
|
||||
path: PathBuf,
|
||||
f: F,
|
||||
) -> Result<T, Error> {
|
||||
let mut stores = collection.stores.lock().expect("mutex poisoned");
|
||||
|
||||
if !stores.contains_key(&path) {
|
||||
if collection.frozen {
|
||||
return Err(Error::NotFound(path));
|
||||
}
|
||||
let mut store = StoreBuilder::new(path.clone()).build();
|
||||
// ignore loading errors, just use the default
|
||||
if let Err(err) = store.load(app) {
|
||||
warn!(
|
||||
"Failed to load store {:?} from disk: {}. Falling back to default values.",
|
||||
path, err
|
||||
);
|
||||
}
|
||||
stores.insert(path.clone(), store);
|
||||
}
|
||||
|
||||
f(stores
|
||||
.get_mut(&path)
|
||||
.expect("failed to retrieve store. This is a bug!"))
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn set<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
window: Window<R>,
|
||||
stores: State<'_, StoreCollection>,
|
||||
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(())
|
||||
})
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn get<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
stores: State<'_, StoreCollection>,
|
||||
path: PathBuf,
|
||||
key: String,
|
||||
) -> Result<Option<JsonValue>, Error> {
|
||||
with_store(&app, stores, path, |store| {
|
||||
Ok(store.cache.get(&key).cloned())
|
||||
})
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn has<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
stores: State<'_, StoreCollection>,
|
||||
path: PathBuf,
|
||||
key: String,
|
||||
) -> Result<bool, Error> {
|
||||
with_store(&app, stores, path, |store| {
|
||||
Ok(store.cache.contains_key(&key))
|
||||
})
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn delete<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
window: Window<R>,
|
||||
stores: State<'_, StoreCollection>,
|
||||
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)
|
||||
})
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn clear<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
window: Window<R>,
|
||||
stores: State<'_, StoreCollection>,
|
||||
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(())
|
||||
})
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn reset<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
window: Window<R>,
|
||||
collection: State<'_, StoreCollection>,
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn keys<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
stores: State<'_, StoreCollection>,
|
||||
path: PathBuf,
|
||||
) -> Result<Vec<String>, Error> {
|
||||
with_store(&app, stores, path, |store| {
|
||||
Ok(store.cache.keys().cloned().collect())
|
||||
})
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn values<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
stores: State<'_, StoreCollection>,
|
||||
path: PathBuf,
|
||||
) -> Result<Vec<JsonValue>, Error> {
|
||||
with_store(&app, stores, path, |store| {
|
||||
Ok(store.cache.values().cloned().collect())
|
||||
})
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn entries<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
stores: State<'_, StoreCollection>,
|
||||
path: PathBuf,
|
||||
) -> Result<Vec<(String, JsonValue)>, Error> {
|
||||
with_store(&app, stores, path, |store| {
|
||||
Ok(store.cache.clone().into_iter().collect())
|
||||
})
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn length<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
stores: State<'_, StoreCollection>,
|
||||
path: PathBuf,
|
||||
) -> Result<usize, Error> {
|
||||
with_store(&app, stores, path, |store| Ok(store.cache.len()))
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn load<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
stores: State<'_, StoreCollection>,
|
||||
path: PathBuf,
|
||||
) -> Result<(), Error> {
|
||||
with_store(&app, stores, path, |store| store.load(&app))
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn save<R: Runtime>(
|
||||
app: AppHandle<R>,
|
||||
stores: State<'_, StoreCollection>,
|
||||
path: PathBuf,
|
||||
) -> Result<(), Error> {
|
||||
with_store(&app, stores, path, |store| store.save(&app))
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct PluginBuilder {
|
||||
stores: HashMap<PathBuf, Store>,
|
||||
frozen: bool,
|
||||
}
|
||||
|
||||
impl PluginBuilder {
|
||||
/// Registers a store with the plugin.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// use tauri_plugin_store::{StoreBuilder,PluginBuilder};
|
||||
///
|
||||
/// let store = StoreBuilder::new("store.bin".parse()?).build();
|
||||
///
|
||||
/// let builder = PluginBuilder::default().store(store);
|
||||
///
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn store(mut self, store: Store) -> Self {
|
||||
self.stores.insert(store.path.clone(), store);
|
||||
self
|
||||
}
|
||||
|
||||
/// Registers multiple stores with the plugin.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// use tauri_plugin_store::{StoreBuilder,PluginBuilder};
|
||||
///
|
||||
/// let store = StoreBuilder::new("store.bin".parse()?).build();
|
||||
///
|
||||
/// let builder = PluginBuilder::default().stores([store]);
|
||||
///
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn stores<T: IntoIterator<Item = Store>>(mut self, stores: T) -> Self {
|
||||
self.stores = stores
|
||||
.into_iter()
|
||||
.map(|store| (store.path.clone(), store))
|
||||
.collect();
|
||||
self
|
||||
}
|
||||
|
||||
/// Freezes the collection.
|
||||
///
|
||||
/// This causes requests for plugins that haven't been registered to fail
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// use tauri_plugin_store::{StoreBuilder,PluginBuilder};
|
||||
///
|
||||
/// let store = StoreBuilder::new("store.bin".parse()?).build();
|
||||
///
|
||||
/// let builder = PluginBuilder::default().freeze();
|
||||
///
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn freeze(mut self) -> Self {
|
||||
self.frozen = true;
|
||||
self
|
||||
}
|
||||
|
||||
/// Builds the plugin.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// use tauri_plugin_store::{StoreBuilder,PluginBuilder};
|
||||
/// use tauri::Wry;
|
||||
///
|
||||
/// let store = StoreBuilder::new("store.bin".parse()?).build();
|
||||
///
|
||||
/// let plugin = PluginBuilder::default().build::<Wry>();
|
||||
///
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn build<R: Runtime>(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
|
||||
])
|
||||
.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) {
|
||||
warn!(
|
||||
"Failed to load store {:?} from disk: {}. Falling back to default values.",
|
||||
path, err
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
app_handle.manage(StoreCollection {
|
||||
stores: Mutex::new(self.stores),
|
||||
frozen: self.frozen,
|
||||
});
|
||||
|
||||
Ok(())
|
||||
})
|
||||
.on_event(|app_handle, event| {
|
||||
if let RunEvent::Exit = event {
|
||||
let collection = app_handle.state::<StoreCollection>();
|
||||
|
||||
for store in collection.stores.lock().expect("mutex poisoned").values() {
|
||||
if let Err(err) = store.save(app_handle) {
|
||||
eprintln!("failed to save store {:?} with error {:?}", store.path, err);
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
.build()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,212 @@
|
||||
// Copyright 2021 Tauri Programme within The Commons Conservancy
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
use crate::Error;
|
||||
use serde_json::Value as JsonValue;
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
fs::{create_dir_all, read, File},
|
||||
io::Write,
|
||||
path::PathBuf,
|
||||
};
|
||||
use tauri::{AppHandle, 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>>;
|
||||
|
||||
fn default_serialize(
|
||||
cache: &HashMap<String, JsonValue>,
|
||||
) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
|
||||
Ok(serde_json::to_vec(&cache)?)
|
||||
}
|
||||
|
||||
fn default_deserialize(
|
||||
bytes: &[u8],
|
||||
) -> Result<HashMap<String, JsonValue>, Box<dyn std::error::Error>> {
|
||||
serde_json::from_slice(bytes).map_err(Into::into)
|
||||
}
|
||||
|
||||
/// Builds a [`Store`]
|
||||
pub struct StoreBuilder {
|
||||
path: PathBuf,
|
||||
defaults: Option<HashMap<String, JsonValue>>,
|
||||
cache: HashMap<String, JsonValue>,
|
||||
serialize: SerializeFn,
|
||||
deserialize: DeserializeFn,
|
||||
}
|
||||
|
||||
impl StoreBuilder {
|
||||
/// Creates a new [`StoreBuilder`].
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// use tauri_plugin_store::StoreBuilder;
|
||||
///
|
||||
/// let builder = StoreBuilder::new("store.bin".parse()?);
|
||||
///
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn new(path: PathBuf) -> Self {
|
||||
Self {
|
||||
path,
|
||||
defaults: None,
|
||||
cache: Default::default(),
|
||||
serialize: default_serialize,
|
||||
deserialize: default_deserialize,
|
||||
}
|
||||
}
|
||||
|
||||
/// Inserts a default key-value pair.
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// use tauri_plugin_store::StoreBuilder;
|
||||
/// use std::collections::HashMap;
|
||||
///
|
||||
/// let mut defaults = HashMap::new();
|
||||
///
|
||||
/// defaults.insert("foo".to_string(), "bar".into());
|
||||
///
|
||||
/// let builder = StoreBuilder::new("store.bin".parse()?)
|
||||
/// .defaults(defaults);
|
||||
///
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
pub fn defaults(mut self, defaults: HashMap<String, JsonValue>) -> Self {
|
||||
self.cache = defaults.clone();
|
||||
self.defaults = Some(defaults);
|
||||
self
|
||||
}
|
||||
|
||||
/// Inserts multiple key-value pairs.
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// use tauri_plugin_store::StoreBuilder;
|
||||
///
|
||||
/// let builder = StoreBuilder::new("store.bin".parse()?)
|
||||
/// .default("foo".to_string(), "bar".into());
|
||||
///
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
pub fn default(mut self, key: String, value: JsonValue) -> Self {
|
||||
self.cache.insert(key.clone(), value.clone());
|
||||
self.defaults
|
||||
.get_or_insert(HashMap::new())
|
||||
.insert(key, value);
|
||||
self
|
||||
}
|
||||
|
||||
/// Defines a custom serialization function.
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// use tauri_plugin_store::StoreBuilder;
|
||||
///
|
||||
/// let builder = StoreBuilder::new("store.json".parse()?)
|
||||
/// .serialize(|cache| serde_json::to_vec(&cache).map_err(Into::into));
|
||||
///
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
pub fn serialize(mut self, serialize: SerializeFn) -> Self {
|
||||
self.serialize = serialize;
|
||||
self
|
||||
}
|
||||
|
||||
/// Defines a custom deserialization function
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// use tauri_plugin_store::StoreBuilder;
|
||||
///
|
||||
/// let builder = StoreBuilder::new("store.json".parse()?)
|
||||
/// .deserialize(|bytes| serde_json::from_slice(&bytes).map_err(Into::into));
|
||||
///
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
pub fn deserialize(mut self, deserialize: DeserializeFn) -> Self {
|
||||
self.deserialize = deserialize;
|
||||
self
|
||||
}
|
||||
|
||||
/// Builds the [`Store`].
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// use tauri_plugin_store::StoreBuilder;
|
||||
///
|
||||
/// let store = StoreBuilder::new("store.bin".parse()?).build();
|
||||
///
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
pub fn build(self) -> Store {
|
||||
Store {
|
||||
path: self.path,
|
||||
defaults: self.defaults,
|
||||
cache: self.cache,
|
||||
serialize: self.serialize,
|
||||
deserialize: self.deserialize,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Store {
|
||||
pub(crate) path: PathBuf,
|
||||
pub(crate) defaults: Option<HashMap<String, JsonValue>>,
|
||||
pub(crate) cache: HashMap<String, JsonValue>,
|
||||
serialize: SerializeFn,
|
||||
deserialize: DeserializeFn,
|
||||
}
|
||||
|
||||
impl Store {
|
||||
/// Update the store from the on-disk state
|
||||
pub fn load<R: Runtime>(&mut self, app: &AppHandle<R>) -> Result<(), Error> {
|
||||
let app_dir = app
|
||||
.path_resolver()
|
||||
.app_dir()
|
||||
.expect("failed to resolve app dir");
|
||||
let store_path = app_dir.join(&self.path);
|
||||
|
||||
let bytes = read(&store_path)?;
|
||||
|
||||
self.cache = (self.deserialize)(&bytes).map_err(Error::Deserialize)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Saves the store to disk
|
||||
pub fn save<R: Runtime>(&self, app: &AppHandle<R>) -> Result<(), Error> {
|
||||
let app_dir = app
|
||||
.path_resolver()
|
||||
.app_dir()
|
||||
.expect("failed to resolve app dir");
|
||||
let store_path = app_dir.join(&self.path);
|
||||
|
||||
create_dir_all(store_path.parent().expect("invalid store path"))?;
|
||||
|
||||
let bytes = (self.serialize)(&self.cache).map_err(Error::Serialize)?;
|
||||
let mut f = File::create(&store_path)?;
|
||||
f.write_all(&bytes)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for Store {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("Store")
|
||||
.field("path", &self.path)
|
||||
.field("defaults", &self.defaults)
|
||||
.field("cache", &self.cache)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user