Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

Improve GraphQL cache reads across native and browser Turso (#7097)

teoef0b551f0a6f
diff --git a/Cargo.lock b/Cargo.lock
index 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.ts
index 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.ts
index 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.ts
index 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 isFavorited
properties { 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.rs
index 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, Quer
use 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(&registration.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.rs
index 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.graphql
index 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 {
__typename
id
cacheProjection
+ isFavorited
... on GraphqlSoupEmailThread {
name
ownerId
diff --git a/apps/web/tauri/graphql_cache_plugin/src/engine/test/project.graphql b/apps/web/tauri/graphql_cache_plugin/src/engine/test/project.graphql
index 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 {
__typename
id
cacheProjection
+ isFavorited
... on GraphqlSoupProject {
ownerId
parentId
diff --git a/apps/web/tauri/graphql_cache_plugin/src/engine/test/soup.rs b/apps/web/tauri/graphql_cache_plugin/src/engine/test/soup.rs
index 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.toml
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 in
diff --git a/crates/client/cache-core/src/record_selection.rs b/crates/client/cache-core/src/record_selection.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.toml
index 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.rs
index 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.rs
index 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: Sou
soup(input: $input) {
nextCursor
items {
+ isFavorited
properties { id propertyDefinitionId value { __typename ... on GraphqlSelectOptionPropertyValue { optionIds } } }
__typename
id
@@ -114,6 +184,7 @@ const SOUP_BACKFILL_WITH_PROJECTION_QUERY: &str = r#"query SoupBackfill($input:
soup(input: $input) {
nextCursor
items {
+ isFavorited
properties { id propertyDefinitionId value { __typename ... on GraphqlSelectOptionPropertyValue { optionIds } } }
__typename
id
@@ -138,6 +209,7 @@ const SOUP_UPDATES_WITH_PROJECTION_SUBSCRIPTION: &str = r#"subscription SoupUpda
__typename
... on SoupUpdated {
item {
+ isFavorited
properties { id propertyDefinitionId value { __typename ... on GraphqlSelectOptionPropertyValue { optionIds } } }
__typename
id
@@ -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