856f865cf98d
indexed_presets.rs
//! IndexedDB owns durable bytes; the engine sees only the bounded, Send memory bridge.
//! Each batch commits tips, groups and index together, and success means transaction completion.
use std::{
cell::{Cell, RefCell},
rc::Rc,
};
use js_sys::{Array, Function, JsString, Promise, Uint8Array};
use wasm_bindgen::{JsCast, JsValue, closure::Closure};
use wasm_bindgen_futures::JsFuture;
use web_sys::{Blob, Event, EventTarget, IdbDatabase, IdbRequest, IdbTransactionMode};
use crate::preset_bridge::{ActionKeys, Batch, Bridge, MAX_RECORDS, WriteError, record_limit};
use photocraft_engine::preset_store::{ACTIONS_FILE, MAX_ACTIONS_BYTES, MAX_STORE_BYTES};
const DATABASE: &str = "photocraft.presets";
const FILES: &str = "files";
const TIMEOUT_MS: f64 = 10_000.0;
fn js(e: JsValue) -> String {
if let Some(exception) = e.dyn_ref::<web_sys::DomException>() {
format!("{}: {}", exception.name(), exception.message())
} else {
e.as_string().unwrap_or_else(|| format!("{e:?}"))
}
}
/// Listeners are detached even when startup or a write times out.
type Listener = (EventTarget, &'static str, Closure<dyn FnMut(Event)>);
struct Listeners(Vec<Listener>);
impl Listeners {
fn new() -> Self {
Self(Vec::new())
}
fn add(&mut self, target: &EventTarget, name: &'static str, f: impl FnMut(Event) + 'static) -> Result<(), JsValue> {
let cb = Closure::<dyn FnMut(Event)>::new(f);
target.add_event_listener_with_callback(name, cb.as_ref().unchecked_ref())?;
self.0.push((target.clone(), name, cb));
Ok(())
}
}
impl Drop for Listeners {
fn drop(&mut self) {
for (target, name, cb) in &self.0 {
let _ = target.remove_event_listener_with_callback(name, cb.as_ref().unchecked_ref());
}
}
}
struct Pending {
promise: Promise,
_listeners: Listeners,
}
fn request(request: &IdbRequest) -> Pending {
let mut listeners = Listeners::new();
let promise = Promise::new(&mut |resolve, reject| {
let req = request.clone();
let failed = reject.clone();
if let Err(e) = listeners.add(request, "success", move |_| match req.result() {
Ok(v) => {
let _ = resolve.call1(&JsValue::NULL, &v);
}
Err(e) => {
let _ = failed.call1(&JsValue::NULL, &e);
}
}) {
let _ = reject.call1(&JsValue::NULL, &e);
}
let req = request.clone();
let failed = reject.clone();
if let Err(e) = listeners.add(request, "error", move |_| {
let e = req.error().ok().flatten().map(JsValue::from).unwrap_or_else(|| JsValue::from_str("IndexedDB request failed"));
let _ = failed.call1(&JsValue::NULL, &e);
}) {
let _ = reject.call1(&JsValue::NULL, &e);
}
});
Pending { promise, _listeners: listeners }
}
/// A single deadline bounds the whole startup read, not ten seconds per record.
async fn before(promise: &Promise, deadline: f64) -> Result<JsValue, String> {
let window = web_sys::window().ok_or("no window")?;
let mut timer = None;
let mut callback = None;
let timeout = Promise::new(&mut |_, reject| {
let cb = Closure::<dyn FnMut()>::new(move || {
let _ = reject.call1(&JsValue::NULL, &JsValue::from_str("browser preset storage timed out"));
});
timer = Some(window.set_timeout_with_callback_and_timeout_and_arguments_0(
cb.as_ref().unchecked_ref(),
(deadline - js_sys::Date::now()).clamp(0.0, TIMEOUT_MS) as i32,
));
callback = Some(cb);
});
let id = timer.ok_or("could not start storage timeout")?.map_err(js)?;
let result = JsFuture::from(Promise::race(&Array::of2(promise, &timeout))).await.map_err(js);
window.clear_timeout_with_handle(id);
drop(callback);
result
}
async fn open(deadline: f64) -> Result<IdbDatabase, String> {
let factory = web_sys::window().ok_or("no window")?.indexed_db().map_err(js)?.ok_or("IndexedDB unavailable")?;
// Version 2 excludes old tabs that could still overwrite the paired Actions record with a Blob.
let req = factory.open_with_u32(DATABASE, 2).map_err(js)?;
let mut upgrade = Listeners::new();
let upgrade_req = req.clone();
upgrade
.add(&req, "upgradeneeded", move |_| {
let result = (|| -> Result<(), JsValue> {
let db = upgrade_req.result()?.dyn_into::<IdbDatabase>()?;
let tx = upgrade_req.transaction().ok_or_else(|| JsValue::from_str("No preset database upgrade transaction"))?;
if tx.object_store(FILES).is_err() {
db.create_object_store(FILES)?;
}
Ok(())
})();
if result.is_err()
&& let Some(tx) = upgrade_req.transaction()
{
let _ = tx.abort();
}
})
.map_err(js)?;
let pending = request(&req);
match before(&pending.promise, deadline).await {
Ok(value) => value.dyn_into().map_err(|_| "invalid preset database".into()),
Err(e) => {
// An open request cannot be cancelled (another tab may block its upgrade). Keep
// its handlers alive and close any late connection; never hydrate a live session.
wasm_bindgen_futures::spawn_local(async move {
if let Ok(value) = JsFuture::from(pending.promise.clone()).await
&& let Ok(db) = value.dyn_into::<IdbDatabase>()
{
db.close();
}
drop(pending);
drop(upgrade);
});
Err(e)
}
}
}
pub async fn load() -> Result<(IdbDatabase, Bridge, Vec<String>), String> {
let deadline = js_sys::Date::now() + TIMEOUT_MS;
let db = open(deadline).await?;
let result = read(&db, deadline).await;
match result {
Ok((bridge, warnings)) => Ok((db, bridge, warnings)),
Err(e) => {
db.close();
Err(e)
}
}
}
async fn read(db: &IdbDatabase, deadline: f64) -> Result<(Bridge, Vec<String>), String> {
let tx = db.transaction_with_str_and_mode(FILES, IdbTransactionMode::Readonly).map_err(js)?;
let req = tx.object_store(FILES).map_err(js)?.open_cursor().map_err(js)?;
let mut records = Vec::new();
let mut warnings = Vec::new();
let mut unreadable = Vec::new();
let mut total = 0u64;
let mut seen = 0usize;
let mut action_record = None;
let mut action_issue = None;
let mut next = request(&req);
loop {
let value = before(&next.promise, deadline).await?;
if value.is_null() {
break;
}
let cursor = value.dyn_into::<web_sys::IdbCursorWithValue>().map_err(|_| "invalid preset cursor")?;
seen += 1;
if seen > MAX_RECORDS {
return Err(format!("browser preset record limit ({MAX_RECORDS}) exceeded"));
}
let key = cursor.key().map_err(js)?;
// Inspect key length in JS before allocating its Rust String.
let name = if key.is_string() && js_sys::JsString::from(key.clone()).length() <= 133 { key.as_string().unwrap_or_default() } else { String::new() };
let stored = cursor.value().map_err(js)?;
if name == ACTIONS_FILE && !stored.is_instance_of::<Blob>() {
match paired_actions(&stored) {
Ok(record) => action_record = Some(record),
Err(error) => action_issue = Some(error),
}
next = request(&req);
cursor.continue_().map_err(js)?;
continue;
}
let blob = stored.dyn_into::<Blob>();
let record = record_limit(&name).and_then(|limit| {
let blob = blob.map_err(|_| "record is not a Blob".to_string())?;
if blob.size() > limit as f64 {
return Err("record is too large".into());
}
Ok(blob)
});
match record {
Ok(blob) => {
total = total.saturating_add(blob.size() as u64);
if total > MAX_STORE_BYTES {
return Err("browser preset store exceeds size limit".into());
}
records.push((name, blob));
}
Err(e) => {
// Leave an unreadable placeholder in the engine's file inventory. In
// particular, a skipped group must protect its tip records from orphan GC.
if record_limit(&name).is_ok() {
unreadable.push(name.clone());
}
if warnings.len() < 8 {
warnings.push(format!("Brush presets: {name} skipped: {e}"));
}
}
}
// Register the next callback before continuing the cursor. Blob reads happen after
// enumeration, since awaiting them here would let this transaction become inactive.
next = request(&req);
cursor.continue_().map_err(js)?;
}
let bridge = Bridge::default();
for name in unreadable {
bridge.load(&name, Vec::new())?;
}
for (name, blob) in records {
let result = before(&blob.array_buffer(), deadline).await.and_then(|buffer| bridge.load(&name, Uint8Array::new(&buffer).to_vec()));
if let Err(error) = result {
if name != ACTIONS_FILE {
return Err(error);
}
action_issue = Some(error);
}
}
if let Some((revision, definitions, keys)) = action_record {
let result = async {
// A paired record beyond the remaining definition budget leaves the ordinary presets usable.
if total.saturating_add(definitions.as_ref().map_or(0, |blob| blob.size() as u64)) > MAX_STORE_BYTES {
return Err("browser preset store exceeds size limit".into());
}
let buffer = before(&keys.array_buffer(), deadline).await?;
let keys = ActionKeys::decode(&Uint8Array::new(&buffer).to_vec())?;
if let Some(blob) = definitions {
let buffer = before(&blob.array_buffer(), deadline).await?;
bridge.load(ACTIONS_FILE, Uint8Array::new(&buffer).to_vec())?;
}
bridge.load_action_keys(revision, keys);
Ok::<_, String>(())
}
.await;
if let Err(error) = result {
action_issue = Some(error);
}
}
if let Some(error) = action_issue {
// A placeholder tells the engine that this file exists and must be left unchanged.
// It never enters a write batch, and the unrelated records loaded above remain usable.
bridge.load(ACTIONS_FILE, Vec::new())?;
warnings.push(format!("Browser Actions were not loaded: {error}"));
bridge.quarantine_actions(error);
}
Ok((bridge, warnings))
}
/// A v2 Actions record has one generation, optional definition bytes and Action-only preferences.
fn paired_actions(value: &JsValue) -> Result<(u64, Option<Blob>, Blob), String> {
let invalid = "Invalid paired browser Actions record";
let row = value.dyn_ref::<Array>().filter(|row| row.length() == 3).ok_or(invalid)?;
let revision = row.get(0);
let generation = revision.is_string().then(|| JsString::from(revision.clone())).filter(|s| s.length() <= 20).ok_or(invalid)?;
let text = generation.as_string().ok_or(invalid)?;
let revision = text.parse::<u64>().ok().filter(|r| *r > 0 && r.to_string() == text).ok_or(invalid)?;
let bytes = row.get(1);
let definitions = if bytes.is_null() { None } else { Some(bytes.dyn_into::<Blob>().map_err(|_| invalid)?) };
let keys = row.get(2).dyn_into::<Blob>().map_err(|_| invalid)?;
if keys.size() > MAX_ACTIONS_BYTES as f64 || definitions.as_ref().is_some_and(|blob| blob.size() > MAX_ACTIONS_BYTES as f64) {
return Err("Paired browser Actions record is too large".into());
}
Ok((revision, definitions, keys))
}
fn blob(bytes: &[u8]) -> Result<Blob, String> {
Blob::new_with_u8_array_sequence(&Array::of1(&Uint8Array::from(bytes))).map_err(js)
}
pub async fn write(db: &IdbDatabase, batch: &Batch) -> Result<(), WriteError> {
let tx = db.transaction_with_str_and_mode(FILES, IdbTransactionMode::Readwrite).map_err(js)?;
let store = tx.object_store(FILES).map_err(js)?;
let mut compare = Listeners::new();
let compare_error = Rc::new(RefCell::new(None));
let queued = (|| -> Result<(), String> {
match batch {
Batch::Files(files) => {
for (name, bytes) in files {
let key = JsValue::from_str(name);
if let Some(bytes) = bytes {
store.put_with_key(blob(bytes)?.as_ref(), &key).map_err(js)?;
} else {
store.delete(&key).map_err(js)?;
}
}
}
Batch::Actions(action) => {
let keys = action.keys.encode()?;
if keys.len() as u64 > MAX_ACTIONS_BYTES {
return Err("Browser Action shortcuts are too large to save".into());
}
let definitions = action.definitions.as_deref().map(blob).transpose()?.map_or(JsValue::NULL, JsValue::from);
let keys = blob(&keys)?;
let record = Array::of3(&JsValue::from_str(&action.revision.to_string()), &definitions, keys.as_ref());
let base = action.base;
let key = JsValue::from_str(ACTIONS_FILE);
let request = store.get(&key).map_err(js)?;
let read = request.clone();
let store = store.clone();
let tx = tx.clone();
let compare_error = compare_error.clone();
// Compare and queue synchronously while this isolated readwrite transaction is active.
compare
.add(&request, "success", move |_| {
let outcome = (|| -> Result<(), WriteError> {
let current = read.result().map_err(js)?;
let revision = if current.is_undefined() || current.is_instance_of::<Blob>() {
0
} else {
paired_actions(¤t).map_err(WriteError::Blocked)?.0
};
if revision != base {
return Err(WriteError::Stale("Actions changed in another tab.".into()));
}
store.put_with_key(&record, &key).map_err(js)?;
Ok(())
})();
if let Err(error) = outcome {
*compare_error.borrow_mut() = Some(error);
let _ = tx.abort();
}
})
.map_err(js)?;
}
}
Ok(())
})();
if let Err(error) = queued {
return Err(if tx.abort().is_ok() { WriteError::Aborted(error) } else { WriteError::Uncertain(error) });
}
let mut listeners = Listeners::new();
let terminal = Rc::new(Cell::new(None));
let promise = Promise::new(&mut |resolve, reject| {
let completed = terminal.clone();
if let Err(e) = listeners.add(&tx, "complete", move |_| {
completed.set(Some(true));
let _ = resolve.call0(&JsValue::NULL);
}) {
let _ = reject.call1(&JsValue::NULL, &e);
}
let aborted = terminal.clone();
let tx_for_error = tx.clone();
let failed: Function = reject.clone();
if let Err(e) = listeners.add(&tx, "abort", move |_| {
aborted.set(Some(false));
let e = tx_for_error.error().map(JsValue::from).unwrap_or_else(|| JsValue::from_str("preset transaction aborted"));
let _ = failed.call1(&JsValue::NULL, &e);
}) {
let _ = reject.call1(&JsValue::NULL, &e);
}
});
let outcome = before(&promise, js_sys::Date::now() + TIMEOUT_MS).await;
if let Some(error) = compare_error.take() {
// No put was queued on any comparison failure.
return Err(error);
}
match terminal.get() {
Some(true) => Ok(()),
Some(false) => Err(WriteError::Aborted(outcome.err().unwrap_or_else(|| "Preset transaction aborted".into()))),
None => {
let _ = tx.abort();
let error = outcome.err().unwrap_or_else(|| "No preset transaction result".into());
let message = format!("Preset commit could not be confirmed: {error}");
let message = if matches!(batch, Batch::Actions(_)) { format!("{message}. Reopen the page before saving Actions again.") } else { message };
Err(WriteError::Uncertain(message))
}
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.