mod key_path;
mod object_store_params;
pub use self::{key_path::KeyPath, object_store_params::ObjectStoreParams};
use wasm_bindgen::{JsCast, JsValue};
use web_sys::IdbObjectStore;
use crate::{
utils::dom_string_list_to_vec, CursorDirection, Error, Index, IndexParams, Query, StoreRequest,
Transaction,
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ObjectStore {
inner: IdbObjectStore,
}
impl ObjectStore {
pub fn name(&self) -> String {
self.inner.name()
}
pub fn set_name(&self, name: &str) {
self.inner.set_name(name)
}
pub fn key_path(&self) -> Result<Option<KeyPath>, Error> {
let inner_key_path = self.inner.key_path().map_err(Error::KeyPathNotFound)?;
if inner_key_path.is_null() {
Ok(None)
} else {
Some(inner_key_path.try_into()).transpose()
}
}
pub fn index_names(&self) -> Vec<String> {
dom_string_list_to_vec(&self.inner.index_names())
}
pub fn transaction(&self) -> Transaction {
self.inner.transaction().into()
}
pub fn auto_increment(&self) -> bool {
self.inner.auto_increment()
}
pub fn put(&self, value: &JsValue, key: Option<&JsValue>) -> Result<StoreRequest, Error> {
match key {
None => self.inner.put(value),
Some(key) => self.inner.put_with_key(value, key),
}
.map(Into::into)
.map_err(Error::UpdateFailed)
}
pub fn add(&self, value: &JsValue, key: Option<&JsValue>) -> Result<StoreRequest, Error> {
match key {
None => self.inner.add(value),
Some(key) => self.inner.add_with_key(value, key),
}
.map(Into::into)
.map_err(Error::AddFailed)
}
pub fn delete(&self, query: impl Into<Query>) -> Result<StoreRequest, Error> {
self.inner
.delete(&query.into().into())
.map(Into::into)
.map_err(Error::DeleteFailed)
}
pub fn clear(&self) -> Result<StoreRequest, Error> {
self.inner
.clear()
.map(Into::into)
.map_err(Error::ClearFailed)
}
pub fn get(&self, query: impl Into<Query>) -> Result<StoreRequest, Error> {
self.inner
.get(&query.into().into())
.map(Into::into)
.map_err(Error::GetFailed)
}
pub fn get_key(&self, query: impl Into<Query>) -> Result<StoreRequest, Error> {
self.inner
.get_key(&query.into().into())
.map(Into::into)
.map_err(Error::GetKeyFailed)
}
pub fn get_all(&self, query: Option<Query>, limit: Option<u32>) -> Result<StoreRequest, Error> {
match (query, limit) {
(Some(query), Some(limit)) => self
.inner
.get_all_with_key_and_limit(&query.into(), limit)
.map(Into::into)
.map_err(Error::GetAllKeysFailed),
(Some(query), None) => self
.inner
.get_all_with_key(&query.into())
.map(Into::into)
.map_err(Error::GetAllKeysFailed),
(None, Some(limit)) => self
.inner
.get_all_with_key_and_limit(&JsValue::null(), limit)
.map(Into::into)
.map_err(Error::GetAllKeysFailed),
(None, None) => self
.inner
.get_all()
.map(Into::into)
.map_err(Error::GetAllKeysFailed),
}
}
pub fn get_all_keys(
&self,
query: Option<Query>,
limit: Option<u32>,
) -> Result<StoreRequest, Error> {
match (query, limit) {
(Some(query), Some(limit)) => self
.inner
.get_all_keys_with_key_and_limit(&query.into(), limit)
.map(Into::into)
.map_err(Error::GetAllKeysFailed),
(Some(query), None) => self
.inner
.get_all_keys_with_key(&query.into())
.map(Into::into)
.map_err(Error::GetAllKeysFailed),
(None, Some(limit)) => self
.inner
.get_all_keys_with_key_and_limit(&JsValue::null(), limit)
.map(Into::into)
.map_err(Error::GetAllKeysFailed),
(None, None) => self
.inner
.get_all_keys()
.map(Into::into)
.map_err(Error::GetAllKeysFailed),
}
}
pub fn count(&self, query: Option<Query>) -> Result<StoreRequest, Error> {
match query {
None => self
.inner
.count()
.map(Into::into)
.map_err(Error::CountFailed),
Some(query) => self
.inner
.count_with_key(&query.into())
.map(Into::into)
.map_err(Error::CountFailed),
}
}
pub fn open_cursor(
&self,
query: Option<Query>,
cursor_direction: Option<CursorDirection>,
) -> Result<StoreRequest, Error> {
match (query, cursor_direction) {
(Some(query), Some(cursor_direction)) => self
.inner
.open_cursor_with_range_and_direction(&query.into(), cursor_direction.into())
.map(Into::into)
.map_err(Error::OpenCursorFailed),
(Some(query), None) => self
.inner
.open_cursor_with_range(&query.into())
.map(Into::into)
.map_err(Error::OpenCursorFailed),
(None, Some(cursor_direction)) => self
.inner
.open_cursor_with_range_and_direction(&JsValue::null(), cursor_direction.into())
.map(Into::into)
.map_err(Error::OpenCursorFailed),
(None, None) => self
.inner
.open_cursor()
.map(Into::into)
.map_err(Error::OpenCursorFailed),
}
}
pub fn open_key_cursor(
&self,
query: Option<Query>,
cursor_direction: Option<CursorDirection>,
) -> Result<StoreRequest, Error> {
match (query, cursor_direction) {
(Some(query), Some(cursor_direction)) => self
.inner
.open_key_cursor_with_range_and_direction(&query.into(), cursor_direction.into())
.map(Into::into)
.map_err(Error::OpenCursorFailed),
(Some(query), None) => self
.inner
.open_key_cursor_with_range(&query.into())
.map(Into::into)
.map_err(Error::OpenCursorFailed),
(None, Some(cursor_direction)) => self
.inner
.open_key_cursor_with_range_and_direction(&JsValue::null(), cursor_direction.into())
.map(Into::into)
.map_err(Error::OpenCursorFailed),
(None, None) => self
.inner
.open_key_cursor()
.map(Into::into)
.map_err(Error::OpenCursorFailed),
}
}
pub fn index(&self, name: &str) -> Result<Index, Error> {
self.inner
.index(name)
.map(Into::into)
.map_err(Error::IndexNotFound)
}
pub fn create_index(
&self,
name: &str,
key_path: KeyPath,
params: Option<IndexParams>,
) -> Result<Index, Error> {
match params {
None => self
.inner
.create_index_with_str_sequence(name, &key_path.into()),
Some(params) => self
.inner
.create_index_with_str_sequence_and_optional_parameters(
name,
&key_path.into(),
¶ms.into(),
),
}
.map(Into::into)
.map_err(Error::IndexCreateFailed)
}
pub fn delete_index(&self, name: &str) -> Result<(), Error> {
self.inner
.delete_index(name)
.map_err(Error::IndexDeleteFailed)
}
}
impl From<IdbObjectStore> for ObjectStore {
fn from(inner: IdbObjectStore) -> Self {
Self { inner }
}
}
impl From<ObjectStore> for IdbObjectStore {
fn from(object_store: ObjectStore) -> Self {
object_store.inner
}
}
impl TryFrom<JsValue> for ObjectStore {
type Error = Error;
fn try_from(value: JsValue) -> Result<Self, Self::Error> {
value
.dyn_into::<IdbObjectStore>()
.map(Into::into)
.map_err(|value| Error::UnexpectedJsType("IdbObjectStore", value))
}
}
impl From<ObjectStore> for JsValue {
fn from(value: ObjectStore) -> Self {
value.inner.into()
}
}