@isograph/react 0.0.0-main-ff94ae86 → 0.0.0-main-db159ebc

package/src/core/cache.ts

@@ -35,6 +35,7 @@ import {
 import { logMessage } from './logging';
 import { maybeMakeNetworkRequest } from './makeNetworkRequest';
 import {
+  addNetworkResponseStoreLayer,
   getMutableStoreRecordProxy,
   type StoreLayerWithData,
 } from './optimisticProxy';
@@ -86,12 +87,14 @@ export function getOrCreateCacheForArtifact<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 >(
   environment: IsographEnvironment,
   entrypoint: IsographEntrypoint<
     TReadFromStore,
     TClientFieldValue,
-    TNormalizationAst
+    TNormalizationAst,
+    TRawResponseType
   >,
   variables: ExtractParameters<TReadFromStore>,
   fetchOptions?: FetchOptions<TClientFieldValue>,
@@ -145,15 +148,15 @@ export type NetworkResponseValue =
   | NetworkResponseScalarValue
   | null
   | NetworkResponseObject
-  | (NetworkResponseObject | null)[]
-  | (NetworkResponseScalarValue | null)[];
+  | readonly (NetworkResponseObject | null)[]
+  | readonly (NetworkResponseScalarValue | null)[];
 
 export type NetworkResponseObject = {
   // N.B. undefined is here to support optional id's, but
   // undefined should not *actually* be present in the network response.
-  [index: string]: undefined | NetworkResponseValue;
-  id?: DataId;
-  __typename?: TypeName;
+  readonly [index: string]: undefined | NetworkResponseValue;
+  readonly id?: DataId;
+  readonly __typename?: TypeName;
 };
 
 export function normalizeData(
@@ -516,13 +519,19 @@ function normalizeScalarField(
   }
 
   if (isScalarOrEmptyArray(networkResponseData)) {
-    targetStoreRecord[parentRecordKey] = networkResponseData;
+    targetStoreRecord[parentRecordKey] = networkResponseData as
+      | NetworkResponseScalarValue
+      | (NetworkResponseScalarValue | null)[]; // have to cast array to mutable
     return existingValue !== networkResponseData;
   } else {
     throw new Error('Unexpected object array when normalizing scalar');
   }
 }
 
+function isArray(value: unknown): value is readonly unknown[] {
+  return Array.isArray(value);
+}
+
 /**
  * Mutate targetParentRecord with a given linked field ast node.
  */
@@ -555,7 +564,7 @@ function normalizeLinkedField(
     );
   }
 
-  if (Array.isArray(networkResponseData)) {
+  if (isArray(networkResponseData)) {
     // TODO check astNode.plural or the like
     const dataIds: (StoreLink | null)[] = [];
     for (let i = 0; i < networkResponseData.length; i++) {
@@ -721,7 +730,9 @@ function normalizeNetworkResponseObject(
 
 function isScalarOrEmptyArray(
   data: NonNullable<NetworkResponseValue>,
-): data is NetworkResponseScalarValue | (NetworkResponseScalarValue | null)[] {
+): data is
+  | NetworkResponseScalarValue
+  | readonly (NetworkResponseScalarValue | null)[] {
   // N.B. empty arrays count as empty arrays of scalar fields.
   if (Array.isArray(data)) {
     // This is maybe fixed in a new version of Typescript??
@@ -735,7 +746,9 @@ function isScalarOrEmptyArray(
   return isScalarValue;
 }
 
-function isNullOrEmptyArray(data: unknown): data is never[] | null[] | null {
+function isNullOrEmptyArray(
+  data: unknown,
+): data is readonly never[] | null[] | null {
   if (Array.isArray(data)) {
     if (data.length === 0) {
       return true;
@@ -911,3 +924,37 @@ function getDataIdOfNetworkResponse(
   }
   return storeKey;
 }
+
+export function writeData<
+  TReadFromStore extends UnknownTReadFromStore,
+  TRawResponseType extends NetworkResponseObject,
+>(
+  environment: IsographEnvironment,
+  entrypoint: IsographEntrypoint<
+    TReadFromStore,
+    unknown,
+    NormalizationAst,
+    TRawResponseType
+  >,
+  data: TRawResponseType,
+  variables: ExtractParameters<TReadFromStore>,
+) {
+  const encounteredIds: EncounteredIds = new Map();
+  environment.store = addNetworkResponseStoreLayer(environment.store);
+  normalizeData(
+    environment,
+    environment.store,
+    entrypoint.networkRequestInfo.normalizationAst.selections,
+    data,
+    variables,
+    { __link: ROOT_ID, __typename: entrypoint.concreteType },
+    encounteredIds,
+  );
+  logMessage(environment, () => ({
+    kind: 'AfterNormalization',
+    store: environment.store,
+    encounteredIds,
+  }));
+
+  callSubscriptions(environment, encounteredIds);
+}

package/src/core/entrypoint.ts

@@ -1,3 +1,5 @@
+import type { Contravariant, PhantomData } from './brand';
+import type { NetworkResponseObject } from './cache';
 import type { UnknownTReadFromStore } from './FragmentReference';
 import type { TypeName } from './IsographEnvironment';
 import { TopLevelReaderArtifact } from './reader';
@@ -55,6 +57,7 @@ export type IsographEntrypoint<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 > = {
   readonly kind: 'Entrypoint';
   readonly networkRequestInfo: NetworkRequestInfo<TNormalizationAst>;
@@ -62,16 +65,26 @@ export type IsographEntrypoint<
     | ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
     | ReaderWithRefetchQueriesLoader<TReadFromStore, TClientFieldValue>;
   readonly concreteType: TypeName;
+  /**
+   * This field exists solely for typechecking, and will not exist at runtime.
+   */
+  readonly '~TRawResponseType'?: PhantomData<Contravariant<TRawResponseType>>;
 };
 
 export type IsographEntrypointLoader<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
+  TRawResponseType extends NetworkResponseObject,
 > = {
   readonly kind: 'EntrypointLoader';
   readonly typeAndField: string;
   readonly loader: () => Promise<
-    IsographEntrypoint<TReadFromStore, TClientFieldValue, NormalizationAst>
+    IsographEntrypoint<
+      TReadFromStore,
+      TClientFieldValue,
+      NormalizationAst,
+      TRawResponseType
+    >
   >;
 };
 
@@ -129,9 +142,15 @@ export function assertIsEntrypoint<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 >(
   value:
-    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>
+    | IsographEntrypoint<
+        TReadFromStore,
+        TClientFieldValue,
+        TNormalizationAst,
+        TRawResponseType
+      >
     | ((_: any) => any)
     // Temporarily, allow any here. Once we automatically provide
     // types to entrypoints, we probably don't need this.
@@ -139,13 +158,16 @@ export function assertIsEntrypoint<
 ): asserts value is IsographEntrypoint<
   TReadFromStore,
   TClientFieldValue,
-  TNormalizationAst
+  TNormalizationAst,
+  TRawResponseType
 > {
   if (typeof value === 'function') throw new Error('Not a string');
 }
 
 export type ExtractReadFromStore<Type> =
-  Type extends IsographEntrypoint<infer X, any, any> ? X : never;
+  Type extends IsographEntrypoint<infer X, any, any, any> ? X : never;
+export type ExtractRawResponseType<Type> =
+  Type extends IsographEntrypoint<any, any, any, infer X> ? X : never;
 export type ExtractResolverResult<Type> =
-  Type extends IsographEntrypoint<any, infer X, any> ? X : never;
+  Type extends IsographEntrypoint<any, infer X, any, any> ? X : never;
 export type ExtractProps<Type> = Type extends React.FC<infer X> ? X : never;

package/src/core/logging.ts

@@ -44,7 +44,7 @@ export type LogMessage =
       kind: 'MakeNetworkRequest';
       artifact:
         | RefetchQueryNormalizationArtifact
-        | IsographEntrypoint<any, any, any>;
+        | IsographEntrypoint<any, any, any, any>;
       variables: Variables;
       networkRequestId: string;
     }

package/src/core/makeNetworkRequest.ts

@@ -1,5 +1,10 @@
 import { ItemCleanupPair } from '@isograph/disposable-types';
-import { callSubscriptions, normalizeData, type EncounteredIds } from './cache';
+import {
+  callSubscriptions,
+  normalizeData,
+  type EncounteredIds,
+  type NetworkResponseObject,
+} from './cache';
 import { check, DEFAULT_SHOULD_FETCH_VALUE, FetchOptions } from './check';
 import { getOrCreateCachedComponent } from './componentCache';
 import {
@@ -37,13 +42,18 @@ let networkRequestId = 0;
 export function maybeMakeNetworkRequest<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
-  TArtifact extends
-    | RefetchQueryNormalizationArtifact
-    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 >(
   environment: IsographEnvironment,
-  artifact: TArtifact,
+  artifact:
+    | RefetchQueryNormalizationArtifact
+    | IsographEntrypoint<
+        TReadFromStore,
+        TClientFieldValue,
+        TNormalizationAst,
+        TRawResponseType
+      >,
   variables: ExtractParameters<TReadFromStore>,
   readerWithRefetchQueries: PromiseWrapper<
     ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
@@ -108,6 +118,7 @@ export function maybeMakeNetworkRequest<
 function retainQueryWithoutMakingNetworkRequest<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
+  TRawResponseType extends NetworkResponseObject,
 >(
   environment: IsographEnvironment,
   artifact:
@@ -115,7 +126,8 @@ function retainQueryWithoutMakingNetworkRequest<
     | IsographEntrypoint<
         TReadFromStore,
         TClientFieldValue,
-        NormalizationAst | NormalizationAstLoader
+        NormalizationAst | NormalizationAstLoader,
+        TRawResponseType
       >,
   variables: ExtractParameters<TReadFromStore>,
 ): ItemCleanupPair<PromiseWrapper<void, AnyError>> {
@@ -143,13 +155,18 @@ function retainQueryWithoutMakingNetworkRequest<
 export function makeNetworkRequest<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
-  TArtifact extends
-    | RefetchQueryNormalizationArtifact
-    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 >(
   environment: IsographEnvironment,
-  artifact: TArtifact,
+  artifact:
+    | RefetchQueryNormalizationArtifact
+    | IsographEntrypoint<
+        TReadFromStore,
+        TClientFieldValue,
+        TNormalizationAst,
+        TRawResponseType
+      >,
   variables: ExtractParameters<TReadFromStore>,
   readerWithRefetchQueries: PromiseWrapper<
     ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
@@ -284,12 +301,17 @@ type NetworkRequestStatus =
 function readDataForOnComplete<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
-  TArtifact extends
-    | RefetchQueryNormalizationArtifact
-    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 >(
-  artifact: TArtifact,
+  artifact:
+    | RefetchQueryNormalizationArtifact
+    | IsographEntrypoint<
+        TReadFromStore,
+        TClientFieldValue,
+        TNormalizationAst,
+        TRawResponseType
+      >,
   environment: IsographEnvironment,
   root: StoreLink,
   variables: ExtractParameters<TReadFromStore>,
@@ -386,6 +408,7 @@ function readDataForOnComplete<
 function fetchNormalizationAstAndRetainArtifact<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
+  TRawResponseType extends NetworkResponseObject,
 >(
   environment: IsographEnvironment,
   artifact:
@@ -393,7 +416,8 @@ function fetchNormalizationAstAndRetainArtifact<
     | IsographEntrypoint<
         TReadFromStore,
         TClientFieldValue,
-        NormalizationAst | NormalizationAstLoader
+        NormalizationAst | NormalizationAstLoader,
+        TRawResponseType
       >,
   variables: ExtractParameters<TReadFromStore>,
 ): RetainedQuery {

package/src/core/read.ts

@@ -344,7 +344,7 @@ export function readLoadablySelectedFieldData(
         // Fetcher
         () => {
           const fragmentReferenceAndDisposeFromEntrypoint = (
-            entrypoint: IsographEntrypoint<any, any, any>,
+            entrypoint: IsographEntrypoint<any, any, any, {}>,
           ): [FragmentReference<any, any>, CleanupFn] => {
             const readerWithRefetchQueries =
               entrypoint.readerWithRefetchQueries.kind ===

package/src/core/reader.ts

@@ -153,8 +153,8 @@ export type LoadablySelectedField = {
 
   // TODO we should not type these as any
   readonly entrypoint:
-    | IsographEntrypoint<any, any, any>
-    | IsographEntrypointLoader<any, any>;
+    | IsographEntrypoint<any, any, any, any>
+    | IsographEntrypointLoader<any, any, any>;
 };
 
 export type StableId = string;

package/src/index.ts

@@ -21,6 +21,7 @@ export {
   callSubscriptions,
   subscribe,
   normalizeData,
+  writeData,
   type NetworkResponseObject,
   type NetworkResponseValue,
   type NetworkResponseScalarValue,

package/src/react/FragmentReader.tsx

@@ -1,3 +1,4 @@
+import type { NetworkResponseObject } from '../core/cache';
 import {
   type ExtractReadFromStore,
   type IsographEntrypoint,
@@ -8,7 +9,8 @@ import { useResult } from './useResult';
 
 export function FragmentReader<
   TResult,
-  TEntrypoint extends IsographEntrypoint<any, TResult, any>,
+  TRawResponseType extends NetworkResponseObject,
+  TEntrypoint extends IsographEntrypoint<any, TResult, any, TRawResponseType>,
   TChildrenResult,
 >({
   fragmentReference,

package/src/react/FragmentRenderer.tsx

@@ -6,6 +6,7 @@ import {
 import { type FragmentReference } from '../core/FragmentReference';
 import { type NetworkRequestReaderOptions } from '../core/read';
 import { useResult } from './useResult';
+import type { NetworkResponseObject } from '../core/cache';
 
 export type IsExactlyIntrinsicAttributes<T> = T extends JSX.IntrinsicAttributes
   ? JSX.IntrinsicAttributes extends T
@@ -15,7 +16,13 @@ export type IsExactlyIntrinsicAttributes<T> = T extends JSX.IntrinsicAttributes
 
 export function FragmentRenderer<
   TProps extends Record<any, any>,
-  TEntrypoint extends IsographEntrypoint<any, React.FC<TProps>, any>,
+  TRawResponseType extends NetworkResponseObject,
+  TEntrypoint extends IsographEntrypoint<
+    any,
+    React.FC<TProps>,
+    any,
+    TRawResponseType
+  >,
 >(
   props: IsExactlyIntrinsicAttributes<TProps> extends true
     ? {

package/src/react/useImperativeReference.ts

@@ -2,6 +2,7 @@ import {
   UNASSIGNED_STATE,
   useUpdatableDisposableState,
 } from '@isograph/react-disposable-state';
+import type { NetworkResponseObject } from '../core/cache';
 import { FetchOptions, type RequiredFetchOptions } from '../core/check';
 import {
   IsographEntrypoint,
@@ -39,11 +40,13 @@ export function useImperativeReference<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 >(
   entrypoint: IsographEntrypoint<
     TReadFromStore,
     TClientFieldValue,
-    TNormalizationAst
+    TNormalizationAst,
+    TRawResponseType
   >,
 ): UseImperativeReferenceResult<
   TReadFromStore,

package/src/react/useLazyReference.ts

@@ -1,5 +1,8 @@
 import { useLazyDisposableState } from '@isograph/react-disposable-state';
-import { getOrCreateCacheForArtifact } from '../core/cache';
+import {
+  getOrCreateCacheForArtifact,
+  type NetworkResponseObject,
+} from '../core/cache';
 import { FetchOptions, type RequiredFetchOptions } from '../core/check';
 import {
   IsographEntrypoint,
@@ -18,11 +21,13 @@ export function useLazyReference<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 >(
   entrypoint: IsographEntrypoint<
     TReadFromStore,
     TClientFieldValue,
-    TNormalizationAst
+    TNormalizationAst,
+    TRawResponseType
   >,
   variables: ExtractParameters<TReadFromStore>,
   ...[fetchOptions]: TNormalizationAst extends NormalizationAstLoader
@@ -57,12 +62,18 @@ export function useLazyReference<
 
 // @ts-ignore
 function tsTests() {
-  let withAst!: IsographEntrypoint<any, unknown, NormalizationAst>;
-  let withAstLoader!: IsographEntrypoint<any, unknown, NormalizationAstLoader>;
+  let withAst!: IsographEntrypoint<any, unknown, NormalizationAst, any>;
+  let withAstLoader!: IsographEntrypoint<
+    any,
+    unknown,
+    NormalizationAstLoader,
+    {}
+  >;
   let withAstOrLoader!: IsographEntrypoint<
     any,
     unknown,
-    NormalizationAst | NormalizationAstLoader
+    NormalizationAst | NormalizationAstLoader,
+    {}
   >;
 
   useLazyReference(withAst, {}) satisfies {};

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

@@ -1,6 +1,7 @@
 import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__linkedUpdate__param} from './param_type';
 import {Query__linkedUpdate__output_type} from './output_type';
+import type {Query__linkedUpdate__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__linkedUpdate__param,
   Query__linkedUpdate__output_type,
-  NormalizationAst
+  NormalizationAst,
+  Query__linkedUpdate__raw_response_type
 > = {
   kind: "Entrypoint",
   networkRequestInfo: {

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

@@ -1,4 +1,4 @@
-export type Query__linkedUpdate__rawResponse = {
+export type Query__linkedUpdate__raw_response_type = {
   node____id___l_0?: ({
     __typename: "Economist",
     id: string,

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

@@ -1,6 +1,7 @@
 import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__meName__param} from './param_type';
 import {Query__meName__output_type} from './output_type';
+import type {Query__meName__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__meName__param,
   Query__meName__output_type,
-  NormalizationAst
+  NormalizationAst,
+  Query__meName__raw_response_type
 > = {
   kind: "Entrypoint",
   networkRequestInfo: {

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

@@ -1,4 +1,4 @@
-export type Query__meName__rawResponse = {
+export type Query__meName__raw_response_type = {
   me: {
     id: string,
     name: string,

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

@@ -1,6 +1,7 @@
 import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__meNameSuccessor__param} from './param_type';
 import {Query__meNameSuccessor__output_type} from './output_type';
+import type {Query__meNameSuccessor__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__meNameSuccessor__param,
   Query__meNameSuccessor__output_type,
-  NormalizationAst
+  NormalizationAst,
+  Query__meNameSuccessor__raw_response_type
 > = {
   kind: "Entrypoint",
   networkRequestInfo: {

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

@@ -1,4 +1,4 @@
-export type Query__meNameSuccessor__rawResponse = {
+export type Query__meNameSuccessor__raw_response_type = {
   me: {
     id: string,
     name: string,

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

@@ -1,4 +1,4 @@
-export type Query__nodeField__rawResponse = {
+export type Query__nodeField__raw_response_type = {
   node____id___v_id?: ({
     __typename: string,
     id: string,

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

@@ -1,6 +1,7 @@
 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';
@@ -9,7 +10,8 @@ const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
 const artifact: IsographEntrypoint<
   Query__normalizeUndefinedField__param,
   Query__normalizeUndefinedField__output_type,
-  NormalizationAst
+  NormalizationAst,
+  Query__normalizeUndefinedField__raw_response_type
 > = {
   kind: "Entrypoint",
   networkRequestInfo: {

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

@@ -1,4 +1,4 @@
-export type Query__normalizeUndefinedField__rawResponse = {
+export type Query__normalizeUndefinedField__raw_response_type = {
   me: {
     id: string,
     name: string,

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

@@ -1,4 +1,4 @@
-export type Query__startUpdate__rawResponse = {
+export type Query__startUpdate__raw_response_type = {
   node____id___v_id?: ({
     __typename: "Economist",
     id: string,

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

@@ -1,4 +1,4 @@
-export type Query__subquery__rawResponse = {
+export type Query__subquery__raw_response_type = {
   query: {
     node____id___v_id?: ({
       __typename: string,

package/src/tests/__isograph/iso.ts

@@ -121,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 ' +