@data-client/core 0.16.7 → 0.18.1

package/src/controller/__tests__/getResponseMeta-countRef.ts

@@ -0,0 +1,93 @@
+import { Endpoint, Entity } from '@data-client/endpoint';
+
+import { GCPolicy } from '../../state/GCPolicy';
+import { initialState } from '../../state/reducer/createReducer';
+import Controller from '../Controller';
+
+/** Integration test for the `paths` → `countRef` pipeline.
+ *
+ * React hooks (`useSuspense`, `useCache`, `useLive`, `useDLE`, `useQuery`)
+ * all call `controller.getResponseMeta(...)` during `useMemo` and then
+ * pass the returned `countRef` to `useEffect`. `useEffect` executes
+ * `countRef` once per hook instance — iterating the **captured** `paths`
+ * array to increment `GCPolicy.entityCount` per referenced entity. When
+ * the component unmounts (or `data` changes) the returned `decrement`
+ * closure iterates that same captured `paths` array to decrement.
+ *
+ * Before the fix, `globalCache.getResults` called `paths.shift()` on a
+ * result-cache hit, mutating the journey array stored by reference on
+ * `WeakDependencyMap.Link.journey`. Because `paths` aliases that stored
+ * journey, every successive hit dropped one more real `EntityPath` from
+ * the subscription list. The Nth component mount (for N ≥ 3, same
+ * endpoint + args, entities unchanged) would have its `countRef`
+ * iterate a progressively shorter list — skipping the first real
+ * entity, then the second, etc. — leaving `entityCount` under-counted
+ * for those entities and allowing GC to reap entities that mounted
+ * components still subscribe to.
+ */
+describe('Controller.getResponseMeta + GCPolicy.countRef integration', () => {
+  it('entityCount tracks all entities for each subscriber across repeated result-cache hits', () => {
+    class Foo extends Entity {
+      id = '';
+      pk() {
+        return this.id;
+      }
+    }
+    const ep = new Endpoint(() => Promise.resolve(), {
+      key: () => 'listFoo',
+      schema: [Foo],
+    });
+
+    const gcPolicy = new GCPolicy();
+    const controller = new Controller({ gcPolicy });
+    gcPolicy.init(controller);
+
+    const state = {
+      ...initialState,
+      entities: {
+        Foo: {
+          '1': { id: '1' },
+          '2': { id: '2' },
+        },
+      },
+      endpoints: {
+        [ep.key()]: ['1', '2'],
+      },
+    };
+
+    // Three successive `getResponseMeta` calls simulate three React
+    // components mounting with the same endpoint + args, where the store
+    // has not changed between renders. Call 1 is a result-cache miss;
+    // calls 2 and 3 are hits — each hit mutates the shared journey.
+    const m1 = controller.getResponseMeta(ep, state);
+    const m2 = controller.getResponseMeta(ep, state);
+    const m3 = controller.getResponseMeta(ep, state);
+
+    // Simulate `useEffect(countRef, [data])` firing for each mount.
+    // Pre-fix: m2.paths and m3.paths both aliased the shared journey,
+    // and by the time the countRefs run the journey has been shifted
+    // twice — so both iterate `[Foo|'2']` only, silently skipping
+    // Foo|'1'. Only m1 (miss path, fresh `paths`) counted Foo|'1'.
+    const dec1 = m1.countRef();
+    const dec2 = m2.countRef();
+    const dec3 = m3.countRef();
+
+    // Each mount must have incremented *both* entities.
+    // Pre-fix: Foo|'1' = 1 (only m1 counted it); Foo|'2' = 3.
+    expect(gcPolicy['entityCount'].get('Foo')?.get('1')).toBe(3);
+    expect(gcPolicy['entityCount'].get('Foo')?.get('2')).toBe(3);
+
+    // Simulate all three components unmounting (or `data` changing).
+    // Pre-fix: only dec1 would decrement Foo|'1' (taking it from 1 to
+    // 0) — observable as premature GC-eligibility of Foo|'1' while
+    // the other two subscribers still depended on it.
+    dec1();
+    dec2();
+    dec3();
+
+    expect(gcPolicy['entityCount'].get('Foo')?.get('1')).toBeUndefined();
+    expect(gcPolicy['entityCount'].get('Foo')?.get('2')).toBeUndefined();
+
+    gcPolicy.cleanup();
+  });
+});

package/src/controller/__tests__/getResponseMeta-paths.ts

@@ -0,0 +1,88 @@
+import { Endpoint, Entity } from '@data-client/endpoint';
+
+import { initialState } from '../../state/reducer/createReducer';
+import Controller from '../Controller';
+
+/** Integration test: `Controller.getResponseMeta()` is the seam every read
+ * hook (`useSuspense`, `useCache`, `useFetch`, `useDLE`, `useLive`) calls.
+ * Multiple subscribers to the same endpoint + args + entities must observe
+ * the same `expiresAt`, otherwise late subscribers silently skip the
+ * entity-expiry refetch in `useSuspense`'s gate
+ * `if (Date.now() <= expiresAt && !forceFetch) return;`.
+ *
+ * The bug fixed by this PR was a `paths.shift()` mutation on the journey
+ * stored by reference on `WeakDependencyMap.Link.journey`. Each successive
+ * cache hit returned a journey one entry shorter than the last. The first
+ * entity dropped is the one with the *earliest* expiry, so subscriber 2's
+ * `entityExpiresAt(paths, …)` skipped it and computed a too-late
+ * `expiresAt`; subscriber 3 saw an empty array and got `Infinity`.
+ *
+ * The path is GC-independent: it fires under `ImmortalGCPolicy` too, since
+ * `entityExpiresAt` is unconditional whenever the endpoint has no
+ * top-level `meta.expiresAt` (the common case for state populated via
+ * `controller.set(Entity, …)`, SSR hydration, or `useQuery`).
+ */
+describe('Controller.getResponseMeta repeated calls', () => {
+  it('returns identical expiresAt across subscribers (journey is not consumed by reads)', () => {
+    class Foo extends Entity {
+      id = '';
+      pk() {
+        return this.id;
+      }
+    }
+    const ep = new Endpoint(() => Promise.resolve(), {
+      key: () => 'listFoo',
+      schema: [Foo],
+    });
+
+    const controller = new Controller({});
+
+    // Endpoint slot exists (so we hit the `denormalize` path) but the
+    // endpoint itself has no top-level `meta.expiresAt` yet — mirrors
+    // apps that hydrate from SSR or use `controller.set(Entity, …)`
+    // without going through an endpoint fetch. In that shape,
+    // `Controller.getResponseMeta()` falls back to walking per-entity
+    // meta via `entityExpiresAt(paths, …)`. Foo|'1' has the earliest
+    // expiry — the first journey entry the buggy `paths.shift()` would
+    // drop.
+    const FOO_1_EXPIRY = 100;
+    const FOO_2_EXPIRY = 1_000_000;
+    const state = {
+      ...initialState,
+      entities: {
+        Foo: {
+          '1': { id: '1' },
+          '2': { id: '2' },
+        },
+      },
+      entitiesMeta: {
+        Foo: {
+          '1': { date: 0, fetchedAt: 0, expiresAt: FOO_1_EXPIRY },
+          '2': { date: 0, fetchedAt: 0, expiresAt: FOO_2_EXPIRY },
+        },
+      },
+      endpoints: {
+        [ep.key()]: ['1', '2'],
+      },
+    };
+
+    // Three successive calls simulate three React components mounting
+    // with the same endpoint + args. Call 1 is a result-cache miss;
+    // calls 2 and 3 are hits.
+    const m1 = controller.getResponseMeta(ep, state);
+    const m2 = controller.getResponseMeta(ep, state);
+    const m3 = controller.getResponseMeta(ep, state);
+
+    // Subscriber 1 picks the earliest entity expiry. Subscribers 2+ must
+    // pick the same one — pre-fix they observed FOO_2_EXPIRY (m2) and
+    // Infinity (m3), silently suppressing entity-expiry refetch.
+    expect(m1.expiresAt).toBe(FOO_1_EXPIRY);
+    expect(m2.expiresAt).toBe(m1.expiresAt);
+    expect(m3.expiresAt).toBe(m1.expiresAt);
+
+    // Cached data must remain referentially equal across hits — the
+    // memo contract `useSuspense` etc. rely on for skip-rerender.
+    expect(m2.data).toBe(m1.data);
+    expect(m3.data).toBe(m1.data);
+  });
+});