Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
Improve GraphQL cache reads across native and browser Turso (#7097)
teoef0b551f0a6f
diff --git a/Cargo.lock b/Cargo.lockindex 2d2d0a655c..2f7d00fff1 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -3313,7 +3313,7 @@ dependencies = [[[package]]name = "cache-wasm"-version = "0.6.35"+version = "0.6.36"dependencies = ["async-lock","cache-core",diff --git a/apps/web/src/lib/graphql-cache/worker/browser-test/fake-coordinator.shared-worker.ts b/apps/web/src/lib/graphql-cache/worker/browser-test/fake-coordinator.shared-worker.tsindex 163ceb4dd1..3d46a7c2f3 100644--- a/apps/web/src/lib/graphql-cache/worker/browser-test/fake-coordinator.shared-worker.ts+++ b/apps/web/src/lib/graphql-cache/worker/browser-test/fake-coordinator.shared-worker.ts@@ -1,10 +1,12 @@/// <reference lib="webworker" />-import { installCacheCoordinatorWorker } from '../cache-coordinator-runtime';+import { installSharedCacheCoordinatorWorker } from '../cache-coordinator-runtime';import { CoordinatorRouter } from '../coordinator-router';+declare const self: SharedWorkerGlobalScope;+const router = new CoordinatorRouter();-installCacheCoordinatorWorker({ router });+installSharedCacheCoordinatorWorker(self, router);let telemetry: BroadcastChannel | undefined;setInterval(() => {diff --git a/apps/web/src/lib/graphql-cache/worker/browser-test/mail-projection-harness.ts b/apps/web/src/lib/graphql-cache/worker/browser-test/mail-projection-harness.tsindex 9d12dea1ea..b41c242515 100644--- a/apps/web/src/lib/graphql-cache/worker/browser-test/mail-projection-harness.ts+++ b/apps/web/src/lib/graphql-cache/worker/browser-test/mail-projection-harness.ts@@ -21,7 +21,7 @@ const nil = id(0);const previewFields ='id subject snippet isDraft senderEmail senderName senderPhotoUrl';const previews = `mailAllPreview { ${previewFields} } mailDraftPreview { ${previewFields} } mailSentPreview { ${previewFields} }`;-const query = `query MailSeed { user { id emailLinks { id } soup(input:{initial:{limit:100,emailView:ALL}}) { items { __typename id cacheProjection ... on GraphqlSoupEmailThread { name linkId ownerId isRead inboxVisible isSignal latestInboundMessageTs ${previews} updatedAt properties { id } } } } } }`;+const query = `query MailSeed { user { id emailLinks { id } soup(input:{initial:{limit:100,emailView:ALL}}) { items { __typename id cacheProjection isFavorited ... on GraphqlSoupEmailThread { name linkId ownerId isRead inboxVisible isSignal latestInboundMessageTs ${previews} updatedAt properties { id } } } } } }`;const fragment = `fragment MailRow on GraphqlSoupEmailThread { __typename id emailName:name isRead inboxVisible ${previews} }`;const preview = (n: number, subject: string, isDraft: boolean) => ({id: id(n),@@ -137,6 +137,7 @@ await host.writeQuery({n <= 50 ? 'offline-mail-viewer' : 'macro|[email protected]',cacheProjection: mailProjectionCapsules[index],properties: [],+ isFavorited: false,mailAllPreview:n === 7 ? null : preview(n + 10000, `Email ${n}`, false),mailDraftPreview:diff --git a/apps/web/src/lib/graphql-cache/worker/browser-test/notification-projection-harness.ts b/apps/web/src/lib/graphql-cache/worker/browser-test/notification-projection-harness.tsindex 6f5909dc30..2718de2a0d 100644--- a/apps/web/src/lib/graphql-cache/worker/browser-test/notification-projection-harness.ts+++ b/apps/web/src/lib/graphql-cache/worker/browser-test/notification-projection-harness.ts@@ -16,7 +16,7 @@ const ids = [const nil = '00000000-0000-0000-0000-000000000000';const snapshotQuery = `query Snapshot {user { id soup(input: { initial: { limit: 20 } }) { items {- __typename id cacheProjection+ __typename id cacheProjection isFavoritedproperties { id }notifications { id entityId entityType state }... on GraphqlSoupProject { ownerId parentId createdAt updatedAt }@@ -101,6 +101,7 @@ const snapshot = (id: entityId,cacheProjection: null,properties: [],+ isFavorited: false,ownerId: 'macro|[email protected]',parentId: null,createdAt: '2025-01-01T00:00:00Z',diff --git a/apps/web/src/lib/graphql-cache/worker/cache-coordinator-runtime.test.ts b/apps/web/src/lib/graphql-cache/worker/cache-coordinator-runtime.test.tsindex f362664c75..8a0505ccd9 100644--- a/apps/web/src/lib/graphql-cache/worker/cache-coordinator-runtime.test.ts+++ b/apps/web/src/lib/graphql-cache/worker/cache-coordinator-runtime.test.ts@@ -1,12 +1,16 @@import * as Effect from 'effect/Effect';import { describe, expect, it, vi } from 'vitest';-import { installCacheCoordinatorWorker } from './cache-coordinator-runtime';+import {+ installCacheCoordinatorWorker,+ installSharedCacheCoordinatorWorker,+} from './cache-coordinator-runtime';import type { CoordinatorToTabEnvelope } from './coordinator-protocol';import type {CoordinatorMessagePort,CoordinatorRouter,} from './coordinator-router';import {+ EFFECT_WORKER_CLOSE_FRAME,EFFECT_WORKER_REQUEST_TAG,EFFECT_WORKER_RESPONSE_TAG,} from './effect-worker-transport';@@ -77,6 +81,37 @@ describe('cache coordinator runtime', () => {await Effect.runPromise(runner.close());});+ it('closes a lost client runner while another client remains usable', async () => {+ const ports: CoordinatorMessagePort[] = [];+ const received = vi.fn();+ const router = {+ connect(port: CoordinatorMessagePort) {+ ports.push(port);+ port.onmessage = received;+ },+ } as unknown as CoordinatorRouter;+ const first = new FakeEndpoint();+ const second = new FakeEndpoint();+ const firstRunner = installCacheCoordinatorWorker({+ endpoint: first as unknown as MessagePort,+ router,+ });+ const secondRunner = installCacheCoordinatorWorker({+ endpoint: second as unknown as MessagePort,+ router,+ });+ first.receive(message);+ second.receive(message);+ await vi.waitFor(() => expect(ports).toHaveLength(2));+ ports[0].close();+ await vi.waitFor(() => expect(first.closed).toBe(true));+ expect(firstRunner.isClosed()).toBe(true);+ expect(second.closed).toBe(false);+ second.receive(message);+ expect(received).toHaveBeenCalledTimes(3);+ await Effect.runPromise(secondRunner.close());+ });+it('contains failed sends and leaves the closed port terminal', async () => {const { connect, endpoint, ports, runner } = setup();const onmessageerror = vi.fn();@@ -103,3 +138,31 @@ describe('cache coordinator runtime', () => {await Effect.runPromise(runner.close());});});++describe('shared coordinator client retirement', () => {+ it('accepts a new client after the last client closes and releases router state', async () => {+ const disconnected = vi.fn();+ const connect = vi.fn((port: CoordinatorMessagePort) => {+ port.onmessageerror = disconnected;+ });+ const scope: { onconnect: ((event: MessageEvent) => void) | null } = {+ onconnect: null,+ };+ installSharedCacheCoordinatorWorker(scope, {+ connect,+ } as unknown as CoordinatorRouter);+ for (let index = 0; index < 3; index++) {+ const endpoint = new FakeEndpoint();+ scope.onconnect?.({ ports: [endpoint] } as unknown as MessageEvent);+ endpoint.receive(message);+ await vi.waitFor(() => expect(connect).toHaveBeenCalledTimes(index + 1));+ endpoint.dispatchEvent(+ new MessageEvent('message', { data: EFFECT_WORKER_CLOSE_FRAME })+ );+ await vi.waitFor(() =>+ expect(disconnected).toHaveBeenCalledTimes(index + 1)+ );+ expect(endpoint.closed).toBe(true);+ }+ });+});diff --git a/apps/web/src/lib/graphql-cache/worker/cache-coordinator-runtime.ts b/apps/web/src/lib/graphql-cache/worker/cache-coordinator-runtime.tsindex 5527ef5758..3a68617037 100644--- a/apps/web/src/lib/graphql-cache/worker/cache-coordinator-runtime.ts+++ b/apps/web/src/lib/graphql-cache/worker/cache-coordinator-runtime.ts@@ -15,17 +15,25 @@ import {} from './effect-worker-transport';export interface CacheCoordinatorRuntimeOptions {- endpoint?: MessagePort | Window;+ endpoint: MessagePort;router?: CoordinatorRouter;}/** Installs the SharedWorker-side Effect runner around CoordinatorRouter. */export function installCacheCoordinatorWorker(- options: CacheCoordinatorRuntimeOptions = {}+ options: CacheCoordinatorRuntimeOptions): EffectWorkerRunnerTransport<CoordinatorToTabEnvelope> {const router = options.router ?? new CoordinatorRouter();const ports = new Map<number, CoordinatorMessagePort>();const closedPortIds = new Set<number>();+ let stopped = false;+ const stop = (): void => {+ if (stopped) return;+ stopped = true;+ // Finalizers may call router close synchronously. End this client scope+ // after the current callback so cleanup cannot recurse into itself.+ queueMicrotask(() => Effect.runFork(runner.close()));+ };let runner!: EffectWorkerRunnerTransport<CoordinatorToTabEnvelope>;const portFor = (portId: number): CoordinatorMessagePort => {@@ -44,12 +52,14 @@ export function installCacheCoordinatorWorker(ports.delete(portId);closedPortIds.add(portId);port.onmessageerror?.({ data: error } as MessageEvent);+ stop();}},start(): void {},close(): void {if (ports.get(portId) === port) ports.delete(portId);closedPortIds.add(portId);+ stop();},};closedPortIds.delete(portId);@@ -58,11 +68,20 @@ export function installCacheCoordinatorWorker(return port;};+ const disconnectAll = (error?: unknown): void => {+ for (const [portId, port] of ports) {+ ports.delete(portId);+ closedPortIds.add(portId);+ port.onmessageerror?.({ data: error } as MessageEvent);+ }+ stop();+ };+runner = createEffectWorkerRunnerTransport<TabToCoordinatorEnvelope,CoordinatorToTabEnvelope>({- endpoint: options.endpoint ?? (self as unknown as Window),+ endpoint: options.endpoint,onMessage(portId, message) {if (closedPortIds.has(portId)) return;portFor(portId).onmessage?.({@@ -76,14 +95,22 @@ export function installCacheCoordinatorWorker(closedPortIds.add(portId);port?.onmessageerror?.({} as MessageEvent);},- onError(error) {- for (const [portId, port] of ports) {- ports.delete(portId);- closedPortIds.add(portId);- port.onmessageerror?.({ data: error } as MessageEvent);- }- },+ onError: disconnectAll,+ onClose: disconnectAll,});return runner;}++/** Give each client its own runner scope. Closing its last port must not call+ * SharedWorkerGlobalScope.close() while another client is reconnecting. */+export function installSharedCacheCoordinatorWorker(+ scope: { onconnect: ((event: MessageEvent) => void) | null },+ router = new CoordinatorRouter()+): void {+ scope.onconnect = (event) => {+ for (const endpoint of event.ports) {+ installCacheCoordinatorWorker({ endpoint, router });+ }+ };+}diff --git a/apps/web/src/lib/graphql-cache/worker/cache.coordinator.shared-worker.ts b/apps/web/src/lib/graphql-cache/worker/cache.coordinator.shared-worker.tsindex 440b9bd949..13322dda21 100644--- a/apps/web/src/lib/graphql-cache/worker/cache.coordinator.shared-worker.ts+++ b/apps/web/src/lib/graphql-cache/worker/cache.coordinator.shared-worker.ts@@ -1,5 +1,7 @@/// <reference lib="webworker" />-import { installCacheCoordinatorWorker } from './cache-coordinator-runtime';+import { installSharedCacheCoordinatorWorker } from './cache-coordinator-runtime';-installCacheCoordinatorWorker();+declare const self: SharedWorkerGlobalScope;++installSharedCacheCoordinatorWorker(self);diff --git a/apps/web/src/lib/graphql-cache/worker/effect-worker-transport.ts b/apps/web/src/lib/graphql-cache/worker/effect-worker-transport.tsindex 647a4073d4..ad2f424666 100644--- a/apps/web/src/lib/graphql-cache/worker/effect-worker-transport.ts+++ b/apps/web/src/lib/graphql-cache/worker/effect-worker-transport.ts@@ -162,6 +162,8 @@ export interface EffectWorkerRunnerOptions<Inbound> {onMessage(portId: number, message: Inbound): void | Promise<void>;onDisconnect?: (portId: number) => void;onError(error: Error): void;+ /** Releases router state when the runner exits, including a peer close frame. */+ onClose?: () => void;}export interface EffectWorkerRunnerTransport<Outbound> {@@ -207,6 +209,12 @@ export function createEffectWorkerRunnerTransport<Inbound, Outbound>(): undefined;+ fiber.addObserver(() => {+ closed = true;+ if (disconnectFiber) Effect.runFork(Fiber.interrupt(disconnectFiber));+ options.onClose?.();+ });+return {send(portId, message, transfers): Effect.Effect<void, Error> {return Effect.suspend(() => {@@ -218,11 +226,9 @@ export function createEffectWorkerRunnerTransport<Inbound, Outbound>(return runner.send(portId, message, transfers);});},-isClosed(): boolean {return closed;},-close(): Effect.Effect<void> {return Effect.suspend(() => {closed = true;diff --git a/apps/web/tauri/graphql_cache_plugin/src/engine.rs b/apps/web/tauri/graphql_cache_plugin/src/engine.rsindex b861492ccf..0986761760 100644--- a/apps/web/tauri/graphql_cache_plugin/src/engine.rs+++ b/apps/web/tauri/graphql_cache_plugin/src/engine.rs@@ -23,7 +23,7 @@ use cache_core::query_inspection::{CachedQueryInstance, CachedQueryVariant, Queruse cache_core::queue::{ClaimedMutation, MutationClaimRequest, MutationClaimToken, MutationUpsertKind,};-use cache_core::record_selection::{RecordSelection, SelectedRecord};+use cache_core::record_selection::{SelectedRecord, cache::RecordSelectionCache};use cache_core::revision::CacheRevision;use cache_core::search::{SearchPage, SearchRequest};use cache_core::value::EntityKey;@@ -350,6 +350,7 @@ pub struct WriteRequest {struct EngineState {engine: Engine<TursoStorage>,ops: OpInterner,+ selections: RecordSelectionCache,}/// Cheaply-clonable handle to the shared engine. All methods serialize@@ -403,6 +404,7 @@ impl EngineHandle {inner: Arc::new(Mutex::new(EngineState {engine,ops: OpInterner::default(),+ selections: RecordSelectionCache::default(),})),}}@@ -451,7 +453,7 @@ impl EngineHandle {entity_resolvers: Vec<EntityResolver>,) -> Result<ReadResultWire, String> {let mut state = self.inner.lock().await;- let EngineState { engine, ops } = &mut *state;+ let EngineState { engine, ops, .. } = &mut *state;let op = op_id.map(|name| ops.intern(&name));engine.read_query_with_entity_resolvers(@@ -476,12 +478,13 @@ impl EngineHandle {fragment_name: String,keys: Vec<String>,) -> Result<RecordSelectionResultWire, String> {- let selection =- RecordSelection::parse(&document, &fragment_name).map_err(|error| error.to_string())?;+ let mut state = self.inner.lock().await;+ let selection = state+ .selections+ .get(document, fragment_name)+ .map_err(|error| error.to_string())?;let keys: Vec<_> = keys.into_iter().map(|key| EntityKey(key.into())).collect();- self.inner- .lock()- .await+ state.engine.read_records_by_keys(&selection, &keys).await@@ -567,7 +570,7 @@ impl EngineHandle {identity,} = request;let mut state = self.inner.lock().await;- let EngineState { engine, ops } = &mut *state;+ let EngineState { engine, ops, .. } = &mut *state;let origin = origin_op_id.map(|name| ops.intern(&name));let registration = registration.map(|registration| {let op_id = ops.intern(®istration.op_id);@@ -616,7 +619,7 @@ impl EngineHandle {identity: Option<String>,) -> Result<HydrationWriteResultWire, String> {let mut state = self.inner.lock().await;- let EngineState { engine, ops } = &mut *state;+ let EngineState { engine, ops, .. } = &mut *state;let projections = soup::write_projections(engine,&query,@@ -663,7 +666,7 @@ impl EngineHandle {lease_expires_at_ms: i64,) -> Result<EnqueueOptimisticMutationResultWire, String> {let mut state = self.inner.lock().await;- let EngineState { engine, ops } = &mut *state;+ let EngineState { engine, ops, .. } = &mut *state;let origin = origin_op_id.map(|name| ops.intern(&name));let projections = soup::optimistic_projections(engine,@@ -749,7 +752,7 @@ impl EngineHandle {generation: parse_u64(&lease_generation, "lease generation")?,};let mut state = self.inner.lock().await;- let EngineState { engine, ops } = &mut *state;+ let EngineState { engine, ops, .. } = &mut *state;match engine.defer_optimistic_write(transaction, claim, next_attempt_at_ms, error).await@@ -782,7 +785,7 @@ impl EngineHandle {generation: parse_u64(&lease_generation, "lease generation")?,};let mut state = self.inner.lock().await;- let EngineState { engine, ops } = &mut *state;+ let EngineState { engine, ops, .. } = &mut *state;let projections = soup::write_projections(engine,&query,@@ -832,7 +835,7 @@ impl EngineHandle {generation: parse_u64(&lease_generation, "lease generation")?,};let mut state = self.inner.lock().await;- let EngineState { engine, ops } = &mut *state;+ let EngineState { engine, ops, .. } = &mut *state;match engine.rollback_optimistic_write_with_outcome(transaction, claim).await@@ -858,7 +861,7 @@ impl EngineHandle {keys: Vec<String>,) -> Result<AffectedOperationsResultWire, String> {let mut state = self.inner.lock().await;- let EngineState { engine, ops } = &mut *state;+ let EngineState { engine, ops, .. } = &mut *state;let projections = soup::invalidation_projections(engine, &keys).await?;let keys: Vec<EntityKey<'static>> =keys.into_iter().map(|key| EntityKey(key.into())).collect();@@ -879,7 +882,7 @@ impl EngineHandle {keys: Vec<String>,) -> Result<AffectedOperationsResultWire, String> {let mut state = self.inner.lock().await;- let EngineState { engine, ops } = &mut *state;+ let EngineState { engine, ops, .. } = &mut *state;let projections = soup::deletion_projections(engine, &keys).await?;let keys: Vec<EntityKey<'static>> =keys.into_iter().map(|key| EntityKey(key.into())).collect();@@ -896,7 +899,7 @@ impl EngineHandle {/// Unregisters an operation (urql teardown).pub async fn teardown(&self, op_id: String) -> Result<(), String> {let mut state = self.inner.lock().await;- let EngineState { engine, ops } = &mut *state;+ let EngineState { engine, ops, .. } = &mut *state;if let Some(id) = ops.remove(&op_id) {engine.teardown_operation(id);}diff --git a/apps/web/tauri/graphql_cache_plugin/src/engine/test.rs b/apps/web/tauri/graphql_cache_plugin/src/engine/test.rsindex 8081cf9383..3ceeec8cd7 100644--- a/apps/web/tauri/graphql_cache_plugin/src/engine/test.rs+++ b/apps/web/tauri/graphql_cache_plugin/src/engine/test.rs@@ -221,7 +221,7 @@ fn identical_hydration_does_not_advance_the_native_revision() {}#[test]-fn hydration_returns_only_unmarked_fields() {+fn hydration_returns_only_unmarked_fields_and_retains_entities_without_pages() {let handle = spawn_handle();let result = block_on(handle.hydrate_query(HYDRATION_QUERY.to_string(),@@ -239,10 +239,29 @@ fn hydration_returns_only_unmarked_fields() {})));assert!(!result.write_result.changed.is_empty());- let ReadResultWire::Hit { data } = read(&handle, None) else {- panic!("expected hydrated cache hit");+ assert!(matches!(read(&handle, None), ReadResultWire::Miss));+ let ReadResultWire::Hit { data } = block_on(handle.read(+ None,+ "query Viewer { user { id } }".to_string(),+ Some("Viewer".to_string()),+ Variables::new(),+ Vec::new(),+ ))+ .unwrap() else {+ panic!("expected hydrated viewer");};- assert_eq!(data, soup_data(true));+ assert_eq!(data, serde_json::json!({"user": {"id": "user-1"}}));+ let records = block_on(handle.read_records_by_keys(+ "fragment Document on GraphqlSoupDocument { __typename id }".to_string(),+ "Document".to_string(),+ vec!["GraphqlSoupDocument:doc-1".to_string()],+ ))+ .unwrap();+ assert_eq!(records.records.len(), 1);+ assert_eq!(+ records.records[0].record,+ serde_json::json!({"__typename": "GraphqlSoupDocument", "id": "doc-1"})+ );}#[test]diff --git a/apps/web/tauri/graphql_cache_plugin/src/engine/test/mail.graphql b/apps/web/tauri/graphql_cache_plugin/src/engine/test/mail.graphqlindex 908f3ddb93..64e750c41d 100644--- a/apps/web/tauri/graphql_cache_plugin/src/engine/test/mail.graphql+++ b/apps/web/tauri/graphql_cache_plugin/src/engine/test/mail.graphql@@ -7,6 +7,7 @@ query NativeMailBackfill {__typenameidcacheProjection+ isFavorited... on GraphqlSoupEmailThread {nameownerIddiff --git a/apps/web/tauri/graphql_cache_plugin/src/engine/test/project.graphql b/apps/web/tauri/graphql_cache_plugin/src/engine/test/project.graphqlindex 14fd7e7bfb..42e66605ad 100644--- a/apps/web/tauri/graphql_cache_plugin/src/engine/test/project.graphql+++ b/apps/web/tauri/graphql_cache_plugin/src/engine/test/project.graphql@@ -6,6 +6,7 @@ query NativeProject {__typenameidcacheProjection+ isFavorited... on GraphqlSoupProject {ownerIdparentIddiff --git a/apps/web/tauri/graphql_cache_plugin/src/engine/test/soup.rs b/apps/web/tauri/graphql_cache_plugin/src/engine/test/soup.rsindex 49a896eb84..81a5e180ad 100644--- a/apps/web/tauri/graphql_cache_plugin/src/engine/test/soup.rs+++ b/apps/web/tauri/graphql_cache_plugin/src/engine/test/soup.rs@@ -39,7 +39,7 @@ fn row(n: u16) -> Value {json!({"__typename": "GraphqlSoupEmailThread", "id": id(n), "name": format!("Mail {n}"),"ownerId": VIEWER, "linkId": id(1000), "isRead": n.is_multiple_of(4),- "inboxVisible": n.is_multiple_of(2), "isSignal": n.is_multiple_of(3),+ "inboxVisible": n.is_multiple_of(2), "isSignal": n.is_multiple_of(3), "isFavorited": false,"cacheProjection": capsule, "latestInboundMessageTs": TIMESTAMP, "updatedAt": TIMESTAMP, "properties": [],"mailAllPreview": preview(n, 1000),"mailDraftPreview": n.is_multiple_of(3).then(|| preview(n, 2000)),@@ -366,7 +366,7 @@ fn native_general_soup_filter_and_server_baseline_reconciliation() {json!({"user": {"id": VIEWER, "soup": {"items": [{"__typename": "GraphqlSoupProject", "id": id(100), "cacheProjection": null,"ownerId": VIEWER, "parentId": null, "createdAt": TIMESTAMP, "updatedAt": TIMESTAMP,- "notifications": [], "properties": []}],+ "notifications": [], "properties": [], "isFavorited": false}],}}}),Some(VIEWER),);diff --git a/crates/client/cache-core/Cargo.toml b/crates/client/cache-core/Cargo.tomlindex 7263e00d87..8acb7101cf 100644--- a/crates/client/cache-core/Cargo.toml+++ b/crates/client/cache-core/Cargo.toml@@ -12,7 +12,8 @@ maybe_send = { path = "../../maybe_send" }postcard = { workspace = true }predicate-index = { path = "../../predicate_index" }serde = { workspace = true }-serde_json = { workspace = true }+# Opaque JSON scalars must preserve floating-point values when reparsed.+serde_json = { workspace = true, features = ["float_roundtrip"] }sha2 = { workspace = true }thiserror = { workspace = true }uuid = { workspace = true }diff --git a/crates/client/cache-core/src/denormalize.rs b/crates/client/cache-core/src/denormalize.rsindex c8c7fe11c8..ffb7d29aa9 100644--- a/crates/client/cache-core/src/denormalize.rs+++ b/crates/client/cache-core/src/denormalize.rs@@ -15,9 +15,14 @@ use crate::entity_resolver::EntityResolverLookup;use crate::meta;use crate::value::{CacheValue, EntityKey, Record, field_key};use serde_json::Value as Json;+use std::borrow::Cow;use std::collections::BTreeSet;use thiserror::Error;+mod plan;+pub(crate) use plan::ReadPlans;+use plan::{Field, FieldSource};+/// Synchronous view over records available right now (hot tier + any/// batch-fetched records).pub trait RecordSource {@@ -125,175 +130,254 @@ fn denormalize_record_with_entity_resolvers(deps: &mut impl DependencyTracker,entity_resolvers: &EntityResolverLookup,) -> Result<ReadOutcome, DenormalizeError> {- let mut walk = Walk {+ ReadSession::new(key, type_name, selections).resume(variables,source,deps,entity_resolvers,- missing_records: BTreeSet::new(),- miss: None,- };- let data = walk.read_record(key, type_name, selections)?;+ &mut ReadPlans::default(),+ )+}- if !walk.missing_records.is_empty() {- return Ok(ReadOutcome::NeedRecords(walk.missing_records));- }- if let Some((entity, field)) = walk.miss {- return Ok(ReadOutcome::Miss { entity, field });+/// A response under construction. Only absent record branches are suspended;+/// completed fields and list positions survive storage hydration rounds.+/// The source must remain an immutable logical snapshot until completion.+pub(crate) struct ReadSession<'a> {+ data: Json,+ pending: Vec<PendingRecord<'a>>,+ miss: Option<(EntityKey<'static>, String)>,+}++#[derive(Clone, PartialEq, Eq)]+enum ResponsePath<'a> {+ Field(&'a str),+ Index(usize),+}++struct PendingRecord<'a> {+ key: EntityKey<'static>,+ type_name: &'a str,+ selections: &'a [Selection],+ // An overwritten duplicate field still contributes dependencies and misses,+ // but must never replace the later field's output when it finishes.+ destination: Option<Vec<ResponsePath<'a>>>,+}++impl<'a> ReadSession<'a> {+ pub(crate) fn new(+ key: &EntityKey<'static>,+ type_name: &'a str,+ selections: &'a [Selection],+ ) -> Self {+ Self {+ data: Json::Null,+ pending: vec![PendingRecord {+ key: key.clone(),+ type_name,+ selections,+ destination: Some(Vec::new()),+ }],+ miss: None,+ }}- match data {- Some(json) => Ok(ReadOutcome::Complete(json)),- None => Ok(ReadOutcome::Miss {- entity: key.clone(),- field: "(record)".to_string(),- }),++ pub(crate) fn resume(+ &mut self,+ variables: &serde_json::Map<String, Json>,+ source: &impl RecordSource,+ deps: &mut impl DependencyTracker,+ entity_resolvers: &EntityResolverLookup,+ plans: &mut ReadPlans<'a>,+ ) -> Result<ReadOutcome, DenormalizeError> {+ for pending in std::mem::take(&mut self.pending) {+ let retain_output = pending.destination.is_some();+ let mut walk = Walk {+ variables,+ source,+ deps,+ entity_resolvers,+ plans,+ pending: &mut self.pending,+ miss: &mut self.miss,+ path: pending.destination.unwrap_or_default(),+ retain_output,+ };+ let data = walk.read_record(&pending.key, pending.type_name, pending.selections)?;+ if retain_output {+ let mut slot = &mut self.data;+ for segment in walk.path {+ slot = match segment {+ ResponsePath::Field(field) => slot.get_mut(field),+ ResponsePath::Index(index) => slot.get_mut(index),+ }+ .expect("suspended response slot remains present");+ }+ *slot = data;+ }+ }+ if !self.pending.is_empty() {+ return Ok(ReadOutcome::NeedRecords(+ self.pending+ .iter()+ .map(|pending| pending.key.clone())+ .collect(),+ ));+ }+ if let Some((entity, field)) = self.miss.take() {+ return Ok(ReadOutcome::Miss { entity, field });+ }+ Ok(ReadOutcome::Complete(self.data.take()))}}-struct Walk<'a, S: RecordSource, D: DependencyTracker> {+struct Walk<'a, 'document, S: RecordSource, D: DependencyTracker> {variables: &'a serde_json::Map<String, Json>,source: &'a S,deps: &'a mut D,entity_resolvers: &'a EntityResolverLookup,- missing_records: BTreeSet<EntityKey<'static>>,- /// First field-level miss encountered.- miss: Option<(EntityKey<'static>, String)>,+ plans: &'a mut ReadPlans<'document>,+ pending: &'a mut Vec<PendingRecord<'document>>,+ miss: &'a mut Option<(EntityKey<'static>, String)>,+ path: Vec<ResponsePath<'document>>,+ retain_output: bool,}-impl<'a, S: RecordSource, D: DependencyTracker> Walk<'a, S, D> {- /// Reads a full record by key. Returns `None` when the outcome is- /// already determined to be incomplete (missing record / miss noted).+impl<'document, S: RecordSource, D: DependencyTracker> Walk<'_, 'document, S, D> {fn read_record(&mut self,key: &EntityKey<'static>,- type_name: &str,- selections: &[Selection],- ) -> Result<Option<Json>, DenormalizeError> {+ type_name: &'document str,+ selections: &'document [Selection],+ ) -> Result<Json, DenormalizeError> {self.deps.record(key);let Some(record) = self.source.get(key) else {- self.missing_records.insert(key.clone());- return Ok(None);+ self.pending.push(PendingRecord {+ key: key.clone(),+ type_name,+ selections,+ destination: self.retain_output.then(|| self.path.clone()),+ });+ return Ok(Json::Null);};- // Clone is cheap relative to the walk; keeps borrows simple.- let record = record.clone();- let concrete = record.typename().unwrap_or(type_name).to_string();- self.deps.field(key, &concrete, "__typename");- self.read_fields(key, &record.fields, &concrete, selections)+ let concrete = record.typename().unwrap_or(type_name);+ self.deps.field(key, concrete, "__typename");+ self.read_fields(key, &record.fields, concrete, selections)}- /// Reads selected fields out of a record's or embedded object's map.fn read_fields(&mut self,owner: &EntityKey<'static>,fields: &std::collections::BTreeMap<String, CacheValue>,concrete: &str,- selections: &[Selection],- ) -> Result<Option<Json>, DenormalizeError> {- let mut field_nodes = Vec::new();- collect_fields(selections, concrete, &mut field_nodes);-+ selections: &'document [Selection],+ ) -> Result<Json, DenormalizeError> {+ let fields_plan =+ self.plans+ .fields(selections, concrete, self.variables, self.entity_resolvers)?;+ let pending_start = self.pending.len();let mut out = serde_json::Map::new();- for f in field_nodes {- if f.name == "__typename" {- out.insert(f.response_key.clone(), Json::String(concrete.to_string()));- continue;- }- // Validate the field exists in the schema (drift protection).- let fmeta = meta::field_meta(concrete, &f.name).ok_or_else(|| {- DenormalizeError::UnknownField {- type_name: concrete.to_string(),- field: f.name.clone(),- }- })?;- let entity_resolver = self.entity_resolvers.get(concrete, &f.name);- let arguments = match resolve_args(f, self.variables) {- Ok(arguments) => arguments,- Err(_) if entity_resolver.is_some() => {- self.mark_miss(owner, f.name.clone());- continue;- }- Err(error) => return Err(error.into()),- };- let args_key = resolved_args_key(f, &arguments);- let storage_key = field_key(&f.name, args_key.as_deref());- self.deps.field(owner, concrete, &storage_key);-- if let Some(entity_resolver) = entity_resolver {- let Some(target_key) = entity_resolver.entity_key(&arguments) else {- self.mark_miss(owner, storage_key);- continue;- };- let json =- self.read_record(&target_key, &entity_resolver.target_type, &f.selection_set)?;- if let Some(json) = json {- out.insert(f.response_key.clone(), json);+ for planned_field in fields_plan.iter() {+ let field = planned_field.node;+ self.path.push(ResponsePath::Field(&field.response_key));+ if self.pending.len() > pending_start && out.contains_key(&field.response_key) {+ for pending in &mut self.pending[pending_start..] {+ if pending+ .destination+ .as_ref()+ .is_some_and(|path| path.starts_with(&self.path))+ {+ pending.destination = None;+ }}- continue;}+ let value = self.read_field(owner, fields, concrete, planned_field)?;+ self.path.pop();+ if let Some(value) = value {+ out.insert(field.response_key.clone(), value);+ }+ }+ Ok(Json::Object(out))+ }- let Some(value) = fields.get(&storage_key) else {- self.mark_miss(owner, storage_key);- continue;- };- let json = self.read_value(owner, f, fmeta.ty.name, value)?;- match json {- Some(j) => {- out.insert(f.response_key.clone(), j);- }- None => continue, // incomplete subtree already noted+ fn read_field(+ &mut self,+ owner: &EntityKey<'static>,+ fields: &std::collections::BTreeMap<String, CacheValue>,+ concrete: &str,+ field: &Field<'document>,+ ) -> Result<Option<Json>, DenormalizeError> {+ match &field.source {+ FieldSource::Typename => Ok(Some(Json::String(concrete.to_owned()))),+ FieldSource::MissingArguments => {+ self.mark_miss(owner, field.node.name.clone());+ Ok(None)+ }+ FieldSource::Missing(key) => {+ self.deps.field(owner, concrete, key);+ self.mark_miss(owner, key.to_string());+ Ok(None)+ }+ FieldSource::Entity {+ key,+ type_name,+ storage_key,+ } => {+ self.deps.field(owner, concrete, storage_key);+ self.read_record(key, type_name, &field.node.selection_set)+ .map(Some)+ }+ FieldSource::Stored { key, type_name } => {+ self.deps.field(owner, concrete, key);+ let Some(value) = fields.get(key.as_ref()) else {+ self.mark_miss(owner, key.to_string());+ return Ok(None);+ };+ self.read_value(owner, field.node, type_name, value)+ .map(Some)}}- Ok(Some(Json::Object(out)))}fn mark_miss(&mut self, owner: &EntityKey<'static>, field: String) {if self.miss.is_none() {- self.miss = Some((owner.clone(), field));+ *self.miss = Some((owner.clone(), field));}}fn read_value(&mut self,owner: &EntityKey<'static>,- field: &FieldNode,- named_type: &str,+ field: &'document FieldNode,+ named_type: &'static str,value: &CacheValue,- ) -> Result<Option<Json>, DenormalizeError> {+ ) -> Result<Json, DenormalizeError> {Ok(match value {- CacheValue::Null => Some(Json::Null),- CacheValue::Bool(b) => Some(Json::Bool(*b)),- CacheValue::Number(n) => Some(Json::Number(n.to_json())),- CacheValue::String(s) => Some(Json::String(s.clone())),- CacheValue::Opaque(j) => {- Some(- serde_json::from_str(j).map_err(|_| DenormalizeError::Shape {- type_name: named_type.to_string(),- field: field.name.clone(),- })?,- )+ CacheValue::Null => Json::Null,+ CacheValue::Bool(value) => Json::Bool(*value),+ CacheValue::Number(value) => Json::Number(value.to_json()),+ CacheValue::String(value) => Json::String(value.clone()),+ CacheValue::Opaque(value) => {+ serde_json::from_str(value).map_err(|_| DenormalizeError::Shape {+ type_name: named_type.to_string(),+ field: field.name.clone(),+ })?}CacheValue::List(items) => {let mut out = Vec::with_capacity(items.len());- let mut complete = true;- for item in items {- match self.read_value(owner, field, named_type, item)? {- Some(j) => out.push(j),- None => complete = false,- }- }- if complete {- Some(Json::Array(out))- } else {- None+ for (index, item) in items.iter().enumerate() {+ self.path.push(ResponsePath::Index(index));+ out.push(self.read_value(owner, field, named_type, item)?);+ self.path.pop();}+ Json::Array(out)}CacheValue::Ref(key) => self.read_record(key, named_type, &field.selection_set)?,CacheValue::Object(map) => {let concrete = match map.get("__typename") {- Some(CacheValue::String(t)) => t.clone(),- _ => named_type.to_string(),+ Some(CacheValue::String(typename)) => typename.as_str(),+ _ => named_type,};- self.read_fields(owner, map, &concrete, &field.selection_set)?+ self.read_fields(owner, map, concrete, &field.selection_set)?}})}@@ -322,3 +406,6 @@ fn collect_fields<'a>(}}}++#[cfg(test)]+mod test;diff --git a/crates/client/cache-core/src/denormalize/plan.rs b/crates/client/cache-core/src/denormalize/plan.rsnew file mode 100644index 0000000000..957df548ba--- /dev/null+++ b/crates/client/cache-core/src/denormalize/plan.rs@@ -0,0 +1,114 @@+//! Resolve schema fields, arguments and entity links once per selection/type+//! during a read, instead of once for every entity in a large result list.++use super::*;+use std::collections::HashMap;+use std::sync::Arc;++pub(super) struct Field<'a> {+ pub node: &'a FieldNode,+ pub source: FieldSource<'a>,+}++pub(super) enum FieldSource<'a> {+ Typename,+ MissingArguments,+ Missing(Cow<'a, str>),+ Stored {+ key: Cow<'a, str>,+ type_name: &'static str,+ },+ Entity {+ key: EntityKey<'static>,+ type_name: &'static str,+ storage_key: Cow<'a, str>,+ },+}++type FieldsByConcreteType<'a> = HashMap<String, Arc<[Field<'a>]>>;++/// Read-local plans. Variables and resolver policy must stay fixed, and the+/// borrowed selection trees must remain alive for this entire read.+#[derive(Default)]+pub(crate) struct ReadPlans<'a> {+ // The address identifies an immutable borrowed AST slice, not its content.+ // Length distinguishes subslices; empty slices share equivalent empty plans.+ selections: HashMap<(usize, usize), FieldsByConcreteType<'a>>,+}++impl<'a> ReadPlans<'a> {+ pub(super) fn fields(+ &mut self,+ selections: &'a [Selection],+ concrete: &str,+ variables: &serde_json::Map<String, Json>,+ entity_resolvers: &EntityResolverLookup,+ ) -> Result<Arc<[Field<'a>]>, DenormalizeError> {+ let types = self+ .selections+ .entry((selections.as_ptr() as usize, selections.len()))+ .or_default();+ if let Some(fields) = types.get(concrete) {+ return Ok(Arc::clone(fields));+ }+ let mut nodes = Vec::new();+ collect_fields(selections, concrete, &mut nodes);+ let fields = nodes+ .into_iter()+ .map(|node| compile_field(node, concrete, variables, entity_resolvers))+ .collect::<Result<Arc<[_]>, _>>()?;+ types.insert(concrete.to_owned(), Arc::clone(&fields));+ Ok(fields)+ }+}++fn compile_field<'a>(+ node: &'a FieldNode,+ concrete: &str,+ variables: &serde_json::Map<String, Json>,+ entity_resolvers: &EntityResolverLookup,+) -> Result<Field<'a>, DenormalizeError> {+ if node.name == "__typename" {+ return Ok(Field {+ node,+ source: FieldSource::Typename,+ });+ }+ let metadata =+ meta::field_meta(concrete, &node.name).ok_or_else(|| DenormalizeError::UnknownField {+ type_name: concrete.to_owned(),+ field: node.name.clone(),+ })?;+ let resolver = entity_resolvers.get(concrete, &node.name);+ let arguments = match resolve_args(node, variables) {+ Ok(arguments) => arguments,+ Err(_) if resolver.is_some() => {+ return Ok(Field {+ node,+ source: FieldSource::MissingArguments,+ });+ }+ Err(error) => return Err(error.into()),+ };+ let storage_key = match resolved_args_key(node, &arguments) {+ Some(args) => Cow::Owned(field_key(&node.name, Some(&args))),+ None => Cow::Borrowed(node.name.as_str()),+ };+ let source = match resolver {+ Some(resolver) => match resolver.entity_key(&arguments) {+ Some(key) => FieldSource::Entity {+ key,+ storage_key,+ type_name: meta::type_meta(&resolver.target_type)+ .expect("compiled resolver target exists")+ .name,+ },+ None => FieldSource::Missing(storage_key),+ },+ None => FieldSource::Stored {+ key: storage_key,+ type_name: metadata.ty.name,+ },+ };+ Ok(Field { node, source })+}diff --git a/crates/client/cache-core/src/denormalize/test.rs b/crates/client/cache-core/src/denormalize/test.rsnew file mode 100644index 0000000000..02bc9c8a71--- /dev/null+++ b/crates/client/cache-core/src/denormalize/test.rs@@ -0,0 +1,275 @@+use super::*;+use crate::deps::QueryDependencies;+use crate::document::Document;+use crate::record_selection::RecordSelection;+use std::cell::RefCell;+use std::collections::BTreeMap;++#[derive(Default)]+struct CountingSource {+ records: BTreeMap<EntityKey<'static>, Record>,+ reads: RefCell<BTreeMap<EntityKey<'static>, usize>>,+}++impl RecordSource for CountingSource {+ fn get(&self, key: &EntityKey<'static>) -> Option<&Record> {+ *self.reads.borrow_mut().entry(key.clone()).or_default() += 1;+ self.records.get(key)+ }+}++fn key(id: &str) -> EntityKey<'static> {+ EntityKey(format!("GraphqlSoupEmailMessage:{id}").into())+}++fn message(id: &str) -> Record {+ Record {+ fields: [+ ("id".into(), CacheValue::String(id.into())),+ (+ "subject".into(),+ CacheValue::String(format!("Subject {id}")),+ ),+ ]+ .into(),+ }+}++fn thread() -> (EntityKey<'static>, Record) {+ (+ EntityKey("GraphqlSoupEmailThread:thread".into()),+ Record {+ fields: [+ ("id".into(), CacheValue::String("thread".into())),+ (+ "messages".into(),+ CacheValue::List(vec![+ CacheValue::Ref(key("hot")),+ CacheValue::Null,+ CacheValue::Ref(key("cold")),+ CacheValue::Ref(key("hot")),+ ]),+ ),+ ]+ .into(),+ },+ )+}++#[test]+fn resumes_only_missing_branches_preserving_aliases_nulls_order_and_dependencies() {+ let selection = RecordSelection::parse(+ "fragment Thread on GraphqlSoupEmailThread { id first: messages { id subject } second: messages { id } }",+ "Thread",+ ).unwrap();+ let (thread_key, thread) = thread();+ let mut session = ReadSession::new(+ &thread_key,+ "GraphqlSoupEmailThread",+ selection.selection_set(),+ );+ let mut source = CountingSource::default();+ let mut deps = BTreeSet::new();+ let variables = serde_json::Map::new();+ let resolvers = EntityResolverLookup::default();+ let mut plans = ReadPlans::default();+ let first = session+ .resume(&variables, &source, &mut deps, &resolvers, &mut plans)+ .unwrap();+ assert!(matches!(first, ReadOutcome::NeedRecords(keys) if keys == [thread_key.clone()].into()));+ source.records.insert(thread_key.clone(), thread);+ source.records.insert(key("hot"), message("hot"));+ let second = session+ .resume(&variables, &source, &mut deps, &resolvers, &mut plans)+ .unwrap();+ assert!(matches!(second, ReadOutcome::NeedRecords(keys) if keys == [key("cold")].into()));+ let completed_reads = source.reads.borrow().clone();+ source.records.insert(key("cold"), message("cold"));+ let ReadOutcome::Complete(data) = session+ .resume(&variables, &source, &mut deps, &resolvers, &mut plans)+ .unwrap()+ else {+ panic!("all selected records are present");+ };+ assert_eq!(+ data,+ serde_json::json!({"id": "thread", "first": [+ {"id": "hot", "subject": "Subject hot"}, null,+ {"id": "cold", "subject": "Subject cold"}, {"id": "hot", "subject": "Subject hot"},+ ], "second": [{"id": "hot"}, null, {"id": "cold"}, {"id": "hot"}]})+ );+ assert_eq!(+ source.reads.borrow()[&key("hot")],+ completed_reads[&key("hot")]+ );+ assert_eq!(+ source.reads.borrow()[&thread_key],+ completed_reads[&thread_key]+ );+ assert_eq!(deps, [thread_key, key("hot"), key("cold")].into());+}++#[test]+fn overwritten_duplicate_selection_cannot_patch_later_output() {+ let selection = RecordSelection::parse(+ "fragment Thread on GraphqlSoupEmailThread { messages { id subject } ... on GraphqlSoupEmailThread { messages { id } } }",+ "Thread",+ ).unwrap();+ let (thread_key, thread) = thread();+ let mut session = ReadSession::new(+ &thread_key,+ "GraphqlSoupEmailThread",+ selection.selection_set(),+ );+ let mut source = CountingSource::default();+ source.records.insert(thread_key.clone(), thread);+ source.records.insert(key("hot"), message("hot"));+ let mut deps = BTreeSet::new();+ let variables = serde_json::Map::new();+ let resolvers = EntityResolverLookup::default();+ let mut plans = ReadPlans::default();+ assert!(matches!(+ session+ .resume(&variables, &source, &mut deps, &resolvers, &mut plans)+ .unwrap(),+ ReadOutcome::NeedRecords(_)+ ));+ source.records.insert(key("cold"), message("cold"));+ let ReadOutcome::Complete(data) = session+ .resume(&variables, &source, &mut deps, &resolvers, &mut plans)+ .unwrap()+ else {+ panic!("all selected records are present");+ };+ let ReadOutcome::Complete(expected) = denormalize_record(+ &thread_key,+ "GraphqlSoupEmailThread",+ selection.selection_set(),+ &variables,+ &source,+ &mut BTreeSet::new(),+ )+ .unwrap() else {+ panic!("fully resident read completes");+ };+ assert_eq!(data, expected);+ assert_eq!(data["messages"][2], serde_json::json!({"id": "cold"}));+ assert!(deps.contains(&key("cold")));+}++#[test]+fn a_field_miss_survives_later_record_hydration() {+ let selection = RecordSelection::parse(+ "fragment Thread on GraphqlSoupEmailThread { id messages { id subject } }",+ "Thread",+ )+ .unwrap();+ let (thread_key, mut thread) = thread();+ thread.fields.remove("id");+ let mut source = CountingSource::default();+ source.records.insert(thread_key.clone(), thread);+ let mut session = ReadSession::new(+ &thread_key,+ "GraphqlSoupEmailThread",+ selection.selection_set(),+ );+ let mut deps = BTreeSet::new();+ let variables = serde_json::Map::new();+ let resolvers = EntityResolverLookup::default();+ let mut plans = ReadPlans::default();+ assert!(matches!(+ session+ .resume(&variables, &source, &mut deps, &resolvers, &mut plans)+ .unwrap(),+ ReadOutcome::NeedRecords(_)+ ));+ source.records.insert(key("hot"), message("hot"));+ source.records.insert(key("cold"), message("cold"));+ assert!(+ matches!(session.resume(&variables, &source, &mut deps, &resolvers, &mut plans).unwrap(), ReadOutcome::Miss { entity, field } if entity == thread_key && field == "id")+ );+ assert_eq!(deps, [thread_key, key("hot"), key("cold")].into());+}++#[test]+fn resumed_reads_retain_argument_qualified_viewer_fields() {+ let document = Document::parse(+ "query Page { user { id page: soup(input: {initial: {limit: 1}}) { items { __typename id } } } }",+ ).unwrap();+ let operation = document.operation(Some("Page")).unwrap();+ let root = EntityKey::root();+ let viewer = EntityKey("GraphqlUser:viewer".into());+ let item = EntityKey("GraphqlSoupDocument:item".into());+ let page_key = field_key("soup", Some(r#"{"input":{"initial":{"limit":1}}}"#));+ let mut source = CountingSource::default();+ source.records.insert(+ root.clone(),+ Record {+ fields: [("user".into(), CacheValue::Ref(viewer.clone()))].into(),+ },+ );+ let mut session = ReadSession::new(&root, meta::QUERY_ROOT_TYPE, &operation.selection_set);+ let mut deps = QueryDependencies::default();+ let mut plans = ReadPlans::default();+ let variables = serde_json::Map::new();+ let resolvers = EntityResolverLookup::default();+ assert!(matches!(+ session.resume(&variables, &source, &mut deps, &resolvers, &mut plans).unwrap(),+ ReadOutcome::NeedRecords(keys) if keys == [viewer.clone()].into()+ ));+ source.records.insert(+ viewer.clone(),+ Record {+ fields: [+ ("id".into(), CacheValue::String("viewer".into())),+ (+ page_key.clone(),+ CacheValue::Object(+ [(+ "items".into(),+ CacheValue::List(vec![CacheValue::Ref(item.clone())]),+ )]+ .into(),+ ),+ ),+ ]+ .into(),+ },+ );+ assert!(matches!(+ session.resume(&variables, &source, &mut deps, &resolvers, &mut plans).unwrap(),+ ReadOutcome::NeedRecords(keys) if keys == [item.clone()].into()+ ));+ let viewer_reads = source.reads.borrow()[&viewer];+ source.records.insert(+ item.clone(),+ Record {+ fields: [+ (+ "__typename".into(),+ CacheValue::String("GraphqlSoupDocument".into()),+ ),+ ("id".into(), CacheValue::String("item".into())),+ ]+ .into(),+ },+ );+ let ReadOutcome::Complete(data) = session+ .resume(&variables, &source, &mut deps, &resolvers, &mut plans)+ .unwrap()+ else {+ panic!("hydrated query completes")+ };+ assert_eq!(+ data,+ serde_json::json!({"user": {"id": "viewer", "page": {"items": [+ {"__typename": "GraphqlSoupDocument", "id": "item"}+ ]}}})+ );+ assert_eq!(source.reads.borrow()[&viewer], viewer_reads);+ assert_eq!(+ deps.viewer_fields[&viewer],+ ["__typename".into(), "id".into(), page_key].into()+ );+ assert_eq!(deps.records, [root, viewer, item].into());+}diff --git a/crates/client/cache-core/src/deps.rs b/crates/client/cache-core/src/deps.rsindex e3ddd45bac..7a0823755c 100644--- a/crates/client/cache-core/src/deps.rs+++ b/crates/client/cache-core/src/deps.rs@@ -30,6 +30,12 @@ impl DepIndex {/// Replaces the dependency set of an active operation.pub fn set_op_deps(&mut self, op: OpId, deps: BTreeSet<EntityKey<'static>>) {+ // A record-only registration must discard any prior field-level proof,+ // even when its record set is unchanged.+ self.viewer_fields.remove(&op);+ if !self.broad_ops.contains(&op) && self.by_op.get(&op) == Some(&deps) {+ return;+ }self.remove_op(op);for key in &deps {self.by_key.entry(key.clone()).or_default().insert(op);@@ -131,47 +137,4 @@ impl DepIndex {}#[cfg(test)]-mod tests {- use super::*;-- fn key(s: &str) -> EntityKey<'static> {- EntityKey(s.to_owned().into())- }-- #[test]- fn tracks_and_removes() {- let mut idx = DepIndex::new();- idx.set_op_deps(1, [key("A"), key("B")].into());- idx.set_op_deps(2, [key("B"), key("C")].into());-- assert_eq!(idx.ops_for_keys(&[key("A")]), [1].into());- assert_eq!(idx.ops_for_keys(&[key("B")]), [1, 2].into());- assert_eq!(idx.ops_for_keys(&[key("C"), key("A")]), [1, 2].into());-- // Re-registration replaces deps.- idx.set_op_deps(1, [key("C")].into());- assert!(idx.ops_for_keys(&[key("A")]).is_empty());-- idx.remove_op(1);- idx.remove_op(2);- assert_eq!(idx.active_ops(), 0);- assert!(idx.ops_for_keys(&[key("B"), key("C")]).is_empty());- }-- #[test]- fn broad_registration_is_replaced_and_removed() {- let mut idx = DepIndex::new();- idx.set_op_broad(1);- assert_eq!(idx.ops_for_keys(&[key("anything")]), [1].into());- assert!(idx.ops_for_keys(std::iter::empty()).is_empty());-- idx.set_op_deps(1, [key("A")].into());- assert!(idx.ops_for_keys(&[key("B")]).is_empty());- assert_eq!(idx.ops_for_keys(&[key("A")]), [1].into());-- idx.set_op_broad(1);- idx.remove_op(1);- assert!(idx.ops_for_keys(&[key("A")]).is_empty());- assert_eq!(idx.active_ops(), 0);- }-}+mod test;diff --git a/crates/client/cache-core/src/deps/test.rs b/crates/client/cache-core/src/deps/test.rsnew file mode 100644index 0000000000..1cd0c820c9--- /dev/null+++ b/crates/client/cache-core/src/deps/test.rs@@ -0,0 +1,106 @@+use super::*;++fn key(s: &str) -> EntityKey<'static> {+ EntityKey(s.to_owned().into())+}++#[test]+fn unchanged_records_replace_field_proof_and_allow_record_only_registration() {+ let viewer = key("GraphqlUser:viewer");+ let records: BTreeSet<_> = [viewer.clone()].into();+ let mut index = DepIndex::new();+ let changes = |field: &str| [(viewer.clone(), [field.to_owned()].into())].into();+ for field in ["soup(a)", "soup(b)"] {+ index.set_query_deps(+ 1,+ QueryDependencies {+ records: records.clone(),+ viewer_fields: changes(field),+ },+ );+ assert_eq!(index.ops_for_changes(&records, &changes(field)), [1].into());+ }+ assert!(+ index+ .ops_for_changes(&records, &changes("soup(a)"))+ .is_empty()+ );+ index.set_op_deps(1, records.clone());+ assert_eq!(+ index.ops_for_changes(&records, &changes("soup(a)")),+ [1].into()+ );+ index.remove_op(1);+ assert!(+ index+ .ops_for_changes(&records, &changes("soup(a)"))+ .is_empty()+ );+}++#[test]+fn tracks_and_removes() {+ let mut idx = DepIndex::new();+ idx.set_op_deps(1, [key("A"), key("B")].into());+ idx.set_op_deps(2, [key("B"), key("C")].into());++ assert_eq!(idx.ops_for_keys(&[key("A")]), [1].into());+ assert_eq!(idx.ops_for_keys(&[key("B")]), [1, 2].into());+ assert_eq!(idx.ops_for_keys(&[key("C"), key("A")]), [1, 2].into());++ // Re-registration replaces deps.+ idx.set_op_deps(1, [key("C")].into());+ assert!(idx.ops_for_keys(&[key("A")]).is_empty());++ idx.remove_op(1);+ idx.remove_op(2);+ assert_eq!(idx.active_ops(), 0);+ assert!(idx.ops_for_keys(&[key("B"), key("C")]).is_empty());+}++#[test]+fn broad_registration_is_replaced_and_removed() {+ let mut idx = DepIndex::new();+ idx.set_op_broad(1);+ assert_eq!(idx.ops_for_keys(&[key("anything")]), [1].into());+ assert!(idx.ops_for_keys(std::iter::empty()).is_empty());++ idx.set_op_deps(1, [key("A")].into());+ assert!(idx.ops_for_keys(&[key("B")]).is_empty());+ assert_eq!(idx.ops_for_keys(&[key("A")]), [1].into());++ idx.set_op_broad(1);+ idx.remove_op(1);+ assert!(idx.ops_for_keys(&[key("A")]).is_empty());+ assert_eq!(idx.active_ops(), 0);+}++#[test]+fn repeated_registration_preserves_shared_dependencies_and_teardown() {+ let mut index = DepIndex::new();+ let deps: BTreeSet<_> = [key("A"), key("B")].into();+ index.set_op_deps(1, deps.clone());+ index.set_op_deps(2, [key("B")].into());+ for _ in 0..3 {+ index.set_op_deps(1, deps.clone());+ }+ assert_eq!(index.ops_for_keys(&[key("B")]), [1, 2].into());+ index.set_op_deps(1, [key("C")].into());+ assert!(index.ops_for_keys(&[key("A")]).is_empty());+ assert_eq!(index.ops_for_keys(&[key("B")]), [2].into());+ index.remove_op(1);+ assert!(index.ops_for_keys(&[key("C")]).is_empty());+ assert_eq!(index.active_ops(), 1);+}++#[test]+fn broad_empty_registration_becomes_exact_empty() {+ let mut index = DepIndex::new();+ index.set_op_broad(1);+ index.set_op_deps(1, BTreeSet::new());+ index.set_op_deps(1, BTreeSet::new());+ assert!(index.ops_for_keys(&[key("A")]).is_empty());+ assert_eq!(index.active_ops(), 1);+ index.remove_op(1);+ assert_eq!(index.active_ops(), 0);+}diff --git a/crates/client/cache-core/src/deps/viewer.rs b/crates/client/cache-core/src/deps/viewer.rsindex 3a9fcb5384..bd21935fde 100644--- a/crates/client/cache-core/src/deps/viewer.rs+++ b/crates/client/cache-core/src/deps/viewer.rs@@ -31,13 +31,6 @@ pub(crate) struct QueryDependencies {pub viewer_fields: ViewerFields,}-impl QueryDependencies {- pub fn clear(&mut self) {- self.records.clear();- self.viewer_fields.clear();- }-}-impl DependencyTracker for QueryDependencies {fn record(&mut self, key: &EntityKey<'static>) {self.records.insert(key.clone());diff --git a/crates/client/cache-core/src/engine.rs b/crates/client/cache-core/src/engine.rsindex f11093fbce..eb40715c9f 100644--- a/crates/client/cache-core/src/engine.rs+++ b/crates/client/cache-core/src/engine.rs@@ -5,10 +5,7 @@#[cfg(test)]mod test;-use crate::denormalize::{- DenormalizeError, ReadOutcome, RecordSource, denormalize_record,- denormalize_with_entity_resolvers,-};+use crate::denormalize::{DenormalizeError, ReadOutcome, ReadPlans, ReadSession, RecordSource};use crate::deps::{DepIndex, OpId, QueryDependencies, ViewerFieldUpdate, ViewerFields, changed_viewer_fields,};@@ -312,11 +309,15 @@ enum IdentityState {/// hardening-phase refinement).pub const DEFAULT_HOT_CAPACITY: usize = 10_000;+// Parsed plans contain no cached user data. Bound dynamic document churn while+// leaving room for the production operation catalog and fragment variants.+const DOCUMENT_CACHE_CAPACITY: usize = 128;+pub struct Engine<S: Storage> {storage: S,revision: CacheRevision,hot: LruCache<EntityKey<'static>, Record>,- docs: HashMap<String, Document>,+ docs: LruCache<String, Document>,deps: DepIndex,identity: IdentityState,/// Ordered optimistic mutation layers hydrated from durable storage.@@ -337,7 +338,7 @@ impl<S: Storage> Engine<S> {storage,revision: CacheRevision::ZERO,hot: LruCache::new(NonZeroUsize::new(hot_capacity).expect("capacity > 0")),- docs: HashMap::new(),+ docs: LruCache::new(NonZeroUsize::new(DOCUMENT_CACHE_CAPACITY).unwrap()),deps: DepIndex::new(),identity: IdentityState::NotHydrated,optimistic: Vec::new(),@@ -649,20 +650,19 @@ impl<S: Storage> Engine<S> {let mut known_absent: BTreeSet<EntityKey<'static>> = BTreeSet::new();let mut deps = QueryDependencies::default();+ let mut plans = ReadPlans::default();+ let mut session = ReadSession::new(+ &EntityKey::root(),+ crate::meta::QUERY_ROOT_TYPE,+ &op.selection_set,+ );let outcome = loop {- deps.clear();let source = EngineSource {hot: &self.hot,fetched: &fetched_base,composed: &composed,};- match denormalize_with_entity_resolvers(- op,- variables,- &source,- &mut deps,- &entity_resolvers,- )? {+ match session.resume(variables, &source, &mut deps, &entity_resolvers, &mut plans)? {ReadOutcome::Complete(data) => break ReadResult::Hit { data },ReadOutcome::Miss { .. } => break ReadResult::Miss,ReadOutcome::NeedRecords(missing) => {@@ -707,14 +707,13 @@ impl<S: Storage> Engine<S> {}};- // Promote durable records into the hot tier and refresh recency of- // everything this operation touched.- for (key, record) in fetched_base {- self.hot.put(key, record);- }+ // Refresh borrowed hot records before cold promotions can evict them.for key in &deps.records {let _ = self.hot.get(key);}+ for (key, record) in fetched_base {+ self.hot.put(key, record);+ }if let Some(op_id) = op_id {self.deps.set_query_deps(op_id, deps);}@@ -766,28 +765,13 @@ impl<S: Storage> Engine<S> {}).cloned().collect();- let key_set: BTreeSet<_> = ordered_keys.iter().cloned().collect();- let mut bases = self.load_bases(&key_set).await?;- let candidates = ordered_keys- .iter()- .cloned()- .map(|key| {- let record = bases.remove(&key);- (key, record)- })- .collect();let optimistic = merged_optimistic(&self.optimistic);let projected = self- .project_record_batch(selection, candidates, &optimistic)+ .project_record_batch(selection, &ordered_keys, &optimistic).await?;- let mut projected: HashMap<_, _> = projected.into_iter().collect();- let records = ordered_keys+ let records = projected.into_iter()- .filter_map(|record_key| {- projected- .remove(&record_key)- .map(|record| SelectedRecord { record_key, record })- })+ .map(|(record_key, record)| SelectedRecord { record_key, record }).collect();Ok(self.revisioned(records))}@@ -795,34 +779,39 @@ impl<S: Storage> Engine<S> {async fn project_record_batch(&mut self,selection: &RecordSelection,- candidates: BTreeMap<EntityKey<'static>, Option<Record>>,+ candidate_keys: &[EntityKey<'static>],optimistic: &BTreeMap<EntityKey<'static>, Record>,) -> Result<Vec<(EntityKey<'static>, Json)>, EngineError<S::Error>> {- let candidate_keys: Vec<_> = candidates.keys().cloned().collect();- let optimistic_only_candidates: BTreeSet<_> = candidates- .iter()- .filter_map(|(key, record)| record.is_none().then_some(key.clone()))- .collect();- let mut fetched_base: HashMap<_, _> = candidates- .into_iter()- .filter_map(|(key, record)| record.map(|record| (key, record)))- .collect();+ // Borrow hot bases through EngineSource, just like ordinary query reads.+ // Only cold records and optimistic compositions need owned snapshots.+ let mut fetched_base = HashMap::new();let mut composed = HashMap::new();for (key, update) in optimistic {- let base = fetched_base.get(key).or_else(|| self.hot.peek(key));- if let Some(base) = base {+ if let Some(base) = self.hot.peek(key) {let mut effective = base.clone();effective.merge(update.clone());composed.insert(key.clone(), effective);- } else if optimistic_only_candidates.contains(key) {- composed.insert(key.clone(), update.clone());}}let variables = serde_json::Map::new();- let mut pending: BTreeSet<_> = candidate_keys.iter().cloned().collect();+ let mut pending: BTreeMap<_, _> = candidate_keys+ .iter()+ .map(|key| {+ (+ key.clone(),+ ReadSession::new(+ key,+ record_key_type(key).unwrap_or_default(),+ selection.selection_set(),+ ),+ )+ })+ .collect();+ let mut plans = ReadPlans::default();let mut completed = BTreeMap::new();let mut known_absent = BTreeSet::new();+ let mut dependencies = BTreeSet::new();while !pending.is_empty() {let mut missing = BTreeSet::new();let source = EngineSource {@@ -830,17 +819,14 @@ impl<S: Storage> Engine<S> {fetched: &fetched_base,composed: &composed,};- let current: Vec<_> = pending.iter().cloned().collect();+ let current: Vec<_> = pending.keys().cloned().collect();for key in current {- let type_name = record_key_type(&key).unwrap_or_default();- let mut dependencies = BTreeSet::new();- match denormalize_record(- &key,- type_name,- selection.selection_set(),+ match pending.get_mut(&key).expect("pending record").resume(&variables,&source,&mut dependencies,+ &EntityResolverLookup::default(),+ &mut plans,)? {ReadOutcome::Complete(record) => {pending.remove(&key);@@ -893,12 +879,16 @@ impl<S: Storage> Engine<S> {}}+ // Keep this read's working set ahead of unrelated hot records.+ for key in &dependencies {+ let _ = self.hot.get(key);+ }for (key, record) in fetched_base {self.hot.put(key, record);}Ok(candidate_keys- .into_iter()- .filter_map(|key| completed.remove(&key).map(|record| (key, record)))+ .iter()+ .filter_map(|key| completed.remove(key).map(|record| (key.clone(), record))).collect())}@@ -2450,17 +2440,13 @@ impl<S: Storage> Engine<S> {self.storage}- /// Memoized document parse. Takes the map (not `&mut self`) so callers+ /// Memoized document parse. Takes the cache (not `&mut self`) so callers/// can keep the returned borrow while using other engine fields.fn document<'d>(- docs: &'d mut HashMap<String, Document>,+ docs: &'d mut LruCache<String, Document>,query: &str,) -> Result<&'d Document, DocumentError> {- use std::collections::hash_map::Entry;- match docs.entry(query.to_string()) {- Entry::Occupied(e) => Ok(e.into_mut()),- Entry::Vacant(e) => Ok(e.insert(Document::parse(query)?)),- }+ docs.try_get_or_insert_ref(query, || Document::parse(query))}}diff --git a/crates/client/cache-core/src/engine/test.rs b/crates/client/cache-core/src/engine/test.rsindex 6facddd13b..6118de4dfa 100644--- a/crates/client/cache-core/src/engine/test.rs+++ b/crates/client/cache-core/src/engine/test.rs@@ -4,6 +4,70 @@ use crate::store::InMemoryStorage;mod hydration_search_changes;mod query_search_changes;+#[test]+fn resolved_read_plans_do_not_leak_arguments_or_values_between_reads() {+ pollster::block_on(async {+ let query = "query Page($input: SoupInput!) { user { id soup(input: $input) { items { __typename id ... on GraphqlSoupDocument { name } } nextCursor } } }";+ let mut engine = Engine::with_capacity(InMemoryStorage::new(), 1);+ let variables = |limit| {+ serde_json::json!({"input": {"limit": limit}})+ .as_object()+ .unwrap()+ .clone()+ };+ let response = |id: &str, name: &str| {+ serde_json::json!({"user": {"id": "viewer", "soup": {+ "items": [{"__typename": "GraphqlSoupDocument", "id": id, "name": name}], "nextCursor": null+ }}})+ };+ for (limit, id, name) in [(1, "first", "First"), (2, "second", "Second")] {+ engine+ .write_query(+ None,+ query,+ Some("Page"),+ &variables(limit),+ &response(id, name),+ None,+ )+ .await+ .unwrap();+ }+ for (limit, id, name) in [+ (1, "first", "First"),+ (2, "second", "Second"),+ (1, "first", "First"),+ ] {+ let read = engine+ .read_query(Some(1), query, Some("Page"), &variables(limit))+ .await+ .unwrap();+ assert!(matches!(read, ReadResult::Hit { data } if data == response(id, name)));+ }+ engine+ .write_query(+ None,+ query,+ Some("Page"),+ &variables(1),+ &response("first", "Renamed"),+ None,+ )+ .await+ .unwrap();+ let read = engine+ .read_query(Some(1), query, Some("Page"), &variables(1))+ .await+ .unwrap();+ assert!(matches!(read, ReadResult::Hit { data } if data == response("first", "Renamed")));+ let read = engine+ .read_query(Some(1), query, Some("Page"), &variables(2))+ .await+ .unwrap();+ assert!(matches!(read, ReadResult::Hit { data } if data == response("second", "Second")));+ });+}+#[test]fn storage_generation_survives_reopening_and_preserves_existing_records() {pollster::block_on(async {@@ -146,3 +210,136 @@ fn revision_overflow_is_rejected_without_mutating_storage() {assert!(engine.storage().is_empty());});}++#[test]+fn parsed_documents_are_bounded_reused_and_errors_are_not_cached() {+ let mut engine = Engine::new(InMemoryStorage::new());+ let query = |index| format!("query Q{index} {{ user {{ id }} }}");+ for index in 0..DOCUMENT_CACHE_CAPACITY {+ Engine::<InMemoryStorage>::document(&mut engine.docs, &query(index)).unwrap();+ }+ Engine::<InMemoryStorage>::document(&mut engine.docs, &query(0)).unwrap();+ Engine::<InMemoryStorage>::document(&mut engine.docs, &query(DOCUMENT_CACHE_CAPACITY)).unwrap();+ assert_eq!(engine.docs.len(), DOCUMENT_CACHE_CAPACITY);+ assert!(engine.docs.contains(&query(0)));+ assert!(!engine.docs.contains(&query(1)));+ assert!(Engine::<InMemoryStorage>::document(&mut engine.docs, "query Broken {").is_err());+ assert_eq!(engine.docs.len(), DOCUMENT_CACHE_CAPACITY);+ let document = Engine::<InMemoryStorage>::document(&mut engine.docs, &query(1)).unwrap();+ assert!(document.operation(Some("Q1")).is_ok());+}++#[test]+fn fragment_reads_keep_hot_and_cold_linked_records_in_the_working_set() {+ use crate::value::CacheValue;+ pollster::block_on(async {+ for message_is_hot in [true, false] {+ let mut engine = Engine::with_capacity(InMemoryStorage::new(), 3);+ let message_key = EntityKey("GraphqlSoupEmailMessage:message".into());+ let thread_key = EntityKey("GraphqlSoupEmailThread:thread".into());+ let unrelated_key = EntityKey("GraphqlSoupDocument:unrelated".into());+ let message = Record {+ fields: [+ (+ "__typename".into(),+ CacheValue::String("GraphqlSoupEmailMessage".into()),+ ),+ ("id".into(), CacheValue::String("message".into())),+ ("subject".into(), CacheValue::String("Subject".into())),+ (+ "bodyText".into(),+ CacheValue::String("unselected body".repeat(4096)),+ ),+ ]+ .into(),+ };+ let thread = Record {+ fields: [+ (+ "__typename".into(),+ CacheValue::String("GraphqlSoupEmailThread".into()),+ ),+ ("id".into(), CacheValue::String("thread".into())),+ (+ crate::value::field_key("messages", Some(r#"{"limit":1,"offset":0}"#)),+ CacheValue::List(vec![CacheValue::Ref(message_key.clone())]),+ ),+ ]+ .into(),+ };+ engine+ .storage+ .put_batch(vec![(message_key.clone(), message.clone())])+ .await+ .unwrap();+ if message_is_hot {+ engine.hot.put(message_key.clone(), message);+ }+ engine.hot.put(thread_key.clone(), thread);+ engine.hot.put(unrelated_key.clone(), Record::default());+ if !message_is_hot {+ engine.hot.put(+ EntityKey("GraphqlSoupDocument:other".into()),+ Record::default(),+ );+ }+ let selection = RecordSelection::parse(+ "fragment Thread on GraphqlSoupEmailThread { id messages(offset: 0, limit: 1) { id subject } }",+ "Thread",+ ).unwrap();+ let reads = engine.storage().record_get_count();+ for _ in 0..2 {+ let result = engine+ .read_records_by_keys(&selection, std::slice::from_ref(&thread_key))+ .await+ .unwrap();+ assert_eq!(+ result.value[0].record,+ serde_json::json!({"id": "thread", "messages": [{"id": "message", "subject": "Subject"}]})+ );+ }+ assert_eq!(+ engine.storage().record_get_count(),+ reads + usize::from(!message_is_hot)+ );+ engine.hot.put(+ EntityKey("GraphqlSoupDocument:new".into()),+ Record::default(),+ );+ assert!(engine.hot.contains(&thread_key));+ assert!(engine.hot.contains(&message_key));+ assert!(!engine.hot.contains(&unrelated_key));+ }+ });+}++#[test]+fn opaque_json_numbers_round_trip_exactly_through_hot_and_cold_reads() {+ pollster::block_on(async {+ let query = "query Payload { user { id activity(input: {limit: 1}) { items { __typename id action { __typename ... on GraphqlActivityUnknownAction { payload } } } } } }";+ let data = serde_json::json!({"user": {"id": "viewer", "activity": {"items": [{+ "__typename": "GraphqlActivityEvent", "id": "event", "action": {+ "__typename": "GraphqlActivityUnknownAction", "payload": {+ "large": 15_588_948_318_755_801_000.0,+ "negative": -15_588_948_318_755_801_000.0,+ "fraction": 1.0000000000000002,+ "tiny": 1.2345678901234567e-200+ }+ }+ }]}}});+ let variables = serde_json::Map::new();+ let mut engine = Engine::new(InMemoryStorage::new());+ engine+ .write_query(None, query, Some("Payload"), &variables, &data, None)+ .await+ .unwrap();+ for _ in 0..2 {+ let read = engine+ .read_query(None, query, Some("Payload"), &variables)+ .await+ .unwrap();+ assert!(matches!(read, ReadResult::Hit { data: actual } if actual == data));+ engine = Engine::new(engine.into_storage());+ }+ });+}diff --git a/crates/client/cache-core/src/engine/test/hydration_search_changes.rs b/crates/client/cache-core/src/engine/test/hydration_search_changes.rsindex 16173d4a8d..af74a3fe06 100644--- a/crates/client/cache-core/src/engine/test/hydration_search_changes.rs+++ b/crates/client/cache-core/src/engine/test/hydration_search_changes.rs@@ -32,7 +32,7 @@ fn nested_task_completion_hydration_invalidates_task_searches() {let document_key = EntityKey::entity("GraphqlSoupDocument", &["task"]);let records = engine.storage()- .get_batch(&[document_key.clone()])+ .get_batch(std::slice::from_ref(&document_key)).await.unwrap();// Task subtypes have no id: normalization embeds the object indiff --git a/crates/client/cache-core/src/record_selection.rs b/crates/client/cache-core/src/record_selection.rsindex 3ee2acd572..0f67a94fc0 100644--- a/crates/client/cache-core/src/record_selection.rs+++ b/crates/client/cache-core/src/record_selection.rs@@ -4,6 +4,8 @@//! only to normalized entity objects. Explicit entity keys are projected with//! the ordinary denormalizer without scanning normalized storage.+pub mod cache;+use crate::document::{ArgValue, Document, DocumentError, FieldNode, Selection};use crate::meta::{self, FieldKind, TypeKind};use crate::value::EntityKey;diff --git a/crates/client/cache-core/src/record_selection/cache.rs b/crates/client/cache-core/src/record_selection/cache.rsnew file mode 100644index 0000000000..c1875ed3e5--- /dev/null+++ b/crates/client/cache-core/src/record_selection/cache.rs@@ -0,0 +1,39 @@+//! Bounded reuse of validated fragment plans across cache hosts.+use super::{RecordSelection, RecordSelectionError};+use lru::LruCache;+use std::{num::NonZeroUsize, sync::Arc};++const CAPACITY: usize = 128;++/// Reuses successful fragment plans by document text and fragment name.+pub struct RecordSelectionCache {+ plans: LruCache<(String, String), Arc<RecordSelection>>,+}++impl Default for RecordSelectionCache {+ fn default() -> Self {+ Self {+ plans: LruCache::new(NonZeroUsize::new(CAPACITY).unwrap()),+ }+ }+}++impl RecordSelectionCache {+ /// Returns a validated plan, parsing only on a cache miss.+ pub fn get(+ &mut self,+ document: String,+ fragment: String,+ ) -> Result<Arc<RecordSelection>, RecordSelectionError> {+ let key = (document, fragment);+ if let Some(selection) = self.plans.get(&key) {+ return Ok(Arc::clone(selection));+ }+ let selection = Arc::new(RecordSelection::parse(&key.0, &key.1)?);+ self.plans.put(key, Arc::clone(&selection));+ Ok(selection)+ }+}++#[cfg(test)]+mod test;diff --git a/crates/client/cache-core/src/record_selection/cache/test.rs b/crates/client/cache-core/src/record_selection/cache/test.rsnew file mode 100644index 0000000000..0f7f0c8410--- /dev/null+++ b/crates/client/cache-core/src/record_selection/cache/test.rs@@ -0,0 +1,42 @@+use super::*;++#[test]+fn plans_are_reused_but_both_document_and_fragment_are_part_of_identity() {+ let mut selections = RecordSelectionCache::default();+ let document =+ "fragment A on GraphqlSoupDocument { id } fragment B on GraphqlSoupDocument { name }";+ let first = selections.get(document.into(), "A".into()).unwrap();+ let again = selections.get(document.into(), "A".into()).unwrap();+ assert!(Arc::ptr_eq(&first, &again));+ let other = selections.get(document.into(), "B".into()).unwrap();+ assert!(!Arc::ptr_eq(&first, &other));+ let changed = selections+ .get(+ "fragment A on GraphqlSoupDocument { name }".into(),+ "A".into(),+ )+ .unwrap();+ assert!(!Arc::ptr_eq(&first, &changed));+ assert!(selections.get(document.into(), "Missing".into()).is_err());+ assert_eq!(selections.plans.len(), 3);+}++#[test]+fn eviction_is_bounded_and_keeps_recent_plans() {+ let mut selections = RecordSelectionCache::default();+ let document = |i| format!("fragment F{i} on GraphqlSoupDocument {{ id }}");+ let first = selections.get(document(0), "F0".into()).unwrap();+ for i in 1..CAPACITY {+ selections.get(document(i), format!("F{i}")).unwrap();+ }+ assert!(Arc::ptr_eq(+ &first,+ &selections.get(document(0), "F0".into()).unwrap()+ ));+ selections+ .get(document(CAPACITY), format!("F{CAPACITY}"))+ .unwrap();+ assert_eq!(selections.plans.len(), CAPACITY);+ assert!(selections.plans.contains(&(document(0), "F0".into())));+ assert!(!selections.plans.contains(&(document(1), "F1".into())));+}diff --git a/crates/client/cache-turso/src/storage.rs b/crates/client/cache-turso/src/storage.rsindex 5226b62716..920aeebb2b 100644--- a/crates/client/cache-turso/src/storage.rs+++ b/crates/client/cache-turso/src/storage.rs@@ -816,26 +816,7 @@ impl Storage for TursoStorage {return Ok(Vec::new());}let connection = self.connection();- driver::read_transaction(&connection, || {- let mut statement = driver::prepare(&connection, RECORD_GET)?;- let mut records = Vec::with_capacity(keys.len());- for key in &keys {- let rows = driver::query_prepared(- &mut statement,- vec![text(&key.typename), text(&key.id)],- )?;- match rows.as_slice() {- [] => records.push(None),- [row] => {- records.push(Some(decode_record(&required_blob(row, 0)?).map_err(- |_| TursoStorageError::reset(PhysicalResetReason::Codec),- )?))- }- _ => return Err(invariant()),- }- }- Ok(records)- })+ driver::read_transaction(&connection, || record_batch::read(&connection, &keys))})();self.latch_result(result)}@@ -4968,6 +4949,7 @@ mod bounded_selection;mod conjunction;mod integrity;mod page_retention;+mod record_batch;#[cfg(all(test, target_arch = "wasm32"))]mod browser_test;diff --git a/crates/client/cache-turso/src/storage/record_batch.rs b/crates/client/cache-turso/src/storage/record_batch.rsnew file mode 100644index 0000000000..640aa6f02b--- /dev/null+++ b/crates/client/cache-turso/src/storage/record_batch.rs@@ -0,0 +1,79 @@+//! Bounded indexed lookups, retaining the caller's order and duplicate keys.++use super::*;++const BATCH_SIZE: usize = 128;++fn sql(count: usize) -> String {+ let values = (0..count)+ .map(|index| format!("({index}, ?, ?)"))+ .collect::<Vec<_>>()+ .join(", ");+ format!(+ "WITH requested(position, typename, id) AS (VALUES {values}) \+ SELECT q.position, r.value FROM requested AS q \+ LEFT JOIN records AS r ON r.__typename = q.typename AND r.id = q.id"+ )+}++pub(super) fn read(+ connection: &Arc<Connection>,+ keys: &[RecordKey],+) -> Result<Vec<Option<Record>>, TursoStorageError> {+ if let [key] = keys {+ let rows = driver::query(+ connection,+ RECORD_GET,+ vec![text(&key.typename), text(&key.id)],+ )?;+ return match rows.as_slice() {+ [] => Ok(vec![None]),+ [row] => match required_value(row, 0)? {+ Value::Blob(bytes) => {+ Ok(vec![Some(decode_record(bytes).map_err(|_| {+ TursoStorageError::reset(PhysicalResetReason::Codec)+ })?)])+ }+ _ => Err(invariant()),+ },+ _ => Err(invariant()),+ };+ }+ let mut records = Vec::with_capacity(keys.len());+ let mut statement = driver::prepare(connection, &sql(keys.len().min(BATCH_SIZE)))?;+ for batch in keys.chunks(BATCH_SIZE) {+ if statement.parameters_count() != batch.len() * 2 {+ statement = driver::prepare(connection, &sql(batch.len()))?;+ }+ let parameters = batch+ .iter()+ .flat_map(|key| [text(&key.typename), text(&key.id)])+ .collect();+ let rows = driver::query_prepared(&mut statement, parameters)?;+ if rows.len() != batch.len() {+ return Err(invariant());+ }+ let offset = records.len();+ records.resize_with(offset + batch.len(), || None);+ let mut seen = vec![false; batch.len()];+ for row in rows {+ let position = usize::try_from(required_i64(&row, 0)?).map_err(|_| invariant())?;+ let slot = seen.get_mut(position).ok_or_else(invariant)?;+ if std::mem::replace(slot, true) || row.len() != 2 {+ return Err(invariant());+ }+ records[offset + position] = match required_value(&row, 1)? {+ Value::Null => None,+ Value::Blob(bytes) => Some(+ decode_record(bytes)+ .map_err(|_| TursoStorageError::reset(PhysicalResetReason::Codec))?,+ ),+ _ => return Err(invariant()),+ };+ }+ }+ Ok(records)+}++#[cfg(all(test, not(target_arch = "wasm32")))]+mod test;diff --git a/crates/client/cache-turso/src/storage/record_batch/test.rs b/crates/client/cache-turso/src/storage/record_batch/test.rsnew file mode 100644index 0000000000..0cfee7fceb--- /dev/null+++ b/crates/client/cache-turso/src/storage/record_batch/test.rs@@ -0,0 +1,112 @@+use super::*;+use pollster::block_on;++fn key(value: &str) -> EntityKey<'static> {+ EntityKey(value.to_owned().into())+}++fn record(value: &str) -> Record {+ Record {+ fields: [(+ "value".into(),+ cache_core::value::CacheValue::String(value.into()),+ )]+ .into(),+ }+}++#[test]+fn batches_preserve_order_duplicates_missing_keys_and_root_across_boundaries() {+ block_on(async {+ let mut storage = TursoStorage::open_in_memory("record-batches").unwrap();+ let entries: Vec<_> = (0..BATCH_SIZE * 3 + 1)+ .map(|index| {+ let typename = if index % 2 == 0 { "Thing" } else { "Other" };+ (+ key(&format!("{typename}:{index}")),+ record(&index.to_string()),+ )+ })+ .chain([(EntityKey::root(), record("root"))])+ .collect();+ storage.put_batch(entries.clone()).await.unwrap();+ let mut requested = entries+ .iter()+ .rev()+ .map(|(key, _)| key.clone())+ .collect::<Vec<_>>();+ requested.insert(BATCH_SIZE - 1, key("Missing:absent"));+ requested.insert(BATCH_SIZE, requested[0].clone());+ requested.push(key("Thing:1")); // Same id, different typename.+ requested.push(key("Thing:0"));+ let expected = requested+ .iter()+ .map(|key| {+ entries+ .iter()+ .find(|(stored, _)| stored == key)+ .map(|(_, record)| record.clone())+ })+ .collect::<Vec<_>>();+ assert_eq!(storage.get_batch(&requested).await.unwrap(), expected);+ assert!(storage.get_batch(&[]).await.unwrap().is_empty());+ assert_eq!(+ storage.get_batch(&[EntityKey::root()]).await.unwrap(),+ vec![Some(record("root"))]+ );+ });+}++#[test]+fn batch_uses_indexed_point_lookups_in_a_large_population() {+ block_on(async {+ let mut storage = TursoStorage::open_in_memory("record-batch-cost").unwrap();+ storage+ .put_batch(+ (0..10_000)+ .map(|index| (key(&format!("Thing:{index:05}")), record("value")))+ .collect(),+ )+ .await+ .unwrap();+ let connection = storage.connection();+ let mut statement = driver::prepare(&connection, &sql(BATCH_SIZE)).unwrap();+ let parameters = (0..BATCH_SIZE)+ .flat_map(|index| [text("Thing"), text(&format!("{:05}", index * 71))])+ .collect();+ let rows = driver::query_prepared(&mut statement, parameters).unwrap();+ assert_eq!(rows.len(), BATCH_SIZE);+ assert!(rows.iter().all(|row| matches!(&row[1], Value::Blob(_))));+ let steps = statement.metrics().vm_steps;+ assert!(+ steps < BATCH_SIZE as u64 * 100,+ "{steps} VM steps: expected indexed lookups"+ );+ });+}++#[test]+fn corrupt_batch_payload_latches_storage_health() {+ block_on(async {+ let storage = TursoStorage::open_in_memory("record-batch-corruption").unwrap();+ driver::execute(+ &storage.connection(),+ RECORD_UPSERT,+ vec![text("Thing"), text("bad"), Value::from_blob(vec![0xff])],+ )+ .unwrap();+ let error = storage+ .get_batch(&[key("Thing:absent"), key("Thing:bad")])+ .await+ .unwrap_err();+ assert_eq!(+ error.physical_reset_reason(),+ Some(PhysicalResetReason::Codec)+ );+ let error = storage.get_batch(&[]).await.unwrap_err();+ assert_eq!(+ error.physical_reset_reason(),+ Some(PhysicalResetReason::Codec)+ );+ });+}diff --git a/crates/client/cache-wasm/Cargo.toml b/crates/client/cache-wasm/Cargo.tomlindex 834a4d231b..1ae4f117ed 100644--- a/crates/client/cache-wasm/Cargo.toml+++ b/crates/client/cache-wasm/Cargo.toml@@ -2,8 +2,8 @@edition = "2024"name = "cache-wasm"publish = false-# Rebuild for bounded sort-index selection of dense local filter pages.-version = "0.6.35"+# Rebuild with read-path optimizations, scoped invalidation, and bounded filter selection.+version = "0.6.36"[features]default = []diff --git a/crates/client/cache-wasm/src/shell.rs b/crates/client/cache-wasm/src/shell.rsindex 912228e93d..14d79aaf87 100644--- a/crates/client/cache-wasm/src/shell.rs+++ b/crates/client/cache-wasm/src/shell.rs@@ -16,7 +16,7 @@ use cache_core::query_inspection::QueryInspection;use cache_core::queue::{ClaimedMutation, MutationClaimRequest, MutationClaimToken, MutationUpsertKind,};-use cache_core::record_selection::RecordSelection;+use cache_core::record_selection::cache::RecordSelectionCache;use cache_core::search::SearchRequest;use cache_core::store::QueueDiagnosticsAvailability;use cache_core::value::EntityKey;@@ -431,6 +431,7 @@ fn js_write_result(result: WriteResult, ops: &OpInterner) -> JsWriteResult {}struct CacheState {+ selections: RecordSelectionCache,engine: Option<BrowserEngine>,mail_generation: String,scope: String,@@ -717,6 +718,7 @@ async fn open_cache_inner(Ok((CacheEngine {state: Rc::new(Mutex::new(CacheState {+ selections: RecordSelectionCache::default(),engine: Some(build_engine(storage, hot_capacity)),mail_generation: soup_filter_cache_adapter::mail::new_generation(),scope,@@ -1012,6 +1014,37 @@ fn to_js<T: Serialize>(value: &T) -> Result<JsValue, JsValue> {.map_err(|e| JsValue::from_str(&e.to_string()))}+/// Read envelopes contain strings and JSON values. Converting the JSON in one+/// call avoids a Wasm/JS crossing for every nested field and array element.+fn read_response_to_js<'a, T: Serialize>(+ response: &T,+ values: impl IntoIterator<Item = &'a serde_json::Value>,+) -> Result<JsValue, JsValue> {+ // Preserve the existing rejection of integer values outside JS's safe+ // range. JSON.parse would otherwise silently round them. Floating-point+ // values already have JS Number semantics and are allowed at any magnitude.+ if values.into_iter().any(has_unsafe_json_integer) {+ return to_js(response);+ }+ let json = serde_json::to_string(response).map_err(err_js)?;+ js_sys::JSON::parse(&json)+}++fn has_unsafe_json_integer(value: &serde_json::Value) -> bool {+ const MAX_SAFE_INTEGER: i64 = 9_007_199_254_740_991;+ match value {+ serde_json::Value::Number(number) => {+ !number.is_f64()+ && number+ .as_i64()+ .is_none_or(|n| !(-MAX_SAFE_INTEGER..=MAX_SAFE_INTEGER).contains(&n))+ }+ serde_json::Value::Array(values) => values.iter().any(has_unsafe_json_integer),+ serde_json::Value::Object(values) => values.values().any(has_unsafe_json_integer),+ _ => false,+ }+}+const RESET_REQUIRED_MARKER: &str = "cacheStorageResetRequired";const RESET_REQUIRED_MESSAGE: &str = "cache storage reset required";const OWNER_LOCK_UNAVAILABLE_MARKER: &str = "cacheOwnerLockUnavailable";@@ -1233,10 +1266,15 @@ impl CacheEngine {).await;let result = state.engine_result(result)?;- to_js(&match result {+ let response = match result {ReadResult::Hit { data } => JsReadResult::Hit { data },ReadResult::Miss => JsReadResult::Miss,- })+ };+ let data = match &response {+ JsReadResult::Hit { data } => Some(data),+ JsReadResult::Miss => None,+ };+ read_response_to_js(&response, data)})}@@ -1253,7 +1291,10 @@ impl CacheEngine {future_to_promise(async move {let mut state = state.lock().await;state.ensure_callable()?;- let selection = RecordSelection::parse(&document, &fragment_name).map_err(err_js)?;+ let selection = state+ .selections+ .get(document, fragment_name)+ .map_err(err_js)?;let keys: Vec<String> = parse_vec(keys)?;let keys: Vec<_> = keys.into_iter().map(|key| EntityKey(key.into())).collect();let result = state@@ -1261,10 +1302,14 @@ impl CacheEngine {.read_records_by_keys(&selection, &keys).await;let records = state.engine_result(result)?;- to_js(&JsRecordSelectionResult {+ let response = JsRecordSelectionResult {revision: records.revision.to_string(),records: records.value,- })+ };+ read_response_to_js(+ &response,+ response.records.iter().map(|record| &record.record),+ )})}diff --git a/crates/client/cache-wasm/src/shell/test.rs b/crates/client/cache-wasm/src/shell/test.rsindex c869cb1fe5..be9973abb6 100644--- a/crates/client/cache-wasm/src/shell/test.rs+++ b/crates/client/cache-wasm/src/shell/test.rs@@ -11,6 +11,75 @@ wasm_bindgen_test_configure!(run_in_dedicated_worker);mod mail_projection;+#[wasm_bindgen_test]+fn read_response_conversion_preserves_json_and_revision_strings() {+ let data = serde_json::json!({+ "text": "line\n\"quoted\" 🙂",+ "nested": [null, true, {"value": 1.25}],+ "maxInteger": 9_007_199_254_740_991_i64,+ "minInteger": -9_007_199_254_740_991_i64,+ "largeFloat": 15_588_948_318_755_801_000_f64,+ "negativeZero": -0.0_f64,+ });+ let hit = JsReadResult::Hit { data: data.clone() };+ let actual = read_response_to_js(&hit, [&data]).unwrap();+ assert_eq!(+ js_sys::JSON::stringify(&actual).unwrap(),+ js_sys::JSON::stringify(&to_js(&hit).unwrap()).unwrap()+ );+ let js_data = js_sys::Reflect::get(&actual, &"data".into()).unwrap();+ assert!(js_sys::Object::is(+ &js_sys::Reflect::get(&js_data, &"negativeZero".into()).unwrap(),+ &JsValue::from_f64(-0.0)+ ));+ assert_eq!(+ js_sys::Reflect::get(&js_data, &"largeFloat".into())+ .unwrap()+ .as_f64(),+ Some(15_588_948_318_755_801_000_f64)+ );+ let records = JsRecordSelectionResult {+ revision: u64::MAX.to_string(),+ records: vec![cache_core::record_selection::SelectedRecord {+ record_key: EntityKey("Thing:one".into()),+ record: data,+ }],+ };+ assert_eq!(+ js_sys::JSON::stringify(+ &read_response_to_js(&records, records.records.iter().map(|r| &r.record)).unwrap()+ )+ .unwrap(),+ js_sys::JSON::stringify(&to_js(&records).unwrap()).unwrap()+ );+ assert_eq!(+ js_sys::JSON::stringify(+ &read_response_to_js(&JsReadResult::Miss, std::iter::empty()).unwrap()+ )+ .unwrap(),+ js_sys::JSON::stringify(&to_js(&JsReadResult::Miss).unwrap()).unwrap()+ );+}++#[wasm_bindgen_test]+fn read_response_conversion_preserves_unsafe_integer_errors() {+ for number in [+ serde_json::json!(9_007_199_254_740_992_u64),+ serde_json::json!(-9_007_199_254_740_992_i64),+ serde_json::json!(i64::MIN),+ serde_json::json!(u64::MAX),+ ] {+ let data = serde_json::json!({"nested": [{"value": number}]});+ let response = JsReadResult::Hit { data: data.clone() };+ assert_eq!(+ read_response_to_js(&response, [&data])+ .unwrap_err()+ .as_string(),+ to_js(&response).unwrap_err().as_string()+ );+ }+}+#[wasm_bindgen_test]fn build_info_reports_compiled_versions_without_opening_storage() {let info: serde_json::Value =@@ -89,6 +158,7 @@ const SOUP_WITH_PROJECTION_QUERY: &str = r#"query SoupWithProjection($input: Sousoup(input: $input) {nextCursoritems {+ isFavoritedproperties { id propertyDefinitionId value { __typename ... on GraphqlSelectOptionPropertyValue { optionIds } } }__typenameid@@ -114,6 +184,7 @@ const SOUP_BACKFILL_WITH_PROJECTION_QUERY: &str = r#"query SoupBackfill($input:soup(input: $input) {nextCursoritems {+ isFavoritedproperties { id propertyDefinitionId value { __typename ... on GraphqlSelectOptionPropertyValue { optionIds } } }__typenameid@@ -138,6 +209,7 @@ const SOUP_UPDATES_WITH_PROJECTION_SUBSCRIPTION: &str = r#"subscription SoupUpda__typename... on SoupUpdated {item {+ isFavoritedproperties { id propertyDefinitionId value { __typename ... on GraphqlSelectOptionPropertyValue { optionIds } } }__typenameid@@ -389,6 +461,7 @@ fn projected_document_item_with_facts("__typename": "GraphqlSoupDocument","id": document_id,"notifications": [],+ "isFavorited": false,"properties": if status_option_ids.is_empty() { serde_json::json!([]) } else { serde_json::json!([{"id": format!("status:{document_id}"),"propertyDefinitionId": "00000001-0000-0000-0000-000000000002",@@ -2198,6 +2271,60 @@ async fn calls_serialize_and_owner_lock_excludes_a_second_open() {close_and_destroy(&reopened, SCOPE).await;}+#[wasm_bindgen_test]+async fn cached_fragment_plans_preserve_identity_and_recover_from_invalid_requests() {+ let engine = fresh_engine("cache-wasm-fragment-plans").await;+ resolved(engine.write_query(+ write_context(None),+ QUERY.into(),+ Some("Soup".into()),+ js(variables()),+ js(soup_data("doc-1")),+ None,+ ))+ .await;+ let keys = || js(serde_json::json!(["GraphqlSoupDocument:doc-1"]));+ for _ in 0..2 {+ let selected: serde_json::Value = from_js(+ resolved(engine.read_records_by_keys(+ RECORD_FRAGMENT.into(),+ "CachedDocument".into(),+ keys(),+ ))+ .await,+ );+ assert_eq!(selected["records"][0]["record"]["id"], "doc-1");+ }+ assert!(+ JsFuture::from(engine.read_records_by_keys(+ RECORD_FRAGMENT.into(),+ "Missing".into(),+ keys(),+ ))+ .await+ .is_err()+ );+ let changed: serde_json::Value = from_js(+ resolved(engine.read_records_by_keys(+ "fragment CachedDocument on GraphqlSoupDocument { __typename }".into(),+ "CachedDocument".into(),+ keys(),+ ))+ .await,+ );+ assert!(changed["records"][0]["record"].get("id").is_none());+ let original: serde_json::Value = from_js(+ resolved(engine.read_records_by_keys(+ RECORD_FRAGMENT.into(),+ "CachedDocument".into(),+ keys(),+ ))+ .await,+ );+ assert_eq!(original["records"][0]["record"]["id"], "doc-1");+ resolved(engine.close()).await;+}+async fn run_js(body: &str, argument: &str) -> JsValue {let script = js_sys::Function::new_with_args("name", body);let promise = script