@isograph/react 0.4.3 → 0.5.0

package/src/tests/__isograph/Query/startUpdate/entrypoint.ts

@@ -1,6 +1,7 @@
 import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__startUpdate__param} from './param_type';
 import {Query__startUpdate__output_type} from './output_type';
+import type {Query__startUpdate__raw_response_type} from './raw_response_type';
 import readerResolver from './resolver_reader';
 import queryText from './query_text';
 import normalizationAst from './normalization_ast';
@@ -9,7 +10,8 @@ const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
 const artifact: IsographEntrypoint<
   Query__startUpdate__param,
   Query__startUpdate__output_type,
-  NormalizationAst
+  NormalizationAst,
+  Query__startUpdate__raw_response_type
 > = {
   kind: "Entrypoint",
   networkRequestInfo: {

package/src/tests/__isograph/Query/startUpdate/raw_response_type.ts

@@ -0,0 +1,8 @@
+export type Query__startUpdate__raw_response_type = {
+  node____id___v_id?: ({
+    __typename: "Economist",
+    id: string,
+    name: string,
+  } | null),
+}
+

package/src/tests/__isograph/Query/startUpdate/resolver_reader.ts

@@ -46,7 +46,7 @@ const artifact: EagerReaderArtifact<
   Query__startUpdate__output_type
 > = {
   kind: "EagerReaderArtifact",
-  fieldName: "Query.startUpdate",
+  fieldName: "startUpdate",
   resolver,
   readerAst,
   hasUpdatable: true,

package/src/tests/__isograph/Query/subquery/entrypoint.ts

@@ -1,6 +1,7 @@
 import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__subquery__param} from './param_type';
 import {Query__subquery__output_type} from './output_type';
+import type {Query__subquery__raw_response_type} from './raw_response_type';
 import readerResolver from './resolver_reader';
 import queryText from './query_text';
 import normalizationAst from './normalization_ast';
@@ -9,7 +10,8 @@ const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
 const artifact: IsographEntrypoint<
   Query__subquery__param,
   Query__subquery__output_type,
-  NormalizationAst
+  NormalizationAst,
+  Query__subquery__raw_response_type
 > = {
   kind: "Entrypoint",
   networkRequestInfo: {

package/src/tests/__isograph/Query/subquery/raw_response_type.ts

@@ -0,0 +1,9 @@
+export type Query__subquery__raw_response_type = {
+  query: {
+    node____id___v_id?: ({
+      __typename: string,
+      id: string,
+    } | null),
+  },
+}
+

package/src/tests/__isograph/Query/subquery/resolver_reader.ts

@@ -45,7 +45,7 @@ const artifact: EagerReaderArtifact<
   Query__subquery__output_type
 > = {
   kind: "EagerReaderArtifact",
-  fieldName: "Query.subquery",
+  fieldName: "subquery",
   resolver,
   readerAst,
   hasUpdatable: false,

package/src/tests/__isograph/iso.ts

@@ -3,12 +3,14 @@ import { type Query__linkedUpdate__param } from './Query/linkedUpdate/param_type
 import { type Query__meNameSuccessor__param } from './Query/meNameSuccessor/param_type';
 import { type Query__meName__param } from './Query/meName/param_type';
 import { type Query__nodeField__param } from './Query/nodeField/param_type';
+import { type Query__normalizeUndefinedField__param } from './Query/normalizeUndefinedField/param_type';
 import { type Query__startUpdate__param } from './Query/startUpdate/param_type';
 import { type Query__subquery__param } from './Query/subquery/param_type';
 import entrypoint_Query__linkedUpdate from '../__isograph/Query/linkedUpdate/entrypoint';
 import entrypoint_Query__meNameSuccessor from '../__isograph/Query/meNameSuccessor/entrypoint';
 import entrypoint_Query__meName from '../__isograph/Query/meName/entrypoint';
 import entrypoint_Query__nodeField from '../__isograph/Query/nodeField/entrypoint';
+import entrypoint_Query__normalizeUndefinedField from '../__isograph/Query/normalizeUndefinedField/entrypoint';
 import entrypoint_Query__startUpdate from '../__isograph/Query/startUpdate/entrypoint';
 import entrypoint_Query__subquery from '../__isograph/Query/subquery/entrypoint';
 
@@ -76,6 +78,10 @@ export function iso<T>(
   param: T & MatchesWhitespaceAndString<'field Query.nodeField', T>
 ): IdentityWithParam<Query__nodeField__param>;
 
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'field Query.normalizeUndefinedField', T>
+): IdentityWithParam<Query__normalizeUndefinedField__param>;
+
 export function iso<T>(
   param: T & MatchesWhitespaceAndString<'field Query.startUpdate', T>
 ): IdentityWithParam<Query__startUpdate__param>;
@@ -100,6 +106,10 @@ export function iso<T>(
   param: T & MatchesWhitespaceAndString<'entrypoint Query.nodeField', T>
 ): typeof entrypoint_Query__nodeField;
 
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'entrypoint Query.normalizeUndefinedField', T>
+): typeof entrypoint_Query__normalizeUndefinedField;
+
 export function iso<T>(
   param: T & MatchesWhitespaceAndString<'entrypoint Query.startUpdate', T>
 ): typeof entrypoint_Query__startUpdate;
@@ -111,7 +121,7 @@ export function iso<T>(
 export function iso(_isographLiteralText: string):
   | IdentityWithParam<any>
   | IdentityWithParamComponent<any>
-  | IsographEntrypoint<any, any, any>
+  | IsographEntrypoint<any, any, any, any>
 {
   throw new Error('iso: Unexpected invocation at runtime. Either the Babel transform ' +
       'was not set up, or it failed to identify this call site. Make sure it ' +

package/src/tests/garbageCollection.test.ts

@@ -2,17 +2,19 @@ import { describe, expect, test } from 'vitest';
 import {
   garbageCollectEnvironment,
   retainQuery,
+  type RetainedQuery,
 } from '../core/garbageCollection';
 import {
   createIsographEnvironment,
   ROOT_ID,
-  type IsographStore,
+  type BaseStoreLayerData,
 } from '../core/IsographEnvironment';
+import { wrapResolvedValue } from '../core/PromiseWrapper';
 import { iso } from './__isograph/iso';
 import { meNameSuccessorRetainedQuery } from './meNameSuccessor';
 import { nodeFieldRetainedQuery } from './nodeQuery';
 
-const getDefaultStore = (): IsographStore => ({
+const getDefaultStore = (): BaseStoreLayerData => ({
   Query: {
     [ROOT_ID]: {
       me: { __link: '0', __typename: 'Economist' },
@@ -55,9 +57,10 @@ export const meNameField = iso(`
 `)(() => {});
 
 const meNameEntrypoint = iso(`entrypoint Query.meName`);
-const meNameRetainedQuery = {
-  normalizationAst:
-    meNameEntrypoint.networkRequestInfo.normalizationAst.selections,
+const meNameRetainedQuery: RetainedQuery = {
+  normalizationAst: wrapResolvedValue(
+    meNameEntrypoint.networkRequestInfo.normalizationAst,
+  ),
   variables: {},
   root: { __link: ROOT_ID, __typename: 'Query' },
 };

package/src/tests/meNameSuccessor.ts

@@ -1,4 +1,6 @@
+import type { RetainedQuery } from '../core/garbageCollection';
 import { ROOT_ID } from '../core/IsographEnvironment';
+import { wrapResolvedValue } from '../core/PromiseWrapper';
 import { iso } from './__isograph/iso';
 
 export const meNameField = iso(`
@@ -14,9 +16,10 @@ export const meNameField = iso(`
   }
 `)(() => {});
 const meNameSuccessorEntrypoint = iso(`entrypoint Query.meNameSuccessor`);
-export const meNameSuccessorRetainedQuery = {
-  normalizationAst:
-    meNameSuccessorEntrypoint.networkRequestInfo.normalizationAst.selections,
+export const meNameSuccessorRetainedQuery: RetainedQuery = {
+  normalizationAst: wrapResolvedValue(
+    meNameSuccessorEntrypoint.networkRequestInfo.normalizationAst,
+  ),
   variables: {},
   root: {
     __link: ROOT_ID,

package/src/tests/nodeQuery.ts

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

package/src/tests/normalizeData.test.ts

@@ -1,10 +1,10 @@
-import { describe, expect, test, vi } from 'vitest';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
 import { getOrCreateCacheForArtifact, normalizeData } from '../core/cache';
 import {
   createIsographEnvironment,
   createIsographStore,
   ROOT_ID,
-  type IsographStore,
+  type BaseStoreLayerData,
 } from '../core/IsographEnvironment';
 import {
   readButDoNotEvaluate,
@@ -13,6 +13,86 @@ import {
 import { iso } from './__isograph/iso';
 import type { Query__subquery__param } from './__isograph/Query/subquery/param_type';
 
+let store: ReturnType<typeof createIsographStore>;
+let environment: ReturnType<typeof createIsographEnvironment>;
+
+beforeEach(() => {
+  store = createIsographStore();
+  const networkFunction = vi.fn().mockRejectedValue(new Error('Fetch failed'));
+  environment = createIsographEnvironment(store, networkFunction);
+});
+
+export const normalizeUndefinedField = iso(`
+  field Query.normalizeUndefinedField {
+    me {
+      name
+    }
+  }
+`)(() => {});
+
+const normalizeUndefinedFieldEntrypoint = iso(
+  `entrypoint Query.normalizeUndefinedField`,
+);
+
+describe('normalize undefined field', () => {
+  test('should normalize scalar field to null', () => {
+    normalizeData(
+      environment,
+      environment.store,
+      normalizeUndefinedFieldEntrypoint.networkRequestInfo.normalizationAst
+        .selections,
+      {
+        me: { __typename: 'Economist', id: '1' },
+      },
+      {},
+      {
+        __link: ROOT_ID,
+        __typename: normalizeUndefinedFieldEntrypoint.concreteType,
+      },
+      new Map(),
+    );
+    expect(store).toStrictEqual({
+      Economist: {
+        '1': {
+          id: '1',
+          name: null,
+        },
+      },
+      Query: {
+        [ROOT_ID]: {
+          me: {
+            __typename: 'Economist',
+            __link: '1',
+          },
+        },
+      },
+    });
+  });
+
+  test('should normalize linked field to null', () => {
+    normalizeData(
+      environment,
+      environment.store,
+      normalizeUndefinedFieldEntrypoint.networkRequestInfo.normalizationAst
+        .selections,
+      {},
+      {},
+      {
+        __link: ROOT_ID,
+        __typename: normalizeUndefinedFieldEntrypoint.concreteType,
+      },
+      new Map(),
+    );
+    expect(store).toStrictEqual({
+      Query: {
+        [ROOT_ID]: {
+          me: null,
+        },
+      },
+    });
+  });
+});
+
 export const subquery = iso(`
   field Query.subquery($id: ID!) {
     query {
@@ -25,22 +105,18 @@ export const subquery = iso(`
 
 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);
-
+describe('nested Query', () => {
+  test('should be normalized', () => {
     normalizeData(
       environment,
+      environment.store,
       entrypoint.networkRequestInfo.normalizationAst.selections,
       {
         query: { node____id___v_id: { __typename: 'Economist', id: '1' } },
       },
       { id: '1' },
       { __link: ROOT_ID, __typename: entrypoint.concreteType },
+      new Map(),
     );
 
     expect(store).toStrictEqual({
@@ -62,13 +138,11 @@ describe('normalizeData', () => {
           },
         },
       },
-    } satisfies IsographStore);
+    } satisfies BaseStoreLayerData);
   });
-});
 
-describe('readData', () => {
-  test('nested Query should be read', () => {
-    const store: IsographStore = {
+  test('should be read', () => {
+    const store: BaseStoreLayerData = {
       Economist: {
         '1': {
           __typename: 'Economist',