mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
fix(cache): return native query results in the owner realm
This commit is contained in:
@@ -32,6 +32,7 @@ use crate::webidl;
|
||||
mod bucket_maintenance;
|
||||
mod cache_add;
|
||||
mod cache_query;
|
||||
mod cache_results;
|
||||
use moli_storage_service::StorageBucketCacheName;
|
||||
mod legacy_storage_quota;
|
||||
pub(in crate::context_bootstrap) use bucket_maintenance::settle_storage_bucket_operation;
|
||||
@@ -1239,6 +1240,8 @@ fn storage_bucket_cache_storage_open_callback<'s>(
|
||||
let Some(cache_name) = cache_query::name_argument(scope, &args, resolver) else {
|
||||
return;
|
||||
};
|
||||
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
|
||||
let scope = &mut v8::ContextScope::new(scope, owner);
|
||||
let Some(handle) =
|
||||
storage_bucket_cache_storage_live_handle(scope, args.this(), resolver, "open")
|
||||
else {
|
||||
@@ -1281,17 +1284,21 @@ fn storage_bucket_cache_storage_match_callback<'s>(
|
||||
let options = parsed.options;
|
||||
let request = parsed.request.expect("required RequestInfo was converted");
|
||||
let query = storage_bucket_cache_query(request, &options);
|
||||
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
|
||||
let scope = &mut v8::ContextScope::new(scope, owner);
|
||||
let Some(handle) =
|
||||
storage_bucket_cache_storage_live_handle(scope, args.this(), resolver, "match")
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let matched = with_storage_bucket_store_entry(scope, |store| {
|
||||
let cache_names = match parsed.cache_name.as_ref() {
|
||||
Some(cache_name) => vec![cache_name.clone()],
|
||||
None => store.cache_names_for_identity(&handle.identity)?,
|
||||
};
|
||||
let cache_names = store.cache_names_for_identity(&handle.identity)?;
|
||||
for cache_name in cache_names {
|
||||
if let Some(expected) = parsed.cache_name.as_ref()
|
||||
&& expected != &cache_name
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if let Some(response) = store
|
||||
.match_cache_entries_for_identity(&handle.identity, &cache_name, &query)?
|
||||
.into_iter()
|
||||
@@ -1339,6 +1346,8 @@ fn storage_bucket_cache_storage_has_callback<'s>(
|
||||
let Some(cache_name) = cache_query::name_argument(scope, &args, resolver) else {
|
||||
return;
|
||||
};
|
||||
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
|
||||
let scope = &mut v8::ContextScope::new(scope, owner);
|
||||
let Some(handle) =
|
||||
storage_bucket_cache_storage_live_handle(scope, args.this(), resolver, "has")
|
||||
else {
|
||||
@@ -1370,6 +1379,8 @@ fn storage_bucket_cache_storage_keys_callback<'s>(
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
|
||||
let scope = &mut v8::ContextScope::new(scope, owner);
|
||||
let Some(handle) =
|
||||
storage_bucket_cache_storage_live_handle(scope, args.this(), resolver, "keys")
|
||||
else {
|
||||
@@ -1412,6 +1423,8 @@ fn storage_bucket_cache_storage_delete_callback<'s>(
|
||||
let Some(cache_name) = cache_query::name_argument(scope, &args, resolver) else {
|
||||
return;
|
||||
};
|
||||
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
|
||||
let scope = &mut v8::ContextScope::new(scope, owner);
|
||||
let Some(handle) =
|
||||
storage_bucket_cache_storage_live_handle(scope, args.this(), resolver, "delete")
|
||||
else {
|
||||
@@ -1748,6 +1761,8 @@ fn storage_bucket_cache_match_callback<'s>(
|
||||
let options = parsed.options;
|
||||
let request = parsed.request.expect("required RequestInfo was converted");
|
||||
let query = storage_bucket_cache_query(request, &options);
|
||||
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
|
||||
let scope = &mut v8::ContextScope::new(scope, owner);
|
||||
let Some(handle) = storage_bucket_cache_live_handle(scope, args.this(), resolver, "match")
|
||||
else {
|
||||
return;
|
||||
@@ -1802,6 +1817,8 @@ fn storage_bucket_cache_match_all_callback<'s>(
|
||||
let options = parsed.options;
|
||||
let request = parsed.request;
|
||||
let query = request.map(|request| storage_bucket_cache_query(request, &options));
|
||||
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
|
||||
let scope = &mut v8::ContextScope::new(scope, owner);
|
||||
let Some(handle) = storage_bucket_cache_live_handle(scope, args.this(), resolver, "matchAll")
|
||||
else {
|
||||
return;
|
||||
@@ -1842,6 +1859,14 @@ fn storage_bucket_cache_match_all_callback<'s>(
|
||||
return;
|
||||
}
|
||||
}
|
||||
let Some(responses) = cache_results::freeze_array(scope, responses) else {
|
||||
reject_type_error(
|
||||
scope,
|
||||
resolver,
|
||||
"Cache.matchAll failed to freeze its result.",
|
||||
);
|
||||
return;
|
||||
};
|
||||
let _ = resolver.resolve(scope, responses.into());
|
||||
}
|
||||
Some(None) => reject_storage_bucket_unknown_error(scope, resolver, "cache.matchAll"),
|
||||
@@ -1872,6 +1897,8 @@ fn storage_bucket_cache_keys_callback<'s>(
|
||||
let options = parsed.options;
|
||||
let request = parsed.request;
|
||||
let query = request.map(|request| storage_bucket_cache_query(request, &options));
|
||||
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
|
||||
let scope = &mut v8::ContextScope::new(scope, owner);
|
||||
let Some(handle) = storage_bucket_cache_live_handle(scope, args.this(), resolver, "keys")
|
||||
else {
|
||||
return;
|
||||
@@ -1922,6 +1949,8 @@ fn storage_bucket_cache_delete_callback<'s>(
|
||||
let options = parsed.options;
|
||||
let request = parsed.request.expect("required RequestInfo was converted");
|
||||
let query = storage_bucket_cache_query(request, &options);
|
||||
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
|
||||
let scope = &mut v8::ContextScope::new(scope, owner);
|
||||
let Some(handle) = storage_bucket_cache_live_handle(scope, args.this(), resolver, "delete")
|
||||
else {
|
||||
return;
|
||||
@@ -2618,25 +2647,7 @@ fn cache_entries_to_request_array<'s>(
|
||||
return None;
|
||||
}
|
||||
}
|
||||
Some(requests)
|
||||
}
|
||||
|
||||
fn headers_entries_to_init_array<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
entries: &[(String, String)],
|
||||
) -> v8::Local<'s, v8::Array> {
|
||||
let array = v8::Array::new(scope, entries.len() as i32);
|
||||
for (index, (name, value)) in entries.iter().enumerate() {
|
||||
let pair = v8::Array::new(scope, 2);
|
||||
if let Some(name) = v8_string(scope, name) {
|
||||
let _ = pair.set_index(scope, 0, name.into());
|
||||
}
|
||||
if let Some(value) = v8_string(scope, value) {
|
||||
let _ = pair.set_index(scope, 1, value.into());
|
||||
}
|
||||
let _ = array.set_index(scope, index as u32, pair.into());
|
||||
}
|
||||
array
|
||||
cache_results::freeze_array(scope, requests)
|
||||
}
|
||||
|
||||
fn cache_entry_usage_bytes(
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
//! Result construction runs in the receiver's realm after WebIDL conversion.
|
||||
use super::*;
|
||||
use moli_webapi_declare::WebApiObject;
|
||||
|
||||
pub(super) fn owner_resolver<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
receiver: v8::Local<'s, v8::Object>,
|
||||
callee_resolver: v8::Local<'s, v8::PromiseResolver>,
|
||||
rv: &mut v8::ReturnValue<'_, v8::Value>,
|
||||
) -> (
|
||||
v8::Local<'s, v8::Context>,
|
||||
v8::Local<'s, v8::PromiseResolver>,
|
||||
) {
|
||||
let target = moli_webapi_declare::web_api_object_target(scope, receiver)
|
||||
.expect("branded Cache receiver has native identity");
|
||||
let owner = target
|
||||
.get_creation_context(scope)
|
||||
.expect("Cache receiver has an owner realm");
|
||||
if owner == scope.get_current_context() {
|
||||
return (owner, callee_resolver);
|
||||
}
|
||||
let scope = &mut v8::ContextScope::new(scope, owner);
|
||||
let resolver = v8::PromiseResolver::new(scope).expect("Cache result Promise should allocate");
|
||||
rv.set(resolver.get_promise(scope).into());
|
||||
(owner, resolver)
|
||||
}
|
||||
|
||||
pub(super) fn freeze_array<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
array: v8::Local<'s, v8::Array>,
|
||||
) -> Option<v8::Local<'s, v8::Array>> {
|
||||
array
|
||||
.set_integrity_level(scope, v8::IntegrityLevel::Frozen)?
|
||||
.then_some(array)
|
||||
}
|
||||
|
||||
#[derive(WebApiObject)]
|
||||
#[webapi(plain, data_properties, enumerable)]
|
||||
struct CachedResponseInitDeclaration<'s> {
|
||||
status: u32,
|
||||
status_text: v8::Local<'s, v8::String>,
|
||||
}
|
||||
|
||||
fn without_prototype<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
object
|
||||
.set_prototype(scope, v8::null(scope).into())?
|
||||
.then_some(object)
|
||||
}
|
||||
|
||||
pub(super) fn response_init<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
status: u16,
|
||||
status_text: &str,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
let status_text = v8_string(scope, status_text)?;
|
||||
let init = CachedResponseInitDeclaration::new(status as u32, status_text)
|
||||
.bind(scope)
|
||||
.ok()?;
|
||||
without_prototype(scope, init)
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
(async () => {
|
||||
const checks = [];
|
||||
async function check(name, test) {
|
||||
try { checks.push({name, passed: (await test()) === true}); }
|
||||
catch (error) { checks.push({name, passed:false, error:String(error)}); }
|
||||
}
|
||||
const names = ['cache-order-z','cache-order-a','cache-order-Z','cache-order-',
|
||||
'cache-order-\ud800','cache-order-\ufffd','cache-order-\0','cache-order-😀'];
|
||||
const list = async () => (await caches.keys()).filter(name => names.includes(name));
|
||||
const same = (a,b) => JSON.stringify(a) === JSON.stringify(b);
|
||||
const handles = [];
|
||||
try {
|
||||
await Promise.all(names.map(name => caches.delete(name)));
|
||||
handles.push(...await Promise.all(names.map(name => caches.open(name))));
|
||||
await check('names follow creation order', async () => same(await list(),names));
|
||||
await caches.open(names[2]);
|
||||
await check('reopen preserves position', async () => same(await list(),names));
|
||||
for (let i=0;i<names.length;i++) await handles[i].put('/ordering',new Response(names[i]));
|
||||
await check('storage match selects oldest cache', async () => (await (await caches.match('/ordering')).text()) === names[0]);
|
||||
await check('storage explicit name selects chosen cache', async () => (await (await caches.match('/ordering',{cacheName:names[1]})).text()) === names[1]);
|
||||
await check('delete existing cache', async () => await caches.delete(names[1]));
|
||||
await check('delete preserves survivor order', async () => same(await list(),names.filter((_,i)=>i!==1)));
|
||||
const recreated = await caches.open(names[1]);
|
||||
await check('recreated name goes last', async () => same(await list(),[...names.filter((_,i)=>i!==1),names[1]]));
|
||||
await check('recreated cache is empty', async () => (await recreated.keys()).length===0);
|
||||
await check('deleted handle keeps contents', async () => await (await handles[1].match('/ordering')).text()===names[1]);
|
||||
await caches.delete(names[0]);
|
||||
await check('storage match follows next surviving cache', async () => await (await caches.match('/ordering')).text()===names[2]);
|
||||
await check('missing named match does not create cache', async () => {
|
||||
const before=await list();const missing='cache-order-absent';await caches.delete(missing);
|
||||
return await caches.match('/ordering',{cacheName:missing})===undefined && !(await caches.has(missing)) && same(await list(),before);
|
||||
});
|
||||
await check('storage keys returns fresh mutable array', async () => {
|
||||
const a=await caches.keys(),b=await caches.keys();a.push('local-only');return a!==b && !Object.isFrozen(a) && !(await caches.has('local-only'));
|
||||
});
|
||||
const cache=await caches.open('cache-results');
|
||||
await cache.put('/first',new Response('first',{headers:{'x-value':'1'}}));
|
||||
await cache.put('/second',new Response('second',{headers:{'x-value':'2'}}));
|
||||
for (const method of ['keys','matchAll']) {
|
||||
for (const request of [undefined,'/first','/missing']) {
|
||||
const label=method+'/'+String(request),a=await cache[method](request),b=await cache[method](request);
|
||||
await check(label+'/frozen array', () => Array.isArray(a)&&Object.isFrozen(a));
|
||||
await check(label+'/immutable length and entries', async () => {
|
||||
const value=await cache[method](request),old=value.length;
|
||||
return !Reflect.set(value,'length',old+1)&&!Reflect.set(value,'0',null)&&value.length===old;
|
||||
});
|
||||
await check(label+'/fresh result and elements', () => a!==b&&(a.length===0||a[0]!==b[0]));
|
||||
await check(label+'/shallow freeze', () => {if(!a.length)return true;a[0].marker=42;return a[0].marker===42&&!Object.isFrozen(a[0]);});
|
||||
if (a.length) for (const mutation of ['append','set','delete']) {
|
||||
await check(label+'/immutable headers '+mutation, () => {
|
||||
let error;try{a[0].headers[mutation]('x-value','changed');}catch(e){error=e;}return error instanceof TypeError;
|
||||
});
|
||||
}
|
||||
}
|
||||
await check(method+'/internal headers ignore author iterator', async () => {
|
||||
const descriptor=Object.getOwnPropertyDescriptor(Array.prototype,Symbol.iterator);let reads=0;
|
||||
Object.defineProperty(Array.prototype,Symbol.iterator,{configurable:true,get(){reads++;throw 42;}});
|
||||
try{return (await cache[method]()).length===2&&reads===0;}finally{Object.defineProperty(Array.prototype,Symbol.iterator,descriptor);}
|
||||
});
|
||||
const ctor=method==='keys'?'Request':'Response',descriptor=Object.getOwnPropertyDescriptor(globalThis,ctor);
|
||||
await check(method+'/intrinsic constructor', async () => {
|
||||
let calls=0;Object.defineProperty(globalThis,ctor,{configurable:true,get(){calls++;throw 42;}});
|
||||
try{return (await cache[method]()).length===2&&calls===0;}finally{Object.defineProperty(globalThis,ctor,descriptor);}
|
||||
});
|
||||
}
|
||||
await check('keys ignores inherited RequestInit getters',async()=>{
|
||||
const descriptor=Object.getOwnPropertyDescriptor(Object.prototype,'mode');let reads=0;
|
||||
Object.defineProperty(Object.prototype,'mode',{configurable:true,get(){reads++;throw 42;}});
|
||||
try{return (await cache.keys()).length===2&&reads===0;}finally{if(descriptor)Object.defineProperty(Object.prototype,'mode',descriptor);else delete Object.prototype.mode;}
|
||||
});
|
||||
if(typeof document!=='undefined') {
|
||||
const frame=document.createElement('iframe');document.body.append(frame);const child=frame.contentWindow;
|
||||
try {
|
||||
const childCache=await child.caches.open('cache-results');
|
||||
for(const [ownerLabel,owner,receiver] of [['main',globalThis,cache],['child',child,childCache]]) {
|
||||
for(const [calleeLabel,callee] of [['main',globalThis],['child',child]]) {
|
||||
for(const method of ['keys','matchAll']) {
|
||||
const label='realm/'+ownerLabel+'/'+calleeLabel+'/'+method;
|
||||
const promise=callee.Cache.prototype[method].call(receiver),a=await promise;
|
||||
const C=method==='keys'?owner.Request:owner.Response;
|
||||
await check(label+'/promise',()=>Object.getPrototypeOf(promise)===owner.Promise.prototype);
|
||||
await check(label+'/array',()=>Object.getPrototypeOf(a)===owner.Array.prototype);
|
||||
await check(label+'/elements',()=>a.length===2&&a.every(value=>Object.getPrototypeOf(value)===C.prototype));
|
||||
await check(label+'/frozen',()=>Object.isFrozen(a));
|
||||
await check(label+'/invalid URL callee rejection',async()=>{
|
||||
const p=callee.Cache.prototype[method].call(receiver,'http://[');let error;
|
||||
try{await p;}catch(e){error=e;}
|
||||
return Object.getPrototypeOf(p)===callee.Promise.prototype&&error instanceof callee.TypeError;
|
||||
});
|
||||
await check(label+'/getter callee rejection',async()=>{
|
||||
const reason={};const p=callee.Cache.prototype[method].call(receiver,'/first',{get ignoreMethod(){throw reason;}});let error;
|
||||
try{await p;}catch(e){error=e;}
|
||||
return Object.getPrototypeOf(p)===callee.Promise.prototype&&error===reason;
|
||||
});
|
||||
}
|
||||
await check('realm/'+ownerLabel+'/'+calleeLabel+'/match',async()=>{
|
||||
const value=await callee.Cache.prototype.match.call(receiver,'/first');return Object.getPrototypeOf(value)===owner.Response.prototype;
|
||||
});
|
||||
for(const method of ['keys','match','open','has','delete']) {
|
||||
const input=method==='match'?'/first':method==='delete'?'cache-order-absent':'cache-results';
|
||||
const promise=callee.CacheStorage.prototype[method].call(owner.caches,input),value=await promise;
|
||||
const label='storage-realm/'+ownerLabel+'/'+calleeLabel+'/'+method;
|
||||
await check(label+'/promise',()=>Object.getPrototypeOf(promise)===owner.Promise.prototype);
|
||||
await check(label+'/value',()=>{
|
||||
if(method==='keys')return Object.getPrototypeOf(value)===owner.Array.prototype&&!Object.isFrozen(value);
|
||||
if(method==='match')return Object.getPrototypeOf(value)===owner.Response.prototype;
|
||||
if(method==='open')return Object.getPrototypeOf(value)===owner.Cache.prototype;
|
||||
return typeof value==='boolean';
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}finally{frame.remove();}
|
||||
}
|
||||
} finally {
|
||||
await Promise.all([...names,'cache-results','cache-order-absent'].map(name=>caches.delete(name)));
|
||||
}
|
||||
globalThis.__uiEventResults={checks,total:checks.length,passed:checks.filter(row=>row.passed).length,complete:true};
|
||||
return true;
|
||||
})()
|
||||
@@ -0,0 +1,23 @@
|
||||
use super::*;
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn cache_queries_preserve_creation_order_owner_realm_and_immutable_results() {
|
||||
let loader = static_http_loader(std::iter::empty::<String>());
|
||||
let mut vm =
|
||||
new_storage_page_task_executor_test_vm_with_loader("https://cache-results.test/", &loader);
|
||||
vm.exec(include_str!("cache_results.js"), None).unwrap();
|
||||
advance_page_task_executor_until_eval_equals(
|
||||
&mut vm,
|
||||
&loader,
|
||||
"String(globalThis.__uiEventResults?.complete===true)",
|
||||
"true",
|
||||
"cache-query-results-fixture",
|
||||
)
|
||||
.await;
|
||||
assert_eq!(vm.eval("__uiEventResults.total").unwrap(), "145");
|
||||
assert_eq!(
|
||||
vm.eval("JSON.stringify(__uiEventResults.checks.filter(row=>!row.passed))")
|
||||
.unwrap(),
|
||||
"[]"
|
||||
);
|
||||
}
|
||||
@@ -16,6 +16,7 @@ mod broadcast_channel;
|
||||
mod cache_add;
|
||||
mod cache_query;
|
||||
mod cache_query_init;
|
||||
mod cache_results;
|
||||
mod chrome;
|
||||
#[cfg(feature = "devtools")]
|
||||
mod click_targets;
|
||||
|
||||
Reference in New Issue
Block a user