Updating the Web Storage interface

* remove panics
* support both local and session storage
* provide detailed error conditions
* provide a fuller interface

Author: itsgreggreg

examples/todomvc/src/lib.rs

@@ -1,10 +1,6 @@
 use enclose::enc;
 use indexmap::IndexMap;
-use seed::{
-    browser::service::storage::{self, Storage},
-    prelude::*,
-    *,
-};
+use seed::{browser::service::web_storage::WebStorage, prelude::*, *};
 use serde::{Deserialize, Serialize};
 use std::mem;
 use uuid::Uuid;
@@ -37,7 +33,7 @@ struct Data {
 }
 
 struct Services {
-    local_storage: Storage,
+    local_storage: WebStorage,
 }
 
 #[derive(Default)]
@@ -95,8 +91,8 @@ fn init(url: Url, orders: &mut impl Orders<Msg>) -> Model {
         .subscribe(Msg::UrlChanged)
         .notify(subs::UrlChanged(url));
 
-    let local_storage = storage::get_storage().expect("get `LocalStorage`");
-    let data = storage::load_data(&local_storage, STORAGE_KEY).unwrap_or_default();
+    let local_storage = web_storage::get_local_storage().expect("get `LocalStorage`");
+    let data = local_storage.load(STORAGE_KEY).unwrap_or_default();
 
     Model {
         data,
@@ -209,7 +205,7 @@ fn update(msg: Msg, model: &mut Model, orders: &mut impl Orders<Msg>) {
         Msg::NoOp => (),
     }
     // Save data into LocalStorage. It should be optimized in a real-world application.
-    storage::store_data(&model.services.local_storage, STORAGE_KEY, &data);
+    model.services.local_storage.save(STORAGE_KEY, &data);
 }
 
 // ------ ------

src/browser/service.rs

@@ -1,3 +1,4 @@
 pub mod fetch;
 pub mod routing;
 pub mod storage;
+pub mod web_storage;

src/browser/service/storage.rs

@@ -10,6 +10,7 @@ extern crate serde_json;
 
 pub type Storage = web_sys::Storage;
 
+#[deprecated(since = "0.7.0", note = "Use web_storage::get_local_storage")]
 #[allow(clippy::module_name_repetitions)]
 pub fn get_storage() -> Option<Storage> {
     web_sys::window()
@@ -20,6 +21,7 @@ pub fn get_storage() -> Option<Storage> {
 }
 
 /// Create a new store, from a serializable data structure.
+#[deprecated(since = "0.7.0", note = "use WebStorage.store_data")]
 pub fn store_data<T>(storage: &Storage, name: &str, data: &T)
 where
     T: serde::Serialize,
@@ -31,6 +33,7 @@ where
 }
 
 /// Load a store, to a deserializable data structure.
+#[deprecated(since = "0.7.0", note = "use WebStorage.load_data")]
 pub fn load_data<T>(storage: &Storage, name: &str) -> Option<T>
 where
     T: serde::de::DeserializeOwned,

src/browser/service/web_storage.rs

@@ -0,0 +1,134 @@
+//! Allows use of the Web Storage API including both local and session storage.
+//!
+//! # References
+//! * [MDN docs](https://developer.mozilla.org/en-US/docs/Web/API/Storage)
+//! * [web-sys docs](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Storage.html)
+//! * [Example syntax](https://github.com/rustwasm/wasm-bindgen/blob/master/examples/todomvc/src/store.rs)
+
+extern crate serde;
+extern crate serde_json;
+use crate::browser::util::window;
+use web_sys::Storage;
+
+pub type JsValue = wasm_bindgen::JsValue;
+
+pub enum Mechanism {
+    LocalStorage,
+    SessionStorage,
+}
+
+pub struct WebStorage {
+    pub mechanism: Mechanism,
+    storage: Storage,
+}
+
+/// Things that can go wrong when trying to load data from storage.
+pub enum LoadError {
+    /// Could not connect to storage.
+    CouldNotConnect(JsValue),
+    /// The data could not be decoded from JSON.
+    CouldNotDecode(serde_json::Error),
+    /// There is no data for that key.
+    NoData,
+}
+
+/// Things that can go wrong when trying to save data to storage.
+pub enum SaveError {
+    /// The browser denied saving to storage. Usually because the storage is full.
+    /// See: https://developer.mozilla.org/en-US/docs/Web/API/Storage/setItem#Exceptions
+    CouldNotSave(JsValue),
+    /// Supplied data could not be encoded to json.
+    CouldNotEncode(serde_json::Error),
+}
+
+impl WebStorage {
+    /// Clear all data in storage
+    pub fn clear(&self) -> bool {
+        self.storage.clear().is_ok()
+    }
+
+    /// A vector of all the keys in storage
+    ///
+    /// # Errors
+    ///
+    /// Will return a `Err(JsValue)` if the storage length could not be retrieved.
+    pub fn keys(storage: &Storage) -> Result<Vec<String>, JsValue> {
+        let mut keys = vec![];
+        let length = storage.length()?;
+        for index in 0..length {
+            if let Ok(Some(key)) = storage.key(index) {
+                keys.push(key);
+            }
+        }
+        Ok(keys)
+    }
+
+    /// Load a JSON deserializable data structure from storage.
+    ///
+    /// # Errors
+    ///
+    /// Will return a `Err(LoadError)` if the data could not be loaded
+    pub fn load<T>(&self, key: &str) -> Result<T, LoadError>
+    where
+        T: serde::de::DeserializeOwned,
+    {
+        let item = self
+            .storage
+            .get_item(key)
+            .map_err(LoadError::CouldNotConnect)?;
+
+        match item {
+            None => Err(LoadError::NoData),
+            Some(d) => {
+                let decoded = serde_json::from_str(&d);
+                decoded.map_err(LoadError::CouldNotDecode)
+            }
+        }
+    }
+
+    /// Delete a key and associated data from storage
+    pub fn delete(&self, key: &str) -> bool {
+        self.storage.remove_item(key).is_ok()
+    }
+
+    /// Save a JSON serializable data structure to storage.
+    ///
+    /// # Errors
+    ///
+    /// Will return a `SaveError` if the data could not be saved
+    pub fn save<T>(&self, key: &str, data: &T) -> Result<(), SaveError>
+    where
+        T: serde::Serialize,
+    {
+        let serialized = serde_json::to_string(&data).map_err(SaveError::CouldNotEncode)?;
+        self.storage
+            .set_item(key, &serialized)
+            .map_err(SaveError::CouldNotSave)
+    }
+}
+
+/// Get an instance of Local Storage
+/// Local Storage maintains a storage area that persists even when the browser
+/// is closed and reopened
+pub fn get_local_storage() -> Option<WebStorage> {
+    window()
+        .local_storage()
+        .unwrap_or(None)
+        .map(|storage| WebStorage {
+            mechanism: Mechanism::LocalStorage,
+            storage,
+        })
+}
+
+/// Get an instance of Session Storage
+/// Session Storage maintains a storage area for the duration of the page session
+/// (as long as the browser is open, including page reloads and restores)
+pub fn get_session_storage() -> Option<WebStorage> {
+    window()
+        .session_storage()
+        .unwrap_or(None)
+        .map(|storage| WebStorage {
+            mechanism: Mechanism::SessionStorage,
+            storage,
+        })
+}

src/lib.rs

@@ -19,6 +19,7 @@ pub use crate::{
     browser::service::fetch::{Method, Request, ResponseDataResult, ResponseResult},
     browser::service::routing::push_route,
     browser::service::storage,
+    browser::service::web_storage,
     browser::url::Url,
     browser::util::{
         self, body, canvas, canvas_context_2d, cookies, document, error, history, html_document,