Lightpanda: the headless browser designed for AI and automation
idb: rework transaction model
Karl Seguin1dcd0dc6fbb9
diff --git a/src/browser/tests/indexeddb.html b/src/browser/tests/indexeddb.htmlindex 18703f4ec..7b4a33c66 100644--- a/src/browser/tests/indexeddb.html+++ b/src/browser/tests/indexeddb.html@@ -935,4 +935,66 @@await state.done((count) => testing.expectEqual(0, count));}</script>++<!-- Serialization: awaiting a request's success and then starting the next+ transaction (the "wrapper await" pattern many IDB libraries use) resumes the+ await *during* txN's drain, before it commits. Because operations run inside+ each transaction's own drain, txN+1 waits its turn on the single connection+ instead of colliding with txN's still-open transaction. -->+<script id="sequential_await_transactions" type=module>+{+ const state = await testing.async();+ const open = indexedDB.open("seq-db", 1);+ open.onupgradeneeded = (e) => e.target.result.createObjectStore("s");+ open.onsuccess = async (e) => {+ const db = e.target.result;+ try {+ for (let i = 0; i < 5; i++) {+ const tx = db.transaction("s", "readwrite");+ const req = tx.objectStore("s").put("v" + i, "k" + i);+ // Resumes mid-drain, before tx commits — the old eager `begin`+ // would make the next iteration's begin fail here.+ await new Promise((resolve, reject) => {+ req.onsuccess = resolve;+ req.onerror = () => reject(req.error);+ });+ }+ const all = db.transaction("s", "readonly").objectStore("s").getAll();+ all.onsuccess = () => state.resolve(all.result);+ all.onerror = () => state.resolve({ err: all.error.name });+ } catch (err) {+ state.resolve({ err: err && err.name });+ }+ };+ await state.done((values) => {+ testing.expectEqual(5, values.length);+ testing.expectEqual("v0", values[0]);+ testing.expectEqual("v4", values[4]);+ });+}+</script>++<!-- Two readwrite transactions opened before either drains. They serialize on the+ shared connection (one drain fully commits before the next begins) rather than+ the second's begin colliding with the first. -->+<script id="overlapping_transactions" type=module>+{+ const state = await testing.async();+ const open = indexedDB.open("overlap-db", 1);+ open.onupgradeneeded = (e) => e.target.result.createObjectStore("s");+ open.onsuccess = (e) => {+ const db = e.target.result;+ const txa = db.transaction("s", "readwrite");+ txa.objectStore("s").put("a", "ka");+ const txb = db.transaction("s", "readwrite");+ txb.objectStore("s").put("b", "kb");+ txb.oncomplete = () => {+ const c = db.transaction("s", "readonly").objectStore("s").count();+ c.onsuccess = () => state.resolve(c.result);+ };+ txb.onerror = () => state.resolve({ err: txb.error.name });+ };+ await state.done((count) => testing.expectEqual(2, count));+}+</script></body>diff --git a/src/browser/webapi/storage/idb/IDBCursor.zig b/src/browser/webapi/storage/idb/IDBCursor.zigindex 15718c186..260414fee 100644--- a/src/browser/webapi/storage/idb/IDBCursor.zig+++ b/src/browser/webapi/storage/idb/IDBCursor.zig@@ -84,7 +84,7 @@ const Source = union(enum) {};// How the next iterate() positions the cursor.-const Seek = union(enum) {+pub const Seek = union(enum) {first, // start of the range, in the iteration directionnext, // strictly past the current positionto: []const u8, // continue(key): first record at/after an index/store key@@ -109,7 +109,7 @@ pub fn openIndex(index: *IDBIndex, bounds: Engine.Bounds, direction: Direction,}fn create(store: *IDBObjectStore, txn: *IDBTransaction, index_id: ?i64, source: Source, bounds: Engine.Bounds, direction: Direction, key_only: bool, exec: *Execution) !*IDBRequest {- try txn.ensureBegun();+ try txn.assertActive();const request = try txn.newRequest();const self = try exec._factory.create(IDBCursor{@@ -136,8 +136,24 @@ fn create(store: *IDBObjectStore, txn: *IDBTransaction, index_id: ?i64, source:// avoiding the bridge's pointer -> js.Value lookup each time.self._js = try public.persist();- try self.iterate(.first, 0, exec);- return request;+ // The first seek runs in the drain (or immediately, for a versionchange txn),+ // not here — so the connection is only touched while the txn owns it.+ return request.submit(.{ .cursor_iterate = .{ .cursor = self, .seek = .first, .offset = 0 } }, exec);+}++// Re-arm the cursor's existing request with its next seek and requeue it. Called by+// continue/advance from within a success handler; the drain loop picks the requeued+// request up in the same pass (a versionchange cursor runs it now).+fn reiterate(self: *IDBCursor, seek: Seek, offset: u32, exec: *Execution) !void {+ _ = try self._request.submit(.{ .cursor_iterate = .{ .cursor = self, .seek = seek, .offset = offset } }, exec);+}++// Run the deferred seek, staging the positioned cursor (or null) on the request.+pub fn runIterate(self: *IDBCursor, seek: Seek, offset: u32, exec: *Execution) !void {+ self.iterate(seek, offset, exec) catch |err| {+ log.warn(.storage, "idb cursor iterate", .{ .err = err });+ self._request.setError(err);+ };}// Called by IDBRequest.deliver right before a cursor's success handler runs.@@ -155,11 +171,10 @@ pub fn @"continue"(self: *IDBCursor, key_arg: ?js.Value, exec: *Execution) !voidif (if (self._direction.reverse()) order != .lt else order != .gt) {return error.DataError;}- try self.iterate(.{ .to = encoded }, 0, exec);+ try self.reiterate(.{ .to = encoded }, 0, exec);} else {- try self.iterate(.next, 0, exec);+ try self.reiterate(.next, 0, exec);}- try self._txn.enqueue(self._request);}pub fn continuePrimaryKey(self: *IDBCursor, key_arg: js.Value, primary_key_arg: js.Value, exec: *Execution) !void {@@ -184,8 +199,7 @@ pub fn continuePrimaryKey(self: *IDBCursor, key_arg: js.Value, primary_key_arg:};if (!ok) return error.DataError;- try self.iterate(.{ .to_primary = .{ .key = key, .primary_key = primary_key } }, 0, exec);- try self._txn.enqueue(self._request);+ try self.reiterate(.{ .to_primary = .{ .key = key, .primary_key = primary_key } }, 0, exec);}pub fn advance(self: *IDBCursor, count: u32, exec: *Execution) !void {@@ -195,8 +209,7 @@ pub fn advance(self: *IDBCursor, count: u32, exec: *Execution) !void {try self.prepareIterate();// `count` records forward = skip count-1 past the immediate next.- try self.iterate(.next, count - 1, exec);- try self._txn.enqueue(self._request);+ try self.reiterate(.next, count - 1, exec);}pub fn update(self: *IDBCursor, value: js.Value, exec: *Execution) !*IDBRequest {@@ -224,20 +237,32 @@ pub fn update(self: *IDBCursor, value: js.Value, exec: *Execution) !*IDBRequest}}- const serialized = try value.serialize();+ // Snapshot the record key: the write runs in the drain, by which point a+ // `continue` could have moved the cursor's live position on.+ const request = try self._txn.newRequest();+ const value_global = try value.persist();+ return request.submit(.{ .cursor_update = .{ .cursor = self, .key = key, .value = value_global } }, exec);+}++pub fn runUpdate(self: *IDBCursor, request: *IDBRequest, key: []const u8, value_global: js.Value.Global, exec: *Execution) !void {+ const local = exec.js.local.?;+ const value = value_global.local(local);++ const serialized = value.serialize() catch |err| {+ request.setError(err);+ return;+ };defer serialized.deinit();- const request = try self._txn.newRequest();self._store.writeAt(key, value, serialized.bytes(), exec) catch |err| {log.warn(.storage, "idb cursor update", .{ .err = err });request.setError(err);- return request;+ return;};- try request.setValue(try Key.decodeToJs(exec.call_arena, exec.js.local.?, key));- return request;+ try request.setValue(try Key.decodeToJs(exec.call_arena, local, key));}-pub fn delete(self: *IDBCursor) !*IDBRequest {+pub fn delete(self: *IDBCursor, exec: *Execution) !*IDBRequest {if (self._txn._mode == .readonly) {return error.ReadOnlyError;}@@ -250,14 +275,17 @@ pub fn delete(self: *IDBCursor) !*IDBRequest {return error.InvalidStateError;}+ // Snapshot the record key (see update): the delete runs later, in the drain.const key = self._primary_key orelse return error.InvalidStateError;-const request = try self._txn.newRequest();+ return request.submit(.{ .cursor_delete = .{ .cursor = self, .key = key } }, exec);+}++pub fn runDelete(self: *IDBCursor, request: *IDBRequest, key: []const u8) !void {self._store.deleteAt(key) catch |err| {log.warn(.storage, "idb cursor delete", .{ .err = err });request.setError(err);};- return request;}pub fn getKey(self: *const IDBCursor, exec: *Execution) !?js.Value {diff --git a/src/browser/webapi/storage/idb/IDBIndex.zig b/src/browser/webapi/storage/idb/IDBIndex.zigindex f7fb0db90..b9023393f 100644--- a/src/browser/webapi/storage/idb/IDBIndex.zig+++ b/src/browser/webapi/storage/idb/IDBIndex.zig@@ -56,41 +56,44 @@ pub fn init(obj_store: *IDBObjectStore, info: Engine.IndexInfo, name: []const u8fn txn(self: *IDBIndex) !*IDBTransaction {const t = self._store._txn orelse return error.TransactionInactiveError;- try t.ensureBegun();+ try t.assertActive();return t;}pub fn get(self: *IDBIndex, query: js.Value, exec: *Execution) !*IDBRequest {const t = try self.txn();- const arena = exec.call_arena;- const bounds = try IDBKeyRange.resolveQuery(arena, query, exec);+ const bounds = try IDBKeyRange.resolveQuery(exec.arena, query, exec);const request = try t.newRequest();+ return request.submit(.{ .index_get = .{ .index = self, .bounds = bounds } }, exec);+}+pub fn runGet(self: *IDBIndex, request: *IDBRequest, bounds: Engine.Bounds, exec: *Execution) !void {+ const arena = exec.call_arena;const bytes = self._engine.indexGetRange(arena, self._store._store_id, self._index_id, bounds) catch |err| {log.warn(.storage, "idb index get", .{ .err = err });request.setError(err);- return request;+ return;};-- const b = bytes orelse return request;+ const b = bytes orelse return;try request.setValue(try js.Value.deserialize(exec.js.local.?, b));- return request;}pub fn getKey(self: *IDBIndex, query: js.Value, exec: *Execution) !*IDBRequest {const t = try self.txn();- const arena = exec.call_arena;- const bounds = try IDBKeyRange.resolveQuery(arena, query, exec);+ const bounds = try IDBKeyRange.resolveQuery(exec.arena, query, exec);const request = try t.newRequest();+ return request.submit(.{ .index_get_key = .{ .index = self, .bounds = bounds } }, exec);+}+pub fn runGetKey(self: *IDBIndex, request: *IDBRequest, bounds: Engine.Bounds, exec: *Execution) !void {+ const arena = exec.call_arena;const bytes = self._engine.indexGetKeyRange(arena, self._index_id, bounds) catch |err| {log.warn(.storage, "idb index getKey", .{ .err = err });request.setError(err);- return request;+ return;};- const b = bytes orelse return request;+ const b = bytes orelse return;try request.setValue(try Key.decodeToJs(arena, exec.js.local.?, b));- return request;}pub fn getAll(self: *IDBIndex, query: ?js.Value, count_: ?u32, exec: *Execution) !*IDBRequest {@@ -103,16 +106,18 @@ pub fn getAllKeys(self: *IDBIndex, query: ?js.Value, count_: ?u32, exec: *Executfn _getAll(self: *IDBIndex, query: ?js.Value, count_: ?u32, column: Engine.Column, exec: *Execution) !*IDBRequest {const t = try self.txn();- const bounds = try IDBKeyRange.resolveQuery(exec.call_arena, query, exec);+ const bounds = try IDBKeyRange.resolveQuery(exec.arena, query, exec);const request = try t.newRequest();+ return request.submit(.{ .index_get_all = .{ .index = self, .bounds = bounds, .column = column, .count = count_ } }, exec);+}+pub fn runGetAll(self: *IDBIndex, request: *IDBRequest, bounds: Engine.Bounds, column: Engine.Column, count_: ?u32, exec: *Execution) !void {const arr = self.collectAll(bounds, count_, column, exec) catch |err| {log.warn(.storage, "idb index getAll", .{ .err = err });request.setError(err);- return request;+ return;};try request.setValue(arr);- return request;}// Stream an index getAll/getAllKeys straight into a JS array: .value rows are@@ -137,16 +142,18 @@ fn collectAll(self: *IDBIndex, bounds: Engine.Bounds, count_: ?u32, column: Engipub fn count(self: *IDBIndex, query: ?js.Value, exec: *Execution) !*IDBRequest {const t = try self.txn();- const bounds = try IDBKeyRange.resolveQuery(exec.call_arena, query, exec);+ const bounds = try IDBKeyRange.resolveQuery(exec.arena, query, exec);const request = try t.newRequest();+ return request.submit(.{ .index_count = .{ .index = self, .bounds = bounds } }, exec);+}+pub fn runCount(self: *IDBIndex, request: *IDBRequest, bounds: Engine.Bounds, exec: *Execution) !void {const n = self._engine.indexCountRange(self._index_id, bounds) catch |err| {log.warn(.storage, "idb index count", .{ .err = err });request.setError(err);- return request;+ return;};try request.setValue(try exec.js.local.?.zigValueToJs(n, .{}));- return request;}pub fn openCursor(self: *IDBIndex, query: ?js.Value, direction: ?IDBCursor.Direction, exec: *Execution) !*IDBRequest {diff --git a/src/browser/webapi/storage/idb/IDBObjectStore.zig b/src/browser/webapi/storage/idb/IDBObjectStore.zigindex 34de381af..58d688d15 100644--- a/src/browser/webapi/storage/idb/IDBObjectStore.zig+++ b/src/browser/webapi/storage/idb/IDBObjectStore.zig@@ -73,25 +73,25 @@ pub fn put(self: *IDBObjectStore, value: js.Value, key: ?js.Value, exec: *Executpub fn get(self: *IDBObjectStore, query: js.Value, exec: *Execution) !*IDBRequest {const txn = self._txn orelse return error.TransactionInactiveError;- try txn.ensureBegun();-- // Both the encoded key and the fetched bytes are consumed within this call- // (the bytes are deserialized below), so the per-call scratch arena suffices.- const arena = exec.call_arena;- const bounds = try IDBKeyRange.resolveQuery(arena, query, exec);+ try txn.assertActive();+ // Bounds are captured for deferred execution, so they must outlive this call —+ // the page arena, not the per-call scratch arena.+ const bounds = try IDBKeyRange.resolveQuery(exec.arena, query, exec);const request = try txn.newRequest();+ return request.submit(.{ .store_get = .{ .store = self, .bounds = bounds } }, exec);+}+pub fn runGet(self: *IDBObjectStore, request: *IDBRequest, bounds: Engine.Bounds, exec: *Execution) !void {+ // The fetched bytes are deserialized here and then discarded, so the per-call+ // scratch arena suffices for them.+ const arena = exec.call_arena;const bytes = self._engine.getRange(arena, self._store_id, bounds) catch |err| {log.warn(.storage, "idb get", .{ .err = err });request.setError(err);- return request;+ return;};-- const b = bytes orelse return request;-- const value = try js.Value.deserialize(exec.js.local.?, b);- try request.setValue(value);- return request;+ const b = bytes orelse return; // no record -> undefined+ try request.setValue(try js.Value.deserialize(exec.js.local.?, b));}pub fn delete(self: *IDBObjectStore, query: js.Value, exec: *Execution) !*IDBRequest {@@ -99,16 +99,17 @@ pub fn delete(self: *IDBObjectStore, query: js.Value, exec: *Execution) !*IDBReqif (txn._mode == .readonly) {return error.ReadOnlyError;}- try txn.ensureBegun();-- const bounds = try IDBKeyRange.resolveQuery(exec.call_arena, query, exec);+ try txn.assertActive();+ const bounds = try IDBKeyRange.resolveQuery(exec.arena, query, exec);const request = try txn.newRequest();+ return request.submit(.{ .store_delete = .{ .store = self, .bounds = bounds } }, exec);+}+pub fn runDelete(self: *IDBObjectStore, request: *IDBRequest, bounds: Engine.Bounds, _: *Execution) !void {self.deleteBounds(bounds) catch |err| {log.warn(.storage, "idb delete", .{ .err = err });request.setError(err);};- return request;}fn deleteBounds(self: *IDBObjectStore, bounds: Engine.Bounds) !void {@@ -116,19 +117,21 @@ fn deleteBounds(self: *IDBObjectStore, bounds: Engine.Bounds) !void {try self._engine.deleteRange(self._store_id, bounds);}-pub fn clear(self: *IDBObjectStore, _: *Execution) !*IDBRequest {+pub fn clear(self: *IDBObjectStore, exec: *Execution) !*IDBRequest {const txn = self._txn orelse return error.TransactionInactiveError;if (txn._mode == .readonly) {return error.ReadOnlyError;}- try txn.ensureBegun();-+ try txn.assertActive();const request = try txn.newRequest();+ return request.submit(.{ .store_clear = self }, exec);+}++pub fn runClear(self: *IDBObjectStore, request: *IDBRequest, _: *Execution) !void {self.clearAll() catch |err| {log.warn(.storage, "idb clear", .{ .err = err });request.setError(err);};- return request;}fn clearAll(self: *IDBObjectStore) !void {@@ -138,17 +141,19 @@ fn clearAll(self: *IDBObjectStore) !void {pub fn count(self: *IDBObjectStore, query: ?js.Value, exec: *Execution) !*IDBRequest {const txn = self._txn orelse return error.TransactionInactiveError;- try txn.ensureBegun();-- const bounds = try IDBKeyRange.resolveQuery(exec.call_arena, query, exec);+ try txn.assertActive();+ const bounds = try IDBKeyRange.resolveQuery(exec.arena, query, exec);const request = try txn.newRequest();+ return request.submit(.{ .store_count = .{ .store = self, .bounds = bounds } }, exec);+}++pub fn runCount(self: *IDBObjectStore, request: *IDBRequest, bounds: Engine.Bounds, exec: *Execution) !void {const n = self._engine.countRange(self._store_id, bounds) catch |err| {log.warn(.storage, "idb count", .{ .err = err });request.setError(err);- return request;+ return;};try request.setValue(try exec.js.local.?.zigValueToJs(n, .{}));- return request;}pub fn getAll(self: *IDBObjectStore, query: ?js.Value, count_: ?u32, exec: *Execution) !*IDBRequest {@@ -157,18 +162,19 @@ pub fn getAll(self: *IDBObjectStore, query: ?js.Value, count_: ?u32, exec: *Execfn _getAll(self: *IDBObjectStore, query: ?js.Value, count_: ?u32, column: Engine.Column, exec: *Execution) !*IDBRequest {const txn = self._txn orelse return error.TransactionInactiveError;- try txn.ensureBegun();-- const bounds = try IDBKeyRange.resolveQuery(exec.call_arena, query, exec);+ try txn.assertActive();+ const bounds = try IDBKeyRange.resolveQuery(exec.arena, query, exec);const request = try txn.newRequest();+ return request.submit(.{ .store_get_all = .{ .store = self, .bounds = bounds, .column = column, .count = count_ } }, exec);+}+pub fn runGetAll(self: *IDBObjectStore, request: *IDBRequest, bounds: Engine.Bounds, column: Engine.Column, count_: ?u32, exec: *Execution) !void {const arr = self.collectAll(exec, bounds, column, count_) catch |err| {log.warn(.storage, "idb getAll", .{ .err = err });request.setError(err);- return request;+ return;};try request.setValue(arr);- return request;}// Stream a getAll/getAllKeys result straight into a JS array: .value rows@@ -193,21 +199,21 @@ fn collectAll(self: *IDBObjectStore, exec: *Execution, bounds: Engine.Bounds, copub fn getKey(self: *IDBObjectStore, query: js.Value, exec: *Execution) !*IDBRequest {const txn = self._txn orelse return error.TransactionInactiveError;- try txn.ensureBegun();-- const arena = exec.call_arena;- const bounds = try IDBKeyRange.resolveQuery(arena, query, exec);+ try txn.assertActive();+ const bounds = try IDBKeyRange.resolveQuery(exec.arena, query, exec);const request = try txn.newRequest();+ return request.submit(.{ .store_get_key = .{ .store = self, .bounds = bounds } }, exec);+}+pub fn runGetKey(self: *IDBObjectStore, request: *IDBRequest, bounds: Engine.Bounds, exec: *Execution) !void {+ const arena = exec.call_arena;const found = self._engine.getKeyRange(arena, self._store_id, bounds) catch |err| {log.warn(.storage, "idb getKey", .{ .err = err });request.setError(err);- return request;+ return;};-- const bytes = found orelse return request; // no record -> undefined+ const bytes = found orelse return; // no record -> undefinedtry request.setValue(try Key.decodeToJs(arena, exec.js.local.?, bytes));- return request;}pub fn getAllKeys(self: *IDBObjectStore, query: ?js.Value, count_: ?u32, exec: *Execution) !*IDBRequest {@@ -240,86 +246,122 @@ pub fn getTransaction(self: *IDBObjectStore) ?*IDBTransaction {return self._txn;}-const WriteKind = enum { add, put };+pub const WriteKind = enum { add, put };++// The key that we're writing to. We need to validate this on the request side+// so we might as well store the result for the execution side.+pub const PreparedKey = union(enum) {+ // generate number key + injsect into value+ generate_in_line,++ // generate number key, don't inject+ generate_out_of_line,++ // an explicit key, could be passed in or extracted from the value+ explicit: struct { encoded: []const u8, bump: ?f64 },+};fn write(self: *IDBObjectStore, value: js.Value, key_arg: ?js.Value, kind: WriteKind, exec: *Execution) !*IDBRequest {const txn = self._txn orelse return error.TransactionInactiveError;if (txn._mode == .readonly) {return error.ReadOnlyError;}- try txn.ensureBegun();-- const local = exec.js.local.?;+ try txn.assertActive();- var generated = false;- const key_value: js.Value = blk: {+ // Resolve (and validate) the key now, so DataError / a throwing key getter+ // throws synchronously. Encoded key bytes are captured on the page arena to+ // outlive this call. The record write itself is deferred to runWrite.+ const prepared: PreparedKey = blk: {if (self._key_path) |kp| {if (key_arg != null) {// can't have an explicit key if we're configured for in-line keysreturn error.DataError;}-if (Key.evaluatePath(value, kp)) |extracted| {- break :blk extracted;+ break :blk .{ .explicit = .{+ .encoded = try Key.encodeValue(exec.arena, extracted),+ .bump = if (self._auto_increment and extracted.isNumber()) try extracted.toF64() else null,+ } };}-// The keypath wasn't in the value...if (self._auto_increment == false) {- // and auto-increment is disabled, no key, error.return error.DataError;}-if (Key.canInjectKey(value, kp) == false) {return error.DataError;}-- generated = true;- const n = try self._engine.nextGeneratedKey(self._store_id);- const k = try local.newNumber(@floatFromInt(n));- try Key.injectKey(local, value, kp, k);- break :blk k;+ break :blk .generate_in_line;}// Out-of-line keys.if (key_arg) |k| {- break :blk k;+ break :blk .{ .explicit = .{+ .encoded = try Key.encodeValue(exec.arena, k),+ .bump = if (self._auto_increment and k.isNumber()) try k.toF64() else null,+ } };}-if (self._auto_increment == false) {return error.DataError;}-- generated = true;- const n = try self._engine.nextGeneratedKey(self._store_id);- break :blk try local.newNumber(@floatFromInt(n));+ break :blk .generate_out_of_line;};- const encoded = try Key.encodeValue(exec.call_arena, key_value);+ const request = try txn.newRequest();+ const value_global = try value.persist();+ return request.submit(.{ .store_write = .{+ .store = self,+ .kind = kind,+ .value = value_global,+ .key = prepared,+ } }, exec);+}- if (self._auto_increment and !generated and key_value.isNumber()) {- // auto-increment is enabled, but this was NOT a generated key, so we- // need to bump the generator so that future generated keys don't collide- try self._engine.maybeBumpGenerator(self._store_id, try key_value.toF64());- }+pub fn runWrite(self: *IDBObjectStore, request: *IDBRequest, kind: WriteKind, value_global: js.Value.Global, prepared: PreparedKey, exec: *Execution) !void {+ self.writeInner(request, kind, value_global, prepared, exec) catch |err| {+ log.warn(.storage, "idb write", .{ .err = err, .kind = kind });+ request.setError(err);+ };+}++fn writeInner(self: *IDBObjectStore, request: *IDBRequest, kind: WriteKind, value_global: js.Value.Global, prepared: PreparedKey, exec: *Execution) !void {+ const local = exec.js.local.?;+ const value = value_global.local(local);++ // Resolve the encoded key + the JS value that becomes the request result. For+ // generated keys, that's where the connection is finally touched.+ const encoded: []const u8 = switch (prepared) {+ .explicit => |e| blk: {+ if (e.bump) |b| {+ try self._engine.maybeBumpGenerator(self._store_id, b);+ }+ break :blk e.encoded;+ },+ .generate_out_of_line => blk: {+ const n = try self._engine.nextGeneratedKey(self._store_id);+ break :blk try Key.encodeValue(exec.call_arena, try local.newNumber(@floatFromInt(n)));+ },+ .generate_in_line => blk: {+ const n = try self._engine.nextGeneratedKey(self._store_id);+ const k = try local.newNumber(@floatFromInt(n));+ try Key.injectKey(local, value, self._key_path.?, k);+ break :blk try Key.encodeValue(exec.call_arena, k);+ },+ };const serialized = try value.serialize();defer serialized.deinit();- const request = try txn.newRequest();-// Record + index rows are atomic: a unique-index violation rolls the record// write back too.try self._engine.savepoint();self.writeRecord(kind, encoded, serialized.bytes(), value, exec) catch |err| {self._engine.rollbackSavepoint();- log.warn(.storage, "idb write", .{ .err = err, .kind = kind });- request.setError(err);- return request;+ return err;};try self._engine.releaseSavepoint();- try request.setValue(key_value);- return request;+ // The request result is the record's key (decoded back from the encoded bytes).+ try request.setValue(try Key.decodeToJs(exec.call_arena, local, encoded));}fn writeRecord(self: *IDBObjectStore, kind: WriteKind, key: []const u8, bytes: []const u8, value: js.Value, exec: *Execution) !void {diff --git a/src/browser/webapi/storage/idb/IDBRequest.zig b/src/browser/webapi/storage/idb/IDBRequest.zigindex 01eae5b91..b7e1b9267 100644--- a/src/browser/webapi/storage/idb/IDBRequest.zig+++ b/src/browser/webapi/storage/idb/IDBRequest.zig@@ -26,8 +26,11 @@ const EventTarget = @import("../../EventTarget.zig");const DOMException = @import("../../DOMException.zig");const idb = @import("idb.zig");+const Engine = @import("Engine.zig");+const IDBIndex = @import("IDBIndex.zig");const IDBCursor = @import("IDBCursor.zig");const IDBDatabase = @import("IDBDatabase.zig");+const IDBObjectStore = @import("IDBObjectStore.zig");const IDBTransaction = @import("IDBTransaction.zig");const IDBVersionChangeEvent = @import("IDBVersionChangeEvent.zig");@@ -37,11 +40,12 @@ const FunctionSetter = idb.FunctionSetter;const IDBRequest = @This();_proto: *EventTarget,-_result: Result = .{ .none = js.Undefined{} },+_op: Operation = .none,_error: ?anyerror = null,_txn: ?*IDBTransaction = null,_cursor: ?*IDBCursor = null,_ready_state: ReadyState = .pending,+_result: Result = .{ .none = js.Undefined{} },_on_success: ?js.Function.Global = null,_on_error: ?js.Function.Global = null,@@ -184,6 +188,82 @@ fn getFunctionFromSetter(setter: ?FunctionSetter) ?js.Function.Global {};}+// A database operation, captured when a request method is called and run later.+pub const Operation = union(enum) {+ none,+ store_get: StoreQuery,+ store_get_key: StoreQuery,+ store_get_all: StoreGetAll,+ store_count: StoreQuery,+ store_delete: StoreQuery,+ store_clear: *IDBObjectStore,+ store_write: StoreWrite,+ index_get: IndexQuery,+ index_get_key: IndexQuery,+ index_get_all: IndexGetAll,+ index_count: IndexQuery,+ cursor_iterate: CursorIterate,+ cursor_update: CursorUpdate,+ cursor_delete: CursorDelete,++ const StoreQuery = struct { store: *IDBObjectStore, bounds: Engine.Bounds };+ const StoreGetAll = struct { store: *IDBObjectStore, bounds: Engine.Bounds, column: Engine.Column, count: ?u32 };+ const StoreWrite = struct { store: *IDBObjectStore, kind: IDBObjectStore.WriteKind, value: js.Value.Global, key: IDBObjectStore.PreparedKey };+ const IndexQuery = struct { index: *IDBIndex, bounds: Engine.Bounds };+ const IndexGetAll = struct { index: *IDBIndex, bounds: Engine.Bounds, column: Engine.Column, count: ?u32 };+ const CursorIterate = struct { cursor: *IDBCursor, seek: IDBCursor.Seek, offset: u32 };+ const CursorUpdate = struct { cursor: *IDBCursor, key: []const u8, value: js.Value.Global };+ const CursorDelete = struct { cursor: *IDBCursor, key: []const u8 };+};++// Commit this request's operation: record it and queue the request on its+// transaction's drain.+pub fn submit(self: *IDBRequest, op: Operation, exec: *Execution) !*IDBRequest {+ self._op = op;+ const txn = self._txn.?;+ try txn.enqueue(self);++ if (txn.getMode() == .versionchange) {+ // for "upgradeneeded" we run them immediately (and still queue them, but+ // their .op == .noop at that point). This is necessary to keep this+ // operation consistent / ordered with other "upgradeneeded" changes that+ // happen synchronously (e.g. createIndex). And we queue it so that,+ // while the re-execute will be noop, the events will still fire.+ try self.execute(exec);+ }+ return self;+}+++pub fn execute(self: *IDBRequest, exec: *Execution) !void {+ const op = self._op;+ if (op == .none) {+ return;+ }++ self._op = .none;+ if (self._txn) |txn| {+ try txn.ensureBegun();+ }+ switch (op) {+ .none => unreachable,+ .store_get => |o| try o.store.runGet(self, o.bounds, exec),+ .store_get_key => |o| try o.store.runGetKey(self, o.bounds, exec),+ .store_get_all => |o| try o.store.runGetAll(self, o.bounds, o.column, o.count, exec),+ .store_count => |o| try o.store.runCount(self, o.bounds, exec),+ .store_delete => |o| try o.store.runDelete(self, o.bounds, exec),+ .store_clear => |store| try store.runClear(self, exec),+ .store_write => |o| try o.store.runWrite(self, o.kind, o.value, o.key, exec),+ .index_get => |o| try o.index.runGet(self, o.bounds, exec),+ .index_get_key => |o| try o.index.runGetKey(self, o.bounds, exec),+ .index_get_all => |o| try o.index.runGetAll(self, o.bounds, o.column, o.count, exec),+ .index_count => |o| try o.index.runCount(self, o.bounds, exec),+ .cursor_iterate => |o| try o.cursor.runIterate(o.seek, o.offset, exec),+ .cursor_update => |o| try o.cursor.runUpdate(self, o.key, o.value, exec),+ .cursor_delete => |o| try o.cursor.runDelete(self, o.key),+ }+}+pub const JsApi = struct {pub const bridge = js.Bridge(IDBRequest);diff --git a/src/browser/webapi/storage/idb/IDBTransaction.zig b/src/browser/webapi/storage/idb/IDBTransaction.zigindex 723dc6090..de743c03c 100644--- a/src/browser/webapi/storage/idb/IDBTransaction.zig+++ b/src/browser/webapi/storage/idb/IDBTransaction.zig@@ -138,6 +138,10 @@ pub fn abort(self: *IDBTransaction, exec: *Execution) !void {}for (self._requests.items) |request| {+ request._op = .none;+ if (request._ready_state == .done) {+ continue;+ }request.setError(error.AbortError);request.deliver(exec) catch |err| {log.warn(.storage, "idb abort deliver", .{ .err = err });@@ -162,6 +166,13 @@ pub fn settle(self: *IDBTransaction, exec: *Execution) void {self.fire(exec, comptime .wrap("complete"), self._on_complete);}+// "is this transaction still usable". Once settled, it cannot be used.+pub fn assertActive(self: *const IDBTransaction) !void {+ if (self._settled) {+ return error.TransactionInactiveError;+ }+}+pub fn ensureBegun(self: *IDBTransaction) !void {if (self._settled) {return error.TransactionInactiveError;@@ -177,7 +188,6 @@ pub fn ensureBegun(self: *IDBTransaction) !void {pub fn newRequest(self: *IDBTransaction) !*IDBRequest {const request = try IDBRequest.init(self._exec);request._txn = self;- try self.enqueue(request);return request;}@@ -283,12 +293,28 @@ fn finalize(ctx: *anyopaque) void {}}-// Deliver every queued request in order. Re-reads len each iteration so a-// `success` handler can enqueue a follow-up request on this transaction.fn deliverPending(self: *IDBTransaction, exec: *Execution) void {+ // exec.js.local must be non-null. In some cases it is (e.g. tx.commit()+ // called directly from JS), in others is isn't (drain schedule tasks).+ // Easier to explicitly create one and then restore whatever was there before.++ const prev_local = exec.js.local;+ defer exec.js.local = prev_local;++ var ls: js.Local.Scope = undefined;+ exec.js.localScope(&ls);+ defer ls.deinit();++ exec.js.local = &ls.local;+var i: usize = 0;while (i < self._requests.items.len) : (i += 1) {- self._requests.items[i].deliver(exec) catch |err| {+ const request = self._requests.items[i];+ request.execute(exec) catch |err| {+ log.warn(.storage, "idb request execute", .{ .err = err });+ request.setError(err);+ };+ request.deliver(exec) catch |err| {log.warn(.storage, "idb request deliver", .{ .err = err });};}