use std::cell::RefCell;
use std::convert::Infallible;
use std::ops::{Bound, RangeBounds};
use std::rc::Rc;
use indexed_db::{CursorDirection, Database, Factory};
use js_sys::Uint8Array;
use wasm_bindgen::JsValue;
use super::api::{BFut, Backend, KeyRange, Op, ScanPage, ScanRequest, Table, Usage};
use crate::error::{Error, Result};
const VERSION: u32 = 1;
const STORES: [&str; 3] = ["meta", "records", "chunks"];
#[derive(Debug)]
pub struct IndexedDbBackend {
db: RefCell<Option<Rc<Database<Infallible>>>>,
name: String,
}
impl IndexedDbBackend {
pub async fn open(name: impl Into<String>) -> Result<Self> {
let name = name.into();
let db = Self::connect(&name).await?;
let db = if db.object_store_names().is_empty() {
db.close();
Factory::<Infallible>::get()
.map_err(map_err)?
.delete_database(&name)
.await
.map_err(map_err)?;
Self::connect(&name).await?
} else {
db
};
let present = db.object_store_names();
let missing: Vec<&str> = STORES
.into_iter()
.filter(|store| !present.iter().any(|have| have.as_str() == *store))
.collect();
if !missing.is_empty() {
db.close();
return Err(Error::Corrupt(format!(
"IndexedDB database {name:?} is not a crossbank bank: missing [{}], has [{}]",
missing.join(", "),
present.join(", "),
)));
}
Ok(Self {
db: RefCell::new(Some(Rc::new(db))),
name,
})
}
async fn connect(name: &str) -> Result<Database<Infallible>> {
let factory = Factory::<Infallible>::get().map_err(map_err)?;
factory
.open(name, VERSION, async move |evt| {
let database = evt.database();
for store in STORES {
database.build_object_store(store).create()?;
}
Ok(())
})
.await
.map_err(map_err)
}
fn db(&self) -> Result<Rc<Database<Infallible>>> {
self.db.borrow().as_ref().cloned().ok_or(Error::Closed)
}
pub fn name(&self) -> &str {
&self.name
}
pub async fn delete_database(name: &str) -> Result<()> {
let factory = Factory::<Infallible>::get().map_err(map_err)?;
factory.delete_database(name).await.map_err(map_err)
}
}
impl Drop for IndexedDbBackend {
fn drop(&mut self) {
if let Some(db) = self.db.borrow_mut().take() {
db.close();
}
}
}
fn js_bytes(bytes: &[u8]) -> JsValue {
Uint8Array::from(bytes).into()
}
fn from_js_bytes(value: &JsValue) -> Result<Vec<u8>> {
Ok(Uint8Array::new(value).to_vec())
}
fn map_err<E: std::fmt::Display>(err: indexed_db::Error<E>) -> Error {
let message = err.to_string();
if message.contains("QuotaExceeded") {
return Error::QuotaExceeded {
needed: 0,
available: None,
};
}
Error::Backend(message)
}
struct JsBounds {
start: Bound<JsValue>,
end: Bound<JsValue>,
}
impl RangeBounds<JsValue> for JsBounds {
fn start_bound(&self) -> Bound<&JsValue> {
match &self.start {
Bound::Unbounded => Bound::Unbounded,
Bound::Included(v) => Bound::Included(v),
Bound::Excluded(v) => Bound::Excluded(v),
}
}
fn end_bound(&self) -> Bound<&JsValue> {
match &self.end {
Bound::Unbounded => Bound::Unbounded,
Bound::Included(v) => Bound::Included(v),
Bound::Excluded(v) => Bound::Excluded(v),
}
}
}
fn to_js_bounds(range: &KeyRange) -> JsBounds {
fn map(bound: &Bound<Vec<u8>>) -> Bound<JsValue> {
match bound {
Bound::Unbounded => Bound::Unbounded,
Bound::Included(k) => Bound::Included(js_bytes(k)),
Bound::Excluded(k) => Bound::Excluded(js_bytes(k)),
}
}
JsBounds {
start: map(&range.start),
end: map(&range.end),
}
}
fn range_is_all(range: &KeyRange) -> bool {
matches!(range.start, Bound::Unbounded) && matches!(range.end, Bound::Unbounded)
}
impl Backend for IndexedDbBackend {
fn get<'a>(&'a self, table: Table, key: &'a [u8]) -> BFut<'a, Option<Vec<u8>>> {
let store_name = table.name();
let key = js_bytes(key);
Box::pin(async move {
let db = self.db()?;
let got = db
.transaction(&[store_name])
.run(async move |t| {
let store = t.object_store(store_name)?;
store.get(&key).await
})
.await
.map_err(map_err)?;
match got {
Some(value) => Ok(Some(from_js_bytes(&value)?)),
None => Ok(None),
}
})
}
fn get_many<'a>(&'a self, table: Table, keys: Vec<Vec<u8>>) -> BFut<'a, Vec<Option<Vec<u8>>>> {
let store_name = table.name();
Box::pin(async move {
let js_keys: Vec<JsValue> = keys.iter().map(|k| js_bytes(k)).collect();
let db = self.db()?;
db.transaction(&[store_name])
.run(async move |t| {
let store = t.object_store(store_name)?;
let mut out = Vec::with_capacity(js_keys.len());
for key in &js_keys {
match store.get(key).await? {
Some(value) => out.push(Some(Uint8Array::new(&value).to_vec())),
None => out.push(None),
}
}
Ok(out)
})
.await
.map_err(map_err)
})
}
fn scan(&self, request: ScanRequest) -> BFut<'_, ScanPage> {
let store_name = request.table.name();
Box::pin(async move {
let bounds = to_js_bounds(&request.range);
let unbounded = range_is_all(&request.range);
let reverse = request.reverse;
let limit = request.limit;
let want_values = request.want_values;
let direction = if reverse {
CursorDirection::Prev
} else {
CursorDirection::Next
};
let db = self.db()?;
db.transaction(&[store_name])
.run(async move |t| {
let store = t.object_store(store_name)?;
let mut builder = store.cursor().direction(direction);
if !unbounded {
builder = builder.range(bounds)?;
}
let mut cursor = if want_values {
builder.open().await?
} else {
builder.open_key().await?
};
let mut items = Vec::new();
let mut resume = None;
loop {
let Some(key_js) = cursor.key() else {
break;
};
let key = Uint8Array::new(&key_js).to_vec();
let value = if want_values {
cursor.value().map(|v| Uint8Array::new(&v).to_vec())
} else {
None
};
items.push((key, value));
if items.len() >= limit {
match cursor.advance(1).await {
Ok(()) if cursor.key().is_some() => {
resume = items.last().map(|(k, _)| k.clone());
}
Ok(()) => resume = None,
Err(indexed_db::Error::CursorCompleted) => resume = None,
Err(e) => return Err(e),
}
break;
}
match cursor.advance(1).await {
Ok(()) => {}
Err(indexed_db::Error::CursorCompleted) => break,
Err(e) => return Err(e),
}
}
Ok(ScanPage { items, resume })
})
.await
.map_err(map_err)
})
}
fn commit(&self, ops: Vec<Op>) -> BFut<'_, ()> {
Box::pin(async move {
let db = self.db()?;
db.transaction(&STORES)
.rw()
.run(async move |t| {
for op in ops {
match op {
Op::Put { table, key, value } => {
let store = t.object_store(table.name())?;
store.put_kv(&js_bytes(&key), &js_bytes(&value)).await?;
}
Op::Delete { table, key } => {
let store = t.object_store(table.name())?;
store.delete(&js_bytes(&key)).await?;
}
Op::DeleteRange { table, range } => {
let store = t.object_store(table.name())?;
if range_is_all(&range) {
store.clear().await?;
} else {
let bounds = to_js_bounds(&range);
store.delete_range(bounds).await?;
}
}
}
}
Ok(())
})
.await
.map_err(map_err)
})
}
fn usage(&self) -> BFut<'_, Option<Usage>> {
Box::pin(async move {
let Some(window) = web_sys::window() else {
return Ok(None);
};
let storage = window.navigator().storage();
let estimate = match storage.estimate() {
Ok(promise) => wasm_bindgen_futures::JsFuture::from(promise).await.ok(),
Err(_) => None,
};
let Some(estimate) = estimate else {
return Ok(None);
};
let number = |field: &str| -> Option<f64> {
js_sys::Reflect::get(&estimate, &JsValue::from_str(field))
.ok()
.and_then(|v| v.as_f64())
.filter(|n| n.is_finite())
};
let Some(used) = number("usage").map(|u| u.max(0.0) as u64) else {
return Ok(None);
};
let available = number("quota").map(|q| q.max(0.0) as u64);
let persisted = match storage.persisted() {
Ok(promise) => wasm_bindgen_futures::JsFuture::from(promise)
.await
.ok()
.and_then(|v| v.as_bool())
.unwrap_or(false),
Err(_) => false,
};
Ok(Some(Usage {
used,
available,
persisted,
}))
})
}
fn close(&self) -> BFut<'_, ()> {
Box::pin(async move {
let taken = self.db.borrow_mut().take();
if let Some(db) = taken {
db.close();
}
Ok(())
})
}
fn flush(&self) -> BFut<'_, ()> {
Box::pin(async move { Ok(()) })
}
}