@isograph/react 0.0.0-main-3a36e9fb → 0.0.0-main-beecd3bf

package/src/tests/garbageCollection.test.ts

@@ -2,6 +2,7 @@ import { describe, test, expect } from 'vitest';
 import {
   ROOT_ID,
   createIsographEnvironment,
+  type IsographStore,
 } from '../core/IsographEnvironment';
 import {
   garbageCollectEnvironment,
@@ -10,32 +11,37 @@ import {
 import { iso } from './__isograph/iso';
 import { nodeFieldRetainedQuery } from './nodeQuery';
 
-const getDefaultStore = () => ({
-  [ROOT_ID]: {
-    me: { __link: '0' },
-    you: { __link: '1' },
-    node____id___0: {
-      __link: '0',
+const getDefaultStore = (): IsographStore => ({
+  Query: {
+    [ROOT_ID]: {
+      me: { __link: '0', __typename: 'Economist' },
+      you: { __link: '1', __typename: 'Economist' },
+      node____id___0: {
+        __link: '0',
+        __typename: 'Economist',
+      },
     },
   },
-  0: {
-    __typename: 'Economist',
-    id: '0',
-    name: 'Jeremy Bentham',
-    successor: { __link: '1' },
-  },
-  1: {
-    __typename: 'Economist',
-    id: '1',
-    name: 'John Stuart Mill',
-    predecessor: { __link: '0' },
-    successor: { __link: '2' },
-  },
-  2: {
-    __typename: 'Economist',
-    id: '2',
-    name: 'Henry Sidgwick',
-    predecessor: { __link: '1' },
+  Economist: {
+    0: {
+      __typename: 'Economist',
+      id: '0',
+      name: 'Jeremy Bentham',
+      successor: { __link: '1', __typename: 'Economist' },
+    },
+    1: {
+      __typename: 'Economist',
+      id: '1',
+      name: 'John Stuart Mill',
+      predecessor: { __link: '0', __typename: 'Economist' },
+      successor: { __link: '2', __typename: 'Economist' },
+    },
+    2: {
+      __typename: 'Economist',
+      id: '2',
+      name: 'Henry Sidgwick',
+      predecessor: { __link: '1', __typename: 'Economist' },
+    },
   },
 });
 
@@ -51,6 +57,7 @@ const meNameEntrypoint = iso(`entrypoint Query.meName`);
 const meNameRetainedQuery = {
   normalizationAst: meNameEntrypoint.networkRequestInfo.normalizationAst,
   variables: {},
+  root: { __link: ROOT_ID, __typename: 'Query' },
 };
 
 describe('garbage collection', () => {
@@ -62,13 +69,13 @@ describe('garbage collection', () => {
       null as any,
     );
 
-    expect(store[1]).not.toBe(undefined);
+    expect(store.Economist?.[1]).not.toBe(undefined);
 
     // TODO enable babel so we don't have to do this
     retainQuery(environment, meNameRetainedQuery);
     garbageCollectEnvironment(environment);
 
-    expect(store[1]).toBe(undefined);
+    expect(store.Economist?.[1]).toBe(undefined);
   });
 
   test('Referenced records should not be garbage collected', () => {
@@ -79,13 +86,13 @@ describe('garbage collection', () => {
       null as any,
     );
 
-    expect(store[0]).not.toBe(undefined);
+    expect(store.Economist?.[0]).not.toBe(undefined);
 
     // TODO enable babel so we don't have to do this
     retainQuery(environment, meNameRetainedQuery);
     garbageCollectEnvironment(environment);
 
-    expect(store[0]).not.toBe(undefined);
+    expect(store.Economist?.[0]).not.toBe(undefined);
   });
 
   test('Referenced records should not be garbage collected, and this should work with variables', () => {
@@ -96,12 +103,12 @@ describe('garbage collection', () => {
       null as any,
     );
 
-    expect(store[0]).not.toBe(undefined);
+    expect(store.Economist?.[0]).not.toBe(undefined);
 
     retainQuery(environment, nodeFieldRetainedQuery);
     garbageCollectEnvironment(environment);
 
-    expect(store[0]).not.toBe(undefined);
+    expect(store.Economist?.[0]).not.toBe(undefined);
   });
 
   test('Referenced records should not be garbage collected, and this should work through multiple levels', () => {
@@ -115,12 +122,12 @@ describe('garbage collection', () => {
     retainQuery(environment, meNameSuccessorRetainedQuery);
     garbageCollectEnvironment(environment);
 
-    expect(store[0]).not.toBe(undefined);
-    expect(store[1]).not.toBe(undefined);
-    expect(store[2]).not.toBe(undefined);
+    expect(store.Economist?.[0]).not.toBe(undefined);
+    expect(store.Economist?.[1]).not.toBe(undefined);
+    expect(store.Economist?.[2]).not.toBe(undefined);
   });
 
-  test('ROOT_ID should not be garbage collected, even if there are no retained queries', () => {
+  test('ROOT_ID should be garbage collected, if there are no retained queries', () => {
     const store = getDefaultStore();
     const environment = createIsographEnvironment(
       store,
@@ -129,7 +136,7 @@ describe('garbage collection', () => {
     );
     garbageCollectEnvironment(environment);
 
-    expect(store[ROOT_ID]).not.toBe(undefined);
-    expect(store[0]).toBe(undefined);
+    expect(store.Query?.[ROOT_ID]).toBe(undefined);
+    expect(store.Economist?.[0]).toBe(undefined);
   });
 });

package/src/tests/meNameSuccessor.ts

@@ -1,3 +1,4 @@
+import { ROOT_ID } from '../core/IsographEnvironment';
 import { iso } from './__isograph/iso';
 
 export const meNameField = iso(`
@@ -17,4 +18,8 @@ export const meNameSuccessorRetainedQuery = {
   normalizationAst:
     meNameSuccessorEntrypoint.networkRequestInfo.normalizationAst,
   variables: {},
+  root: {
+    __link: ROOT_ID,
+    __typename: 'Query',
+  },
 };

package/src/tests/nodeQuery.ts

@@ -1,4 +1,5 @@
 import { RetainedQuery } from '../core/garbageCollection';
+import { ROOT_ID } from '../core/IsographEnvironment';
 import { iso } from './__isograph/iso';
 
 // TODO investigate why this can't be in garbageCollection.test.ts without
@@ -14,4 +15,5 @@ const nodeFieldEntrypoint = iso(`entrypoint Query.nodeField`);
 export const nodeFieldRetainedQuery: RetainedQuery = {
   normalizationAst: nodeFieldEntrypoint.networkRequestInfo.normalizationAst,
   variables: { id: 0 },
+  root: { __link: ROOT_ID, __typename: 'Query' },
 };

package/src/tests/normalizeData.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test, vi } from 'vitest';
+import { getOrCreateCacheForArtifact, normalizeData } from '../core/cache';
+import {
+  createIsographEnvironment,
+  createIsographStore,
+  ROOT_ID,
+  type IsographStore,
+} from '../core/IsographEnvironment';
+import {
+  readButDoNotEvaluate,
+  type WithEncounteredRecords,
+} from '../core/read';
+import { iso } from './__isograph/iso';
+import type { Query__subquery__param } from './__isograph/Query/subquery/param_type';
+
+export const subquery = iso(`
+  field Query.subquery($id: ID!) {
+    query {
+      node(id: $id) {
+        id
+      }
+    }
+  }
+`)(() => {});
+
+const entrypoint = iso(`entrypoint Query.subquery`);
+
+describe('normalizeData', () => {
+  test('nested Query should be normalized', () => {
+    const store = createIsographStore();
+    const networkFunction = vi
+      .fn()
+      .mockRejectedValue(new Error('Fetch failed'));
+    const environment = createIsographEnvironment(store, networkFunction);
+
+    normalizeData(
+      environment,
+      entrypoint.networkRequestInfo.normalizationAst,
+      {
+        query: { node____id___v_id: { __typename: 'Economist', id: '1' } },
+      },
+      { id: '1' },
+      entrypoint.readerWithRefetchQueries.nestedRefetchQueries,
+      { __link: ROOT_ID, __typename: entrypoint.concreteType },
+    );
+
+    expect(store).toStrictEqual({
+      Economist: {
+        '1': {
+          __typename: 'Economist',
+          id: '1',
+        },
+      },
+      Query: {
+        [ROOT_ID]: {
+          node____id___1: {
+            __typename: 'Economist',
+            __link: '1',
+          },
+          query: {
+            __link: ROOT_ID,
+            __typename: 'Query',
+          },
+        },
+      },
+    } satisfies IsographStore);
+  });
+});
+
+describe('readData', () => {
+  test('nested Query should be read', () => {
+    const store: IsographStore = {
+      Economist: {
+        '1': {
+          __typename: 'Economist',
+          id: '1',
+        },
+      },
+      Query: {
+        [ROOT_ID]: {
+          node____id___1: {
+            __typename: 'Economist',
+            __link: '1',
+          },
+          query: {
+            __link: ROOT_ID,
+            __typename: 'Query',
+          },
+        },
+      },
+    };
+    const networkFunction = vi
+      .fn()
+      .mockRejectedValue(new Error('Fetch failed'));
+    const environment = createIsographEnvironment(store, networkFunction);
+    const [_cacheItem, item, _disposeOfTemporaryRetain] =
+      getOrCreateCacheForArtifact(environment, entrypoint, {
+        id: '1',
+      }).getOrPopulateAndTemporaryRetain();
+
+    const data = readButDoNotEvaluate(environment, item, {
+      suspendIfInFlight: true,
+      throwOnNetworkError: false,
+    });
+
+    expect(data).toStrictEqual({
+      encounteredRecords: new Map([
+        ['Economist', new Set(['1'])],
+        ['Query', new Set([ROOT_ID])],
+      ]),
+      item: {
+        query: {
+          node: {
+            id: '1',
+          },
+        },
+      },
+    } satisfies WithEncounteredRecords<Query__subquery__param>);
+  });
+});