zaphar/kitchen
1
0
Fork 0
mirror of https://github.com/zaphar/kitchen.git synced 2025-07-23 19:49:58 -04:00
Code Issues Packages Projects Releases Wiki Activity

dev: use indexdb instead of local storage in the storage layer

Browse Source
This commit is contained in:
Jeremy Wall 2024-07-11 23:58:17 -04:00
parent 4767115da6
commit b93edd2701
9 changed files with 1235 additions and 915 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1610
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

4
api/Cargo.toml
View File

@ -6,10 +6,12 @@ edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
serde = "<=1.0.171"
recipes = { path = "../recipes" }
chrono = "0.4.22"
[dependencies.serde]
version = "1.0.204"
features = ["derive"]
[dependencies.axum]
version = "0.5.16"

9
kitchen/Cargo.toml
View File

@ -18,14 +18,19 @@ async-trait = "0.1.57"
async-session = "3.0.0"
ciborium = "0.2.0"
tower = "0.4.13"
serde = "<=1.0.171"
cookie = "0.17.0"
chrono = "0.4.22"
metrics = "0.20.1"
metrics-exporter-prometheus = "0.11.0"
futures = "0.3"
metrics-process = "1.0.8"
[dependencies.chrono]
version = "0.4.22"
features = ["serde"]
[dependencies.serde]
version = "1.0.204"
[dependencies.argon2]
version = "0.5.0"

10
recipes/Cargo.toml
View File

@ -8,8 +8,14 @@ edition = "2021"
[dependencies]
abortable_parser = "~0.2.6"
chrono = "~0.4"
serde = "1.0.144"
[dependencies.chrono]
version = "0.4.22"
features = ["serde"]
[dependencies.serde]
version = "1.0.204"
features = ["derive"]
[dependencies.num-rational]
version = "~0.4.0"

3
web/Cargo.toml
View File

@ -29,9 +29,10 @@ wasm-web-component = { git = "https://github.com/zaphar/wasm-web-components.git"
maud = "*"
indexed-db = "0.4.1"
anyhow = "1.0.86"
serde-wasm-bindgen = "0.6.5"
[dependencies.serde]
version = "<=1.0.171"
version = "1.0.204"
features = ["derive"]
[dependencies.tracing-subscriber]

360
web/src/api.rs
View File

@ -16,18 +16,22 @@ use std::collections::{BTreeMap, BTreeSet};
use base64::{self, Engine};
use chrono::NaiveDate;
use gloo_net;
use serde_json::{from_str, to_string};
// TODO(jwall): Remove this when we have gone a few migrations past.
//use serde_json::{from_str, to_string};
use sycamore::prelude::*;
use tracing::{debug, error, instrument};
use anyhow::Result;
use client_api::*;
use recipes::{IngredientKey, RecipeEntry};
use serde_wasm_bindgen::{from_value, to_value};
use wasm_bindgen::JsValue;
use web_sys::Storage;
// TODO(jwall): Remove this when we have gone a few migrations past.
//use web_sys::Storage;
use crate::{
app_state::{parse_recipes, AppState},
js_lib,
js_lib::{self, DBFactory},
};
#[allow(dead_code)]
@ -86,38 +90,68 @@ fn token68(user: String, pass: String) -> String {
#[derive(Clone, Debug)]
pub struct LocalStore {
store: Storage,
// FIXME(zaphar): Migration from local storage to indexed db
//old_store: Storage,
store: DBFactory<'static>,
}
const APP_STATE_KEY: &'static str = "app-state";
impl LocalStore {
pub fn new() -> Self {
Self {
store: js_lib::get_storage(),
store: DBFactory::new("app-state", Some(0)),
//old_store: js_lib::get_storage(),
}
}
pub fn store_app_state(&self, state: &AppState) {
self.migrate_local_store();
let state = match to_string(state) {
pub async fn store_app_state(&self, state: &AppState) {
self.migrate_local_store().await;
let state = match to_value(state) {
Ok(state) => state,
Err(err) => {
error!(?err, ?state, "Error deserializing app_state");
return;
}
};
let key = to_value(APP_STATE_KEY).expect("Failed to serialize key");
self.store
.set("app_state", &state)
.expect("Failed to set our app state");
.rw_transaction(|trx| async move {
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
object_store
.put_kv(
&key,
&state,
)
.await
.expect("Failed to write to object store");
Ok(())
})
.await
.expect("Failed to store app-state");
// FIXME(zaphar): Migration from local storage to indexed db
//self.store
// .set("app_state", &state)
// .expect("Failed to set our app state");
}
pub fn fetch_app_state(&self) -> Option<AppState> {
pub async fn fetch_app_state(&self) -> Option<AppState> {
debug!("Loading state from local store");
self.store.get("app_state").map_or(None, |val| {
val.map(|s| {
debug!("Found an app_state object");
let recipes = parse_recipes(&self.get_recipes().await).expect("Failed to parse recipes");
self.store
.ro_transaction(|trx| async move {
let key = to_value(APP_STATE_KEY).expect("Failed to serialize key");
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
let mut app_state: AppState =
from_str(&s).expect("Failed to deserialize app state");
let recipes = parse_recipes(&self.get_recipes()).expect("Failed to parse recipes");
match object_store.get(&key).await.expect("Failed to read from") {
Some(s) => from_value(s).expect("Failed to deserialize app state"),
None => return Ok(None),
};
if let Some(recipes) = recipes {
debug!("Populating recipes");
for (id, recipe) in recipes {
@ -125,79 +159,185 @@ impl LocalStore {
app_state.recipes.insert(id, recipe);
}
}
app_state
})
Ok(Some(app_state))
})
.await
.expect("Failed to fetch app-state")
// FIXME(zaphar): Migration from local storage to indexed db
//self.store.get("app_state").map_or(None, |val| {
// val.map(|s| {
// debug!("Found an app_state object");
// let mut app_state: AppState =
// from_str(&s).expect("Failed to deserialize app state");
// let recipes = parse_recipes(&self.get_recipes()).expect("Failed to parse recipes");
// if let Some(recipes) = recipes {
// debug!("Populating recipes");
// for (id, recipe) in recipes {
// debug!(id, "Adding recipe from local storage");
// app_state.recipes.insert(id, recipe);
// }
// }
// app_state
// })
//})
}
/// Gets user data from local storage.
pub fn get_user_data(&self) -> Option<UserData> {
pub async fn get_user_data(&self) -> Option<UserData> {
self.store
.get("user_data")
.map_or(None, |val| val.map(|val| from_str(&val).unwrap_or(None)))
.flatten()
.ro_transaction(|trx| async move {
let key = to_value("user_data").expect("Failed to serialize key");
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
let user_data: UserData = match object_store
.get(&key)
.await
.expect("Failed to read from object store")
{
Some(s) => from_value(s).expect("Failed to deserialize app state"),
None => return Ok(None),
};
Ok(Some(user_data))
})
.await
.expect("Failed to fetch user_data")
// FIXME(zaphar): Migration from local storage to indexed db
//self.store
// .get("user_data")
// .map_or(None, |val| val.map(|val| from_str(&val).unwrap_or(None)))
// .flatten()
}
// Set's user data to local storage.
pub fn set_user_data(&self, data: Option<&UserData>) {
pub async fn set_user_data(&self, data: Option<&UserData>) {
let key = to_value("user_data").expect("Failed to serialize key");
if let Some(data) = data {
let data = data.clone();
self.store
.set(
"user_data",
&to_string(data).expect("Failed to desrialize user_data"),
.rw_transaction(|trx| async move {
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
object_store
.put_kv(
&key,
&to_value(&data).expect("failed to serialize UserData"),
)
.await
.expect("Failed to store user_data");
Ok(())
})
.await
.expect("Failed to set user_data");
// FIXME(zaphar): Migration from local storage to indexed db
//self.store
// .set(
// "user_data",
// &to_string(data).expect("Failed to desrialize user_data"),
// )
// .expect("Failed to set user_data");
} else {
self.store
.delete("user_data")
.rw_transaction(|trx| async move {
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
object_store
.delete(&key)
.await
.expect("Failed to delete user_data");
Ok(())
})
.await
.expect("Failed to delete user_data");
// FIXME(zaphar): Migration from local storage to indexed db
//self.store
// .delete("user_data")
// .expect("Failed to delete user_data");
}
}
fn get_storage_keys(&self) -> Vec<String> {
async fn get_storage_keys(&self) -> Vec<String> {
self.store
.ro_transaction(|trx| async move {
let mut keys = Vec::new();
for idx in 0..self.store.length().unwrap() {
if let Some(k) = self.store.key(idx).expect("Failed to get storage key") {
keys.push(k)
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
let key_vec = object_store
.get_all_keys(None)
.await
.expect("Failed to get keys from object_store");
for k in key_vec {
if let Ok(v) = from_value(k) {
keys.push(v);
}
}
keys
Ok(keys)
})
.await
.expect("Failed to get storage keys")
}
fn migrate_local_store(&self) {
for k in self.get_storage_keys().into_iter().filter(|k| {
async fn migrate_local_store(&self) {
// FIXME(zaphar): Migration from local storage to indexed db
for k in self.get_storage_keys().await.into_iter().filter(|k| {
k.starts_with("categor") || k == "inventory" || k.starts_with("plan") || k == "staples"
}) {
// Deleting old local store key
debug!("Deleting old local store key {}", k);
self.store.delete(&k).expect("Failed to delete storage key");
let key = to_value(&k).expect("Failed to serialize key");
self.store
.rw_transaction(|trx| async move {
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
object_store
.delete(&key)
.await
.expect("Failed to delete user_data");
Ok(())
})
.await
.expect("Failed to delete user_data");
//debug!("Deleting old local store key {}", k);
//self.store.delete(&k).expect("Failed to delete storage key");
}
}
fn get_recipe_keys(&self) -> impl Iterator<Item = String> {
async fn get_recipe_keys(&self) -> impl Iterator<Item = String> {
self.get_storage_keys()
.await
.into_iter()
.filter(|k| k.starts_with("recipe:"))
}
/// Gets all the recipes from local storage.
pub fn get_recipes(&self) -> Option<Vec<RecipeEntry>> {
pub async fn get_recipes(&self) -> Option<Vec<RecipeEntry>> {
let mut recipe_list = Vec::new();
for recipe_key in self.get_recipe_keys() {
if let Some(entry) = self
for recipe_key in self.get_recipe_keys().await {
let key = to_value(&recipe_key).expect("Failed to serialize key");
let entry = self
.store
.get(&recipe_key)
.expect(&format!("Failed to get recipe: {}", recipe_key))
.ro_transaction(|trx| async move {
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
let entry: Option<RecipeEntry> = match object_store
.get(&key)
.await
.expect("Failed to get recipe from key")
{
match from_str(&entry) {
Ok(entry) => {
Some(v) => from_value(v).expect("Failed to deserialize entry"),
None => None,
};
Ok(entry)
})
.await
.expect("Failed to get recipes");
if let Some(entry) = entry {
recipe_list.push(entry);
}
Err(e) => {
error!(recipe_key, err = ?e, "Failed to parse recipe entry");
}
}
}
}
if recipe_list.is_empty() {
return None;
@ -205,42 +345,122 @@ impl LocalStore {
Some(recipe_list)
}
pub fn get_recipe_entry(&self, id: &str) -> Option<RecipeEntry> {
let key = recipe_key(id);
pub async fn get_recipe_entry(&self, id: &str) -> Option<RecipeEntry> {
let key = to_value(&recipe_key(id)).expect("Failed to serialize key");
self.store
.ro_transaction(|trx| async move {
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
let entry: Option<RecipeEntry> = match object_store
.get(&key)
.expect(&format!("Failed to get recipe {}", key))
.map(|entry| from_str(&entry).expect(&format!("Failed to get recipe {}", key)))
.await
.expect("Failed to get recipe from key")
{
Some(v) => from_value(v).expect("Failed to deserialize entry"),
None => None,
};
Ok(entry)
})
.await
.expect("Failed to get recipes")
// FIXME(zaphar): Migration from local storage to indexed db
//self.store
// .get(&key)
// .expect(&format!("Failed to get recipe {}", key))
// .map(|entry| from_str(&entry).expect(&format!("Failed to get recipe {}", key)))
}
/// Sets the set of recipes to the entries passed in. Deletes any recipes not
/// in the list.
pub fn set_all_recipes(&self, entries: &Vec<RecipeEntry>) {
for recipe_key in self.get_recipe_keys() {
pub async fn set_all_recipes(&self, entries: &Vec<RecipeEntry>) {
// FIXME(zaphar): Migration from local storage to indexed db
for recipe_key in self.get_recipe_keys().await {
let key = to_value(&recipe_key).expect("Failed to serialize key");
self.store
.delete(&recipe_key)
.expect(&format!("Failed to get recipe {}", recipe_key));
.rw_transaction(|trx| async move {
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
object_store
.delete(&key)
.await
.expect("Failed to delete user_data");
Ok(())
})
.await
.expect("Failed to delete user_data");
//self.store
// .delete(&recipe_key)
// .expect(&format!("Failed to get recipe {}", recipe_key));
}
for entry in entries {
self.set_recipe_entry(entry);
let entry = entry.clone();
let key =
to_value(&recipe_key(entry.recipe_id())).expect("Failed to serialize recipe key");
self.store.rw_transaction(|trx| async move {
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
object_store
.put_kv(
&key,
&to_value(&entry).expect("Failed to serialize recipe entry"),
)
.await
.expect("Failed to store recipe_entry");
Ok(())
}).await.expect("Failed to store recipe entry");
//self.set_recipe_entry(entry).await;
}
}
/// Set recipe entry in local storage.
pub fn set_recipe_entry(&self, entry: &RecipeEntry) {
self.store
.set(
&recipe_key(entry.recipe_id()),
&to_string(&entry).expect(&format!("Failed to get recipe {}", entry.recipe_id())),
pub async fn set_recipe_entry(&self, entry: &RecipeEntry) {
let entry = entry.clone();
let key = to_value(&recipe_key(entry.recipe_id())).expect("Failed to serialize recipe key");
self.store.rw_transaction(|trx| async move {
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
object_store
.put_kv(
&key,
&to_value(&entry).expect("Failed to serialize recipe entry"),
)
.expect(&format!("Failed to store recipe {}", entry.recipe_id()))
.await
.expect("Failed to store recipe_entry");
Ok(())
}).await.expect("Failed to store recipe entry");
// FIXME(zaphar): Migration from local storage to indexed db
//self.store
// .set(
// &recipe_key(entry.recipe_id()),
// &to_string(&entry).expect(&format!("Failed to get recipe {}", entry.recipe_id())),
// )
// .expect(&format!("Failed to store recipe {}", entry.recipe_id()))
}
/// Delete recipe entry from local storage.
pub fn delete_recipe_entry(&self, recipe_id: &str) {
pub async fn delete_recipe_entry(&self, recipe_id: &str) {
let key = to_value(recipe_id).expect("Failed to serialize key");
self.store
.delete(&recipe_key(recipe_id))
.expect(&format!("Failed to delete recipe {}", recipe_id))
.rw_transaction(|trx| async move {
let object_store = trx
.object_store(js_lib::STORE_NAME)
.expect("Failed to get object store");
object_store
.delete(&key)
.await
.expect("Failed to delete user_data");
Ok(())
})
.await
.expect("Failed to delete user_data");
// FIXME(zaphar): Migration from local storage to indexed db
//self.store
// .delete(&recipe_key(recipe_id))
// .expect(&format!("Failed to delete recipe {}", recipe_id))
}
}
@ -365,7 +585,7 @@ impl HttpStore {
Ok(resp) => resp,
Err(gloo_net::Error::JsError(err)) => {
error!(path, ?err, "Error hitting api");
return Ok(self.local_store.get_recipes());
return Ok(self.local_store.get_recipes().await);
}
Err(err) => {
return Err(err)?;
@ -395,7 +615,7 @@ impl HttpStore {
Ok(resp) => resp,
Err(gloo_net::Error::JsError(err)) => {
error!(path, ?err, "Error hitting api");
return Ok(self.local_store.get_recipe_entry(id.as_ref()));
return Ok(self.local_store.get_recipe_entry(id.as_ref()).await);
}
Err(err) => {
return Err(err)?;
@ -415,7 +635,7 @@ impl HttpStore {
.as_success()
.unwrap();
if let Some(ref entry) = entry {
self.local_store.set_recipe_entry(entry);
self.local_store.set_recipe_entry(entry).await;
}
Ok(entry)
}

42
web/src/app_state.rs
View File

@ -40,9 +40,11 @@ pub struct AppState {
pub recipe_counts: BTreeMap<String, usize>,
pub recipe_categories: BTreeMap<String, String>,
pub extras: Vec<(String, String)>,
#[serde(skip)] // FIXME(jwall): This should really be storable I think?
// FIXME(jwall): This should really be storable I think?
#[serde(skip_deserializing,skip_serializing)]
pub staples: Option<BTreeSet<Ingredient>>,
#[serde(skip)] // FIXME(jwall): This should really be storable I think?
// FIXME(jwall): This should really be storable I think?
#[serde(skip_deserializing,skip_serializing)]
pub recipes: BTreeMap<String, Recipe>,
pub category_map: BTreeMap<String, String>,
pub filtered_ingredients: BTreeSet<IngredientKey>,
@ -178,7 +180,7 @@ impl StateMachine {
// call set on the signal once. When the LinearSignal get's dropped it
// will call set on the contained Signal.
let mut original: LinearSignal<AppState> = original.into();
if let Some(state) = local_store.fetch_app_state() {
if let Some(state) = local_store.fetch_app_state().await {
original = original.update(state);
}
let mut state = original.get().as_ref().clone();
@ -201,7 +203,7 @@ impl StateMachine {
info!("Synchronizing recipe");
if let Some(recipe_entries) = recipe_entries {
local_store.set_all_recipes(recipe_entries);
local_store.set_all_recipes(recipe_entries).await;
state.recipe_categories = recipe_entries
.iter()
.map(|entry| {
@ -255,11 +257,11 @@ impl StateMachine {
info!("Checking for user account data");
if let Some(user_data) = store.fetch_user_data().await {
debug!("Successfully got account data from server");
local_store.set_user_data(Some(&user_data));
local_store.set_user_data(Some(&user_data)).await;
state.auth = Some(user_data);
} else {
debug!("Using account data from local store");
let user_data = local_store.get_user_data();
let user_data = local_store.get_user_data().await;
state.auth = user_data;
}
info!("Synchronizing categories");
@ -293,7 +295,7 @@ impl StateMachine {
}
}
// Finally we store all of this app state back to our localstore
local_store.store_app_state(&state);
local_store.store_app_state(&state).await;
original.update(state);
Ok(())
}
@ -349,8 +351,9 @@ impl MessageMapper<Message, AppState> for StateMachine {
.or_insert(cat);
}
let store = self.store.clone();
self.local_store.set_recipe_entry(&entry);
let local_store = self.local_store.clone();
spawn_local_scoped(cx, async move {
local_store.set_recipe_entry(&entry).await;
if let Err(e) = store.store_recipes(vec![entry]).await {
// FIXME(jwall): We should have a global way to trigger error messages
error!(err=?e, "Unable to save Recipe");
@ -363,9 +366,10 @@ impl MessageMapper<Message, AppState> for StateMachine {
Message::RemoveRecipe(recipe, callback) => {
original_copy.recipe_counts.remove(&recipe);
original_copy.recipes.remove(&recipe);
self.local_store.delete_recipe_entry(&recipe);
let store = self.store.clone();
let local_store = self.local_store.clone();
spawn_local_scoped(cx, async move {
local_store.delete_recipe_entry(&recipe).await;
if let Err(err) = store.delete_recipe(&recipe).await {
error!(?err, "Failed to delete recipe");
}
@ -396,8 +400,11 @@ impl MessageMapper<Message, AppState> for StateMachine {
original_copy.modified_amts.insert(key, amt);
}
Message::SetUserData(user_data) => {
self.local_store.set_user_data(Some(&user_data));
original_copy.auth = Some(user_data);
let local_store = self.local_store.clone();
original_copy.auth = Some(user_data.clone());
spawn_local_scoped(cx, async move {
local_store.set_user_data(Some(&user_data)).await;
});
}
Message::SaveState(f) => {
let mut original_copy = original_copy.clone();
@ -417,7 +424,7 @@ impl MessageMapper<Message, AppState> for StateMachine {
if let Err(e) = store.store_app_state(&original_copy).await {
error!(err=?e, "Error saving app state");
};
local_store.store_app_state(&original_copy);
local_store.store_app_state(&original_copy).await;
original.set(original_copy);
f.map(|f| f());
});
@ -478,7 +485,7 @@ impl MessageMapper<Message, AppState> for StateMachine {
.store_plan_for_date(vec![], &date)
.await
.expect("Failed to init meal plan for date");
local_store.store_app_state(&original_copy);
local_store.store_app_state(&original_copy).await;
original.set(original_copy);
callback.map(|f| f());
@ -501,7 +508,7 @@ impl MessageMapper<Message, AppState> for StateMachine {
original_copy.filtered_ingredients = BTreeSet::new();
original_copy.modified_amts = BTreeMap::new();
original_copy.extras = Vec::new();
local_store.store_app_state(&original_copy);
local_store.store_app_state(&original_copy).await;
original.set(original_copy);
callback.map(|f| f());
@ -513,9 +520,14 @@ impl MessageMapper<Message, AppState> for StateMachine {
return;
}
}
self.local_store.store_app_state(&original_copy);
spawn_local_scoped(cx, {
let local_store = self.local_store.clone();
async move {
local_store.store_app_state(&original_copy).await;
original.set(original_copy);
}
});
}
}
pub type StateHandler<'ctx> = &'ctx Handler<'ctx, StateMachine, AppState, Message>;

60
web/src/js_lib.rs
View File

@ -13,32 +13,68 @@
// limitations under the License.
use js_sys::Date;
use tracing::error;
use web_sys::{window, Storage, Window};
use indexed_db::{self, Factory, Database};
use web_sys::{window, Window};
use indexed_db::{self, Factory, Database, Transaction};
use anyhow::{Result, Context};
use std::future::Future;
pub async fn get_indexed_db(name: &str, version: Option<u32>) -> Result<Database<std::io::Error>> {
let version = version.unwrap_or(0);
pub fn get_storage() -> web_sys::Storage {
get_window()
.local_storage()
.expect("Failed to get storage")
.expect("No storage available")
}
pub const STORE_NAME: &'static str = "state-store";
#[derive(Clone, Debug)]
pub struct DBFactory<'name> {
name: &'name str,
version: Option<u32>,
}
impl<'name> DBFactory<'name> {
pub fn new(name: &'name str, version: Option<u32>) -> Self {
Self { name, version }
}
pub async fn get_indexed_db(&self) -> Result<Database<std::io::Error>> {
let factory = Factory::<std::io::Error>::get().context("opening IndexedDB")?;
let db = factory.open(name, version, |evt| async move {
let db = factory.open(self.name, self.version.unwrap_or(0), |evt| async move {
// NOTE(zaphar): This is the on upgradeneeded handler. It get's called on new databases or
// database with an older version than the one we requested to build.
let db = evt.database();
// NOTE(jwall): This needs to be somewhat clever in handling version upgrades.
if db.version() == 0 {
// We use out of line keys for this object store
db.build_object_store("store").create()?;
db.build_object_store(STORE_NAME).create()?;
}
Ok(())
}).await.context(format!("Openong or creating the database {}", name))?;
}).await.context(format!("Opening or creating the database {}", self.name))?;
Ok(db)
}
pub fn get_storage() -> Storage {
get_window()
.local_storage()
.expect("Failed to get storage")
.expect("No storage available")
pub async fn rw_transaction<Fun, RetFut, Ret>(&self, transaction: Fun) -> indexed_db::Result<Ret, std::io::Error>
where
Fun: 'static + FnOnce(Transaction<std::io::Error>) -> RetFut,
RetFut: 'static + Future<Output = indexed_db::Result<Ret, std::io::Error>>,
Ret: 'static,
{
self.get_indexed_db().await.expect("Failed to open database")
.transaction(&[STORE_NAME]).rw()
.run(transaction).await
}
pub async fn ro_transaction<Fun, RetFut, Ret>(&self, transaction: Fun) -> indexed_db::Result<Ret, std::io::Error>
where
Fun: 'static + FnOnce(Transaction<std::io::Error>) -> RetFut,
RetFut: 'static + Future<Output = indexed_db::Result<Ret, std::io::Error>>,
Ret: 'static,
{
self.get_indexed_db().await.expect("Failed to open database")
.transaction(&[STORE_NAME])
.run(transaction).await
}
}
pub fn get_ms_timestamp() -> u32 {

8
web/src/web.rs
View File

@ -20,20 +20,20 @@ use crate::{api, routing::Handler as RouteHandler};
#[instrument]
#[component]
pub fn UI<G: Html>(cx: Scope) -> View<G> {
let view = create_signal(cx, View::empty());
api::HttpStore::provide_context(cx, "/api".to_owned());
let store = api::HttpStore::get_from_context(cx).as_ref().clone();
info!("Starting UI");
spawn_local_scoped(cx, {
async move {
let local_store = api::LocalStore::new();
let app_state = if let Some(app_state) = local_store.fetch_app_state() {
let app_state = if let Some(app_state) = local_store.fetch_app_state().await {
app_state
} else {
crate::app_state::AppState::new()
};
debug!(?app_state, "Loaded app state from local storage");
let sh = crate::app_state::get_state_handler(cx, app_state, store);
let view = create_signal(cx, View::empty());
spawn_local_scoped(cx, {
async move {
sh.dispatch(cx, Message::LoadState(None));
view.set(view! { cx,
RouteHandler(sh=sh)