@isograph/react 0.4.3 → 0.5.1

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

@@ -0,0 +1,14 @@
+export type Query__meNameSuccessor__raw_response_type = {
+  me: {
+    id: string,
+    name: string,
+    successor?: ({
+      id: string,
+      successor?: ({
+        id: string,
+        name: string,
+      } | null),
+    } | null),
+  },
+}
+

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

@@ -58,7 +58,7 @@ const artifact: EagerReaderArtifact<
   Query__meNameSuccessor__output_type
 > = {
   kind: "EagerReaderArtifact",
-  fieldName: "Query.meNameSuccessor",
+  fieldName: "meNameSuccessor",
   resolver,
   readerAst,
   hasUpdatable: false,

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

@@ -1,6 +1,7 @@
 import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__nodeField__param} from './param_type';
 import {Query__nodeField__output_type} from './output_type';
+import type {Query__nodeField__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__nodeField__param,
   Query__nodeField__output_type,
-  NormalizationAst
+  NormalizationAst,
+  Query__nodeField__raw_response_type
 > = {
   kind: "Entrypoint",
   networkRequestInfo: {

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

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

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

@@ -34,7 +34,7 @@ const artifact: EagerReaderArtifact<
   Query__nodeField__output_type
 > = {
   kind: "EagerReaderArtifact",
-  fieldName: "Query.nodeField",
+  fieldName: "nodeField",
   resolver,
   readerAst,
   hasUpdatable: false,

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

@@ -0,0 +1,33 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
+import {Query__normalizeUndefinedField__param} from './param_type';
+import {Query__normalizeUndefinedField__output_type} from './output_type';
+import type {Query__normalizeUndefinedField__raw_response_type} from './raw_response_type';
+import readerResolver from './resolver_reader';
+import queryText from './query_text';
+import normalizationAst from './normalization_ast';
+const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
+
+const artifact: IsographEntrypoint<
+  Query__normalizeUndefinedField__param,
+  Query__normalizeUndefinedField__output_type,
+  NormalizationAst,
+  Query__normalizeUndefinedField__raw_response_type
+> = {
+  kind: "Entrypoint",
+  networkRequestInfo: {
+    kind: "NetworkRequestInfo",
+    operation: {
+      kind: "Operation",
+      text: queryText,
+    },
+    normalizationAst,
+  },
+  concreteType: "Query",
+  readerWithRefetchQueries: {
+    kind: "ReaderWithRefetchQueries",
+    nestedRefetchQueries,
+    readerArtifact: readerResolver,
+  },
+};
+
+export default artifact;

package/src/tests/__isograph/Query/normalizeUndefinedField/normalization_ast.ts

@@ -0,0 +1,25 @@
+import type {NormalizationAst} from '@isograph/react';
+const normalizationAst: NormalizationAst = {
+  kind: "NormalizationAst",
+  selections: [
+    {
+      kind: "Linked",
+      fieldName: "me",
+      arguments: null,
+      concreteType: "Economist",
+      selections: [
+        {
+          kind: "Scalar",
+          fieldName: "id",
+          arguments: null,
+        },
+        {
+          kind: "Scalar",
+          fieldName: "name",
+          arguments: null,
+        },
+      ],
+    },
+  ],
+};
+export default normalizationAst;

package/src/tests/__isograph/Query/normalizeUndefinedField/output_type.ts

@@ -0,0 +1,3 @@
+import type React from 'react';
+import { normalizeUndefinedField as resolver } from '../../../normalizeData.test';
+export type Query__normalizeUndefinedField__output_type = ReturnType<typeof resolver>;

package/src/tests/__isograph/Query/normalizeUndefinedField/param_type.ts

@@ -0,0 +1,9 @@
+
+export type Query__normalizeUndefinedField__param = {
+  readonly data: {
+    readonly me: {
+      readonly name: string,
+    },
+  },
+  readonly parameters: Record<PropertyKey, never>,
+};

package/src/tests/__isograph/Query/normalizeUndefinedField/query_text.ts

@@ -0,0 +1,6 @@
+export default 'query normalizeUndefinedField {\
+  me {\
+    id,\
+    name,\
+  },\
+}';

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

@@ -0,0 +1,7 @@
+export type Query__normalizeUndefinedField__raw_response_type = {
+  me: {
+    id: string,
+    name: string,
+  },
+}
+

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

@@ -0,0 +1,38 @@
+import type { EagerReaderArtifact, ReaderAst } from '@isograph/react';
+import { Query__normalizeUndefinedField__param } from './param_type';
+import { Query__normalizeUndefinedField__output_type } from './output_type';
+import { normalizeUndefinedField as resolver } from '../../../normalizeData.test';
+
+const readerAst: ReaderAst<Query__normalizeUndefinedField__param> = [
+  {
+    kind: "Linked",
+    fieldName: "me",
+    alias: null,
+    arguments: null,
+    condition: null,
+    isUpdatable: false,
+    refetchQueryIndex: null,
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "name",
+        alias: null,
+        arguments: null,
+        isUpdatable: false,
+      },
+    ],
+  },
+];
+
+const artifact: EagerReaderArtifact<
+  Query__normalizeUndefinedField__param,
+  Query__normalizeUndefinedField__output_type
+> = {
+  kind: "EagerReaderArtifact",
+  fieldName: "normalizeUndefinedField",
+  resolver,
+  readerAst,
+  hasUpdatable: false,
+};
+
+export default artifact;

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

@@ -1,18 +1,17 @@
+import { iso } from '@iso';
 import { describe, expect, test } from 'vitest';
 import {
   garbageCollectEnvironment,
   retainQuery,
+  type RetainedQuery,
 } from '../core/garbageCollection';
-import {
-  createIsographEnvironment,
-  ROOT_ID,
-  type IsographStore,
-} from '../core/IsographEnvironment';
-import { iso } from './__isograph/iso';
+import { ROOT_ID, type BaseStoreLayerData } from '../core/IsographEnvironment';
+import { wrapResolvedValue } from '../core/PromiseWrapper';
 import { meNameSuccessorRetainedQuery } from './meNameSuccessor';
 import { nodeFieldRetainedQuery } from './nodeQuery';
+import { createIsographEnvironment } from '../react/createIsographEnvironment';
 
-const getDefaultStore = (): IsographStore => ({
+const getDefaultStore = (): BaseStoreLayerData => ({
   Query: {
     [ROOT_ID]: {
       me: { __link: '0', __typename: 'Economist' },
@@ -55,9 +54,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,5 +1,7 @@
+import type { RetainedQuery } from '../core/garbageCollection';
 import { ROOT_ID } from '../core/IsographEnvironment';
-import { iso } from './__isograph/iso';
+import { wrapResolvedValue } from '../core/PromiseWrapper';
+import { iso } from '@iso';
 
 export const meNameField = iso(`
   field Query.meNameSuccessor {
@@ -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,6 +1,7 @@
-import { RetainedQuery } from '../core/garbageCollection';
+import type { RetainedQuery } from '../core/garbageCollection';
 import { ROOT_ID } from '../core/IsographEnvironment';
-import { iso } from './__isograph/iso';
+import { wrapResolvedValue } from '../core/PromiseWrapper';
+import { iso } from '@iso';
 
 // TODO investigate why this can't be in garbageCollection.test.ts without
 // typescript incorrectly thinking it is referenced in its own initializer
@@ -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,18 +1,100 @@
-import { describe, expect, test, vi } from 'vitest';
-import { getOrCreateCacheForArtifact, normalizeData } from '../core/cache';
+import { iso } from '@iso';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
 import {
-  createIsographEnvironment,
   createIsographStore,
   ROOT_ID,
-  type IsographStore,
+  type BaseStoreLayerData,
 } from '../core/IsographEnvironment';
+import { normalizeData } from '../core/cache';
+import { getOrCreateCacheForArtifact } from '../core/getOrCreateCacheForArtifact';
 import {
   readButDoNotEvaluate,
   type WithEncounteredRecords,
 } from '../core/read';
-import { iso } from './__isograph/iso';
+import { createIsographEnvironment } from '../react/createIsographEnvironment';
 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 +107,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 +140,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',