fix(indexeddb): store native DOMException payloads

This commit is contained in:
ldm0
2026-10-29 08:45:07 +08:00
committed by Donough Liu
parent 5a4588fbd0
commit 75ad372bab
5 changed files with 363 additions and 30 deletions
@@ -1,4 +1,9 @@
use super::*;
use crate::structured_clone::{
HOST_OBJECT_TAG_DOM_EXCEPTION, HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR,
read_dom_exception_payload, read_quota_exceeded_error_payload, write_dom_exception_payload,
write_quota_exceeded_error_payload,
};
use crate::{
context_bootstrap::{
FileSystemHandleDurablePayload, build_file_system_handle_from_durable_payload,
@@ -51,6 +56,16 @@ impl v8::ValueSerializerImpl for IndexedDbStructuredCloneSerializer {
serializer: &dyn v8::ValueSerializerHelper,
) -> Option<bool> {
match moli_webapi_declare::web_api_object_type(scope, object).map(|kind| kind.name()) {
Some("DOMException")
if write_dom_exception_payload(scope, object, serializer).is_some() =>
{
return Some(true);
}
Some("QuotaExceededError")
if write_quota_exceeded_error_payload(scope, object, serializer).is_some() =>
{
return Some(true);
}
Some("EncodedVideoChunk") => {
let exception = dom_exception_value(
scope,
@@ -180,6 +195,10 @@ impl v8::ValueDeserializerImpl for IndexedDbStructuredCloneDeserializer {
return None;
}
match tag {
HOST_OBJECT_TAG_DOM_EXCEPTION => read_dom_exception_payload(scope, deserializer),
HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR => {
read_quota_exceeded_error_payload(scope, deserializer)
}
HOST_OBJECT_TAG_IMAGE_DATA => read_image_data_payload(scope, deserializer),
HOST_OBJECT_TAG_CRYPTO_KEY => {
read_crypto_key_payload(scope, deserializer).or_else(|| {
@@ -6595,3 +6595,101 @@ navigator.storageBuckets.open('limited', {quota: 16}).then(bucket => {
r#"["abort:QuotaExceededError:0:0:true","open-error:AbortError:true","deleted"]"#
);
}
#[test]
fn indexed_db_roundtrips_native_exception_data_without_author_access() {
let mut vm = new_storage_page_task_executor_test_vm("https://indexeddb-exception-data.test/");
vm.eval(&format!(
"{}\nglobalThis.exceptionPayloadResult = 'pending'; indexedDBExceptionPayloadProbe(globalThis).then(result => {{ exceptionPayloadResult = JSON.stringify(result); }}, error => {{ exceptionPayloadResult = JSON.stringify({{error: error.name + ':' + error.message}}); }});",
include_str!("../../../tests/fixtures/indexeddb-exception-payloads.js"),
))
.expect("IndexedDB exception data probe should schedule");
let result = vm
.eval_after_selected_page_tasks("String(exceptionPayloadResult)")
.expect("IndexedDB exception data probe should complete");
let result: serde_json::Value = serde_json::from_str(&result).unwrap();
assert_eq!(result["failures"], serde_json::json!([]), "{result}");
assert_eq!(result["rows"].as_array().unwrap().len(), 225, "{result}");
}
#[test]
fn indexed_db_native_exception_data_survives_profile_restart() {
let root = indexed_db_test_root("exception-data-profile-restart");
let page_url = "https://indexeddb-exception-profile.test/";
for phase in ["write", "read"] {
let manager = crate::new_indexed_db_manager(Some(root.clone()))
.expect("durable IndexedDB manager should initialize");
let mut vm = new_storage_page_task_executor_test_vm(page_url);
vm.set_indexed_db_manager(Some(crate::downgrade_indexed_db_manager(&manager)));
vm.eval(&format!("globalThis.exceptionPayloadPhase = {phase:?};"))
.unwrap();
vm.eval(
r#"
globalThis.exceptionPayloadRestart = 'pending';
(async () => {
const request = value => new Promise((resolve, reject) => {
value.onsuccess = () => resolve(value.result);
value.onerror = () => reject(value.error);
});
const done = tx => new Promise((resolve, reject) => {
tx.oncomplete = resolve; tx.onabort = () => reject(tx.error);
});
const open = indexedDB.open('durable-exceptions', 1);
open.onupgradeneeded = () => open.result.createObjectStore('values');
const db = await request(open);
try {
if (exceptionPayloadPhase === 'write') {
const error = new DOMException('stored\u0000\ud83d\ude00', 'AbortError');
const quota = new QuotaExceededError('full', {quota:0, requested:12.5});
const value = {error, alias:error, quota}; value.self = value;
const tx = db.transaction('values','readwrite'), complete = done(tx);
tx.objectStore('values').put(value, 'record'); await complete;
exceptionPayloadRestart = 'stored';
} else {
const tx = db.transaction('values'), complete = done(tx);
const value = await request(tx.objectStore('values').get('record'));
await complete;
exceptionPayloadRestart = JSON.stringify([
value.self === value, value.error === value.alias,
Object.getPrototypeOf(value.error) === DOMException.prototype,
value.error.name, value.error.message, value.error.code,
Object.getPrototypeOf(value.quota) === QuotaExceededError.prototype,
value.quota.name, value.quota.message, value.quota.code,
value.quota.quota, value.quota.requested,
!Object.hasOwn(value.error,'stack'), !Object.hasOwn(value.quota,'stack')
]);
}
} finally { db.close(); }
})().catch(error => { exceptionPayloadRestart = error.name+':'+error.message; });
"#,
)
.expect("durable exception data workflow should schedule");
let result = vm
.eval_after_selected_page_tasks("String(exceptionPayloadRestart)")
.expect("durable exception data workflow should complete");
if phase == "write" {
assert_eq!(result, "stored");
} else {
assert_eq!(
serde_json::from_str::<serde_json::Value>(&result).unwrap(),
serde_json::json!([
true,
true,
true,
"AbortError",
"stored\0😀",
20,
true,
"QuotaExceededError",
"full",
22,
0,
12.5,
true,
true
])
);
}
}
let _ = std::fs::remove_dir_all(root);
}
+58 -30
View File
@@ -43,9 +43,9 @@ pub(crate) const HOST_OBJECT_TAG_IMAGE_DATA: u32 = 2;
pub(crate) const HOST_OBJECT_TAG_CRYPTO_KEY: u32 = 3;
const HOST_OBJECT_TAG_READABLE_STREAM: u32 = 4;
pub(crate) const HOST_OBJECT_TAG_BLOB: u32 = 5;
const HOST_OBJECT_TAG_DOM_EXCEPTION: u32 = 6;
pub(crate) const HOST_OBJECT_TAG_DOM_EXCEPTION: u32 = 6;
pub(crate) const HOST_OBJECT_TAG_FILE_SYSTEM_HANDLE: u32 = 7;
const HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR: u32 = 8;
pub(crate) const HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR: u32 = 8;
const HOST_OBJECT_TAG_WRITABLE_STREAM: u32 = 9;
const HOST_OBJECT_TAG_TRANSFORM_STREAM: u32 = 10;
const HOST_OBJECT_TAG_ENCODED_VIDEO_CHUNK: u32 = 13;
@@ -532,24 +532,15 @@ impl v8::ValueSerializerImpl for WireSerializer {
return Some(true);
}
}
Some("QuotaExceededError") => {
if let Some((message, quota, requested)) =
quota_exceeded_error_clone_fields(scope, object)
{
serializer.write_uint32(HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR);
write_string(serializer, &message);
write_optional_double(serializer, quota);
write_optional_double(serializer, requested);
return Some(true);
}
Some("QuotaExceededError")
if write_quota_exceeded_error_payload(scope, object, serializer).is_some() =>
{
return Some(true);
}
Some("DOMException") => {
if let Some((message, name)) = dom_exception_clone_fields(scope, object) {
serializer.write_uint32(HOST_OBJECT_TAG_DOM_EXCEPTION);
write_string(serializer, &message);
write_string(serializer, &name);
return Some(true);
}
Some("DOMException")
if write_dom_exception_payload(scope, object, serializer).is_some() =>
{
return Some(true);
}
_ => {}
}
@@ -783,18 +774,9 @@ impl v8::ValueDeserializerImpl for WireDeserializer {
None
})
}
HOST_OBJECT_TAG_DOM_EXCEPTION => {
let message = read_string(deserializer)?;
let name = read_string(deserializer)?;
Some(build_dom_exception_object(scope, &message, &name))
}
HOST_OBJECT_TAG_DOM_EXCEPTION => read_dom_exception_payload(scope, deserializer),
HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR => {
let message = read_string(deserializer)?;
let quota = read_optional_double(deserializer)?;
let requested = read_optional_double(deserializer)?;
Some(build_quota_exceeded_error_object(
scope, &message, quota, requested,
))
read_quota_exceeded_error_payload(scope, deserializer)
}
_ => {
throw_data_clone_exception(scope, "Unsupported structured clone host object.");
@@ -989,6 +971,52 @@ pub(crate) fn read_crypto_key_payload<'s>(
)
}
pub(crate) fn write_dom_exception_payload<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
serializer: &dyn v8::ValueSerializerHelper,
) -> Option<()> {
let (message, name) = dom_exception_clone_fields(scope, object)?;
serializer.write_uint32(HOST_OBJECT_TAG_DOM_EXCEPTION);
write_string(serializer, &message);
write_string(serializer, &name);
Some(())
}
pub(crate) fn read_dom_exception_payload<'s>(
scope: &mut v8::PinScope<'s, '_>,
deserializer: &dyn v8::ValueDeserializerHelper,
) -> Option<v8::Local<'s, v8::Object>> {
let message = read_string(deserializer)?;
let name = read_string(deserializer)?;
Some(build_dom_exception_object(scope, &message, &name))
}
pub(crate) fn write_quota_exceeded_error_payload<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
serializer: &dyn v8::ValueSerializerHelper,
) -> Option<()> {
let (message, quota, requested) = quota_exceeded_error_clone_fields(scope, object)?;
serializer.write_uint32(HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR);
write_string(serializer, &message);
write_optional_double(serializer, quota);
write_optional_double(serializer, requested);
Some(())
}
pub(crate) fn read_quota_exceeded_error_payload<'s>(
scope: &mut v8::PinScope<'s, '_>,
deserializer: &dyn v8::ValueDeserializerHelper,
) -> Option<v8::Local<'s, v8::Object>> {
let message = read_string(deserializer)?;
let quota = read_optional_double(deserializer)?;
let requested = read_optional_double(deserializer)?;
Some(build_quota_exceeded_error_object(
scope, &message, quota, requested,
))
}
fn write_string(serializer: &dyn v8::ValueSerializerHelper, value: &str) {
write_raw_vec(serializer, value.as_bytes());
}
@@ -60,3 +60,67 @@ async fn indexed_db_global_attribute_preserves_receivers_and_identity_across_wor
});
}
}
#[tokio::test]
async fn indexed_db_preserves_native_exception_data_across_worker_kinds() {
ensure_v8();
let manager = crate::new_indexed_db_manager(None).unwrap();
let storage_key = moli_storage_key::MoliStorageKey::new(
"https://indexeddb-exception-data.test".to_owned(),
"https://indexeddb-exception-data.test".to_owned(),
None,
moli_storage_key::StoragePartitionRelation::FirstParty,
);
for (kind, script_kind) in [
(
WorkerGlobalKind::Dedicated {
name: String::new(),
},
WorkerScriptKind::Classic,
),
(
WorkerGlobalKind::Dedicated {
name: String::new(),
},
WorkerScriptKind::Module,
),
(
WorkerGlobalKind::Shared {
name: "exceptions".to_owned(),
storage_key,
},
WorkerScriptKind::Classic,
),
(
WorkerGlobalKind::Service {
registration_id: ServiceWorkerRegistrationId::from_u64_for_test(1),
version_id: ServiceWorkerVersionId::from_u64_for_test(1),
scope_url: url::Url::parse("https://indexeddb-exception-data.test/").unwrap(),
},
WorkerScriptKind::Classic,
),
] {
let source = format!(
"{}\nindexedDBExceptionPayloadProbe(globalThis).then(result => console.log(JSON.stringify(result)), error => console.log(JSON.stringify({{error: error.name + ':' + error.message}})));",
include_str!("../../../../tests/fixtures/indexeddb-exception-payloads.js"),
);
let mut handle = spawn_test_worker_with_options(
WorkerSpawnOptions::new(
source,
"https://indexeddb-exception-data.test/worker.js".to_owned(),
)
.with_global_kind(kind)
.with_script_kind(script_kind)
.with_indexed_db_manager(Some(crate::downgrade_indexed_db_manager(&manager))),
);
let message = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();
handle.terminate_and_join();
let WorkerToParentMessage::Console(console) = message else {
panic!("expected the completed exception data probe, got {message:?}");
};
let result: serde_json::Value =
serde_json::from_str(console.message.strip_prefix("log: ").unwrap()).unwrap();
assert_eq!(result["failures"], serde_json::json!([]), "{result}");
assert_eq!(result["rows"].as_array().unwrap().len(), 225, "{result}");
}
}
@@ -0,0 +1,124 @@
async function indexedDBExceptionPayloadProbe(global) {
const rows = [], failures = [];
const check = (name, pass) => {
rows.push({name, pass: !!pass});
if (!pass) failures.push(name);
};
const request = value => new Promise((resolve, reject) => {
value.onsuccess = () => resolve(value.result);
value.onerror = () => reject(value.error);
});
const completion = tx => new Promise((resolve, reject) => {
tx.oncomplete = resolve;
tx.onabort = () => reject(tx.error || new Error('transaction aborted'));
});
const DOM = global.DOMException, Quota = global.QuotaExceededError;
const domDescriptor = Object.getOwnPropertyDescriptor(global, 'DOMException');
const quotaDescriptor = Object.getOwnPropertyDescriptor(global, 'QuotaExceededError');
const message = 'stored\u0000\ud83d\ude00';
class Derived extends DOM {}
let native;
try { global.structuredClone(() => {}); } catch (error) { native = error; }
const cases = [
{label:'abort', error:new DOM(message, 'AbortError'), ctor:DOM, name:'AbortError', message, code:20},
{label:'default', error:new DOM(), ctor:DOM, name:'Error', message:'', code:0},
{label:'custom', error:new DOM(message, 'CustomError'), ctor:DOM, name:'CustomError', message, code:0},
{label:'base-quota-name', error:new DOM(message, 'QuotaExceededError'), ctor:DOM, name:'QuotaExceededError', message, code:22},
{label:'subclass', error:new Derived(message, 'NotFoundError'), ctor:DOM, name:'NotFoundError', message, code:8},
{label:'native', error:native, ctor:DOM, name:'DataCloneError', message:native.message, code:25},
...[
['empty', {}], ['quota', {quota:10}], ['requested', {requested:12}],
['zero', {quota:0, requested:0}], ['fraction', {quota:10.25, requested:12.5}]
].map(([label, options]) => ({label:'quota-'+label, error:new Quota(message, options),
ctor:Quota, name:'QuotaExceededError', message, code:22,
quota:options.quota ?? null, requested:options.requested ?? null}))
];
check('native API exception retains its diagnostic stack', typeof native.stack === 'string');
const ordinary = new TypeError('ordinary', {cause:cases[0].error});
const ordinaryStack = ordinary.stack;
let authorReads = 0;
const poison = () => { ++authorReads; throw new Error('author getter must not run'); };
for (const entry of cases) {
Object.setPrototypeOf(entry.error, null);
for (const name of ['message', 'name', 'code', 'quota', 'requested', 'stack', 'expando']) {
Object.defineProperty(entry.error, name, {enumerable:true, get:poison});
}
}
const value = {kind:'original', errors:cases.map(entry => entry.error), ordinary};
value.alias = value.errors[0]; value.self = value;
value.map = new Map([[value.errors[0], value.errors[1]]]);
value.set = new Set([value.errors[0]]);
const inspect = (label, copy) => {
check(label+': fresh graph with cycles and aliases', copy !== value && copy.self === copy && copy.alias === copy.errors[0]);
check(label+': Map and Set preserve native-object identity', copy.map.get(copy.errors[0]) === copy.errors[1] && copy.set.has(copy.errors[0]));
check(label+': ordinary Error keeps prototype, cause and stack', Object.getPrototypeOf(copy.ordinary) === TypeError.prototype && copy.ordinary.cause === copy.errors[0] && copy.ordinary.stack === ordinaryStack);
check(label+': exception count', copy.errors.length === cases.length);
for (let i=0; i<cases.length; ++i) {
const entry=cases[i], error=copy.errors[i], name=label+': '+entry.label;
check(name+': native prototype and independent identity', Object.getPrototypeOf(error) === entry.ctor.prototype && error !== entry.error && error instanceof DOM);
check(name+': data fields', error.name === entry.name && error.message === entry.message && error.code === entry.code);
if (entry.ctor === Quota) check(name+': nullable quota data', Object.is(error.quota, entry.quota) && Object.is(error.requested, entry.requested));
check(name+': no authored properties or invented stack', Object.keys(error).length === 0 && !Object.hasOwn(error,'stack') && error.expando === undefined);
}
};
const dbName = 'exception-payloads-'+Date.now()+'-'+Math.random();
let db;
try {
const open = global.indexedDB.open(dbName, 1);
open.onupgradeneeded = () => open.result.createObjectStore('values').createIndex('kind','kind');
db = await request(open);
const tx = db.transaction('values','readwrite'), done = completion(tx), store = tx.objectStore('values');
for (const entry of cases) {
let error;
try { store.put(new Proxy(entry.error, {}), 'proxy-'+entry.label); } catch (caught) { error = caught; }
check(entry.label+': author Proxy rejected', error instanceof DOM && error.name === 'DataCloneError');
}
let serialized = true;
try { store.add(value,'add'); store.put(value,'put'); } catch (error) {
serialized = false;
check('native exception data can be stored: '+error.name, false);
}
await done;
check('native exception records accepted', serialized);
if (serialized) {
Object.defineProperty(global,'DOMException',{configurable:true,get:poison});
Object.defineProperty(global,'QuotaExceededError',{configurable:true,get:poison});
const read = db.transaction('values');
const readDone = completion(read), values = read.objectStore('values');
const one = request(values.get('add'));
const many = request(values.getAll());
const indexed = request(values.index('kind').get('original'));
const [copy, copies, indexCopy] = await Promise.all([one,many,indexed]);
await readDone;
inspect('get',copy);
check('getAll returns both records',copies.length === 2);
for (let i=0;i<copies.length;++i) inspect('getAll['+i+']',copies[i]);
inspect('index.get',indexCopy);
value.kind='updated';
const update=db.transaction('values','readwrite'), updateDone=completion(update);
const cursor=update.objectStore('values').openCursor();
const changed = new Promise((resolve,reject) => {
cursor.onerror=() => reject(cursor.error);
cursor.onsuccess=() => {
const change=cursor.result.update(value);
change.onsuccess=resolve; change.onerror=() => reject(change.error);
};
});
await changed; await updateDone;
db.close(); db=await request(global.indexedDB.open(dbName));
const reopened=db.transaction('values'), reopenedDone=completion(reopened);
const saved=await request(reopened.objectStore('values').index('kind').get('updated'));
await reopenedDone;
inspect('cursor.update after reopening',saved);
}
check('native data serialization never reads author getters',authorReads === 0);
} catch(error) {
check('probe completes without '+error.name+': '+error.message,false);
} finally {
Object.defineProperty(global,'DOMException',domDescriptor);
Object.defineProperty(global,'QuotaExceededError',quotaDescriptor);
if (db) db.close();
await request(global.indexedDB.deleteDatabase(dbName));
}
return {rows,failures};
}