Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

Web: IndexedDB puts and deletes resolve when their transaction commits (#1242)

tylerjenningswfa6c9ffccd4f
diff --git a/apps/effectcraft-web/js/host.js b/apps/effectcraft-web/js/host.js
index 3db6ad35c..f113c2a2d 100644
--- a/apps/effectcraft-web/js/host.js
+++ b/apps/effectcraft-web/js/host.js
@@ -57,6 +57,26 @@ function req(r) {
return new Promise((res, rej) => { r.onsuccess = () => res(r.result); r.onerror = () => rej(r.error); });
}
+// Run `op` on `store` in a readwrite transaction of its own; resolves once the transaction has
+// committed. A request's success doesn't mean the write is stored: the transaction can still
+// abort afterwards (quota at commit, the browser closing), rolling it back, and a write
+// reported as saved then is never retried (#1242). A failed request aborts the transaction
+// with its error; an explicit abort leaves no error, hence the AbortError.
+function write(db, store, op) {
+ return new Promise((res, rej) => {
+ let tx = null;
+ try {
+ tx = db.transaction(store, "readwrite");
+ tx.oncomplete = () => res();
+ tx.onabort = () => rej(tx.error ?? new DOMException("the storage transaction was aborted", "AbortError"));
+ op(tx.objectStore(store));
+ } catch (e) {
+ try { tx?.abort(); } catch {}
+ rej(e);
+ }
+ });
+}
+
async function idb() {
if (!self.indexedDB) throw new Error("no IndexedDB");
const open = indexedDB.open(DB, 1);
@@ -70,10 +90,10 @@ async function idb() {
return all.map((r) => ({ key: r.key, data: new Uint8Array(r.data), modified: r.modified }));
},
async put(key, data, modified) {
- await req(tx("readwrite").put({ key, data: data.slice().buffer, modified }));
+ await write(db, STORE, (s) => s.put({ key, data: data.slice().buffer, modified }));
},
async del(key) {
- await req(tx("readwrite").delete(key));
+ await write(db, STORE, (s) => s.delete(key));
},
};
}
diff --git a/apps/effectcraft-web/tests/storage.mjs b/apps/effectcraft-web/tests/storage.mjs
new file mode 100644
index 000000000..0855c1674
--- /dev/null
+++ b/apps/effectcraft-web/tests/storage.mjs
@@ -0,0 +1,180 @@
+// The IndexedDB storage backend of the web app (js/host.js) under Node with a fake IndexedDB, no
+// browser or Wasm build needed:
+//
+// node apps/effectcraft-web/tests/storage.mjs
+//
+// A write is acknowledged only once its transaction has committed, not when its request
+// succeeded: a transaction that aborts afterwards rolls the write back, and the write must be
+// reported as failed so the flush keeps it for a retry (#1242). Exits non-zero on failure.
+import assert from "node:assert/strict";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const tick = () => new Promise((r) => setTimeout(r, 0));
+globalThis.self = globalThis;
+
+// A small IndexedDB: requests succeed (or fail) one task after they're made, and a readwrite
+// transaction commits once its requests are done, unless it was aborted (which rolls back its
+// writes). `fault` makes the next request do something else.
+let fault = null; // "abortAfterSuccess" | "requestError" | "throw"
+const databases = new Map();
+
+class Request {
+ constructor(tx) {
+ this.transaction = tx;
+ this.result = undefined;
+ this.error = null;
+ }
+}
+
+class Store {
+ constructor(tx, rows) {
+ this.tx = tx;
+ this.rows = rows;
+ }
+ request(apply) {
+ const tx = this.tx;
+ if (tx.finished) throw new DOMException("the transaction has finished", "TransactionInactiveError");
+ const f = fault;
+ fault = null;
+ if (f === "throw") throw new DOMException("the value can't be cloned", "DataCloneError");
+ const r = new Request(tx);
+ tx.pending++;
+ setTimeout(() => {
+ tx.pending--;
+ if (tx.finished) return;
+ if (f === "requestError") {
+ r.error = new DOMException("the key already exists", "ConstraintError");
+ const e = { target: r, defaultPrevented: false, preventDefault() { this.defaultPrevented = true; } };
+ r.onerror?.(e);
+ tx.onerror?.(e);
+ if (!e.defaultPrevented) tx.fail(r.error);
+ return;
+ }
+ r.result = apply(tx.staged);
+ r.onsuccess?.({ target: r });
+ if (f === "abortAfterSuccess") tx.abort();
+ tx.maybeCommit();
+ }, 0);
+ return r;
+ }
+ put(v) {
+ return this.request((rows) => { rows.set(v[this.keyPath], structuredClone(v)); return v[this.keyPath]; });
+ }
+ delete(k) {
+ return this.request((rows) => { rows.delete(k); });
+ }
+ get(k) {
+ return this.request((rows) => rows.get(k));
+ }
+ getAll() {
+ return this.request((rows) => [...rows.values()]);
+ }
+}
+
+class Transaction {
+ constructor(db, name) {
+ this.db = db;
+ this.name = name;
+ this.staged = new Map(db.stores.get(name));
+ this.pending = 0;
+ this.finished = false;
+ this.error = null;
+ setTimeout(() => this.maybeCommit(), 0);
+ }
+ objectStore(name) {
+ const s = new Store(this, this.staged);
+ s.keyPath = this.db.keyPaths.get(name);
+ return s;
+ }
+ maybeCommit() {
+ if (this.finished || this.pending > 0) return;
+ this.finished = true;
+ this.db.stores.set(this.name, this.staged);
+ setTimeout(() => this.oncomplete?.(), 0);
+ }
+ fail(error) {
+ this.error = error;
+ this.abort();
+ }
+ abort() {
+ if (this.finished) throw new DOMException("the transaction has finished", "InvalidStateError");
+ this.finished = true;
+ setTimeout(() => this.onabort?.(), 0);
+ }
+}
+
+class Database {
+ constructor() {
+ this.stores = new Map();
+ this.keyPaths = new Map();
+ }
+ createObjectStore(name, { keyPath }) {
+ this.stores.set(name, new Map());
+ this.keyPaths.set(name, keyPath);
+ }
+ transaction(name) {
+ if (!this.stores.has(name)) throw new DOMException(`no store ${name}`, "NotFoundError");
+ return new Transaction(this, name);
+ }
+}
+
+globalThis.indexedDB = {
+ open(name) {
+ const r = new Request(null);
+ setTimeout(() => {
+ let db = databases.get(name);
+ if (!db) {
+ db = new Database();
+ databases.set(name, db);
+ r.result = db;
+ r.onupgradeneeded?.();
+ }
+ r.result = db;
+ r.onsuccess?.({ target: r });
+ }, 0);
+ return r;
+ },
+};
+
+const host = await import(pathToFileURL(join(here, "../js/host.js")));
+assert.equal(await host.storeOpen("indexeddb"), "indexeddb");
+const stored = (key) => databases.get("effectcraft").stores.get("entries").get(key);
+const bytes = (s) => new TextEncoder().encode(s);
+const text = (row) => row && new TextDecoder().decode(new Uint8Array(row.data));
+
+// A healthy write resolves once committed, and the store has it then.
+await host.storePut("project.json", bytes("v1"), 1);
+assert.equal(text(stored("project.json")), "v1", "a resolved put is committed");
+
+// The put's request succeeds, then the transaction aborts: the put fails, the old value stays.
+fault = "abortAfterSuccess";
+await assert.rejects(host.storePut("project.json", bytes("v2"), 2), { name: "AbortError" }, "an aborted put is reported");
+assert.equal(text(stored("project.json")), "v1", "the aborted put was rolled back");
+
+// The same for a delete: it fails and the entry stays.
+fault = "abortAfterSuccess";
+await assert.rejects(host.storeDelete("project.json"), { name: "AbortError" }, "an aborted delete is reported");
+assert.equal(text(stored("project.json")), "v1", "the aborted delete was rolled back");
+
+// A failed request aborts its transaction with the request's error.
+fault = "requestError";
+await assert.rejects(host.storePut("project.json", bytes("v3"), 3), { name: "ConstraintError" });
+assert.equal(text(stored("project.json")), "v1");
+
+// A request that throws at once (a value that can't be stored) fails the write.
+fault = "throw";
+await assert.rejects(host.storePut("project.json", bytes("v4"), 4), { name: "DataCloneError" });
+assert.equal(text(stored("project.json")), "v1");
+
+// The retry after a failure commits the latest value, and a later delete removes it.
+await host.storePut("project.json", bytes("v5"), 5);
+assert.equal(text(stored("project.json")), "v5");
+await host.storeDelete("project.json");
+assert.equal(stored("project.json"), undefined, "a resolved delete is committed");
+const all = await host.storeLoadAll();
+assert.deepEqual(all, [], "nothing else was written");
+
+await tick();
+console.log("storage: ok");