@isograph/react 0.0.0-main-76ed27b2 → 0.0.0-main-edc5d14f

package/src/core/brand.ts

@@ -16,3 +16,21 @@ export type Brand<
   Brand extends symbol | string,
   // @ts-ignore
 > = infer _ extends Brand ? BaseType : never;
+
+declare const PhantomDataBrand: unique symbol;
+/**
+ * A phantom data type is one that shouldn't show up at runtime, but is checked statically (and only) at compile time.
+ * Data types can use extra properties to act as markers or to perform type checking at compile time. These extra properties should hold no storage values, and have no runtime behavior.
+ *
+ * ```tsx
+ * type MyType<T> = {
+ *   readonly value: number;
+ *   readonly '~T'?: PhantomData<T>;
+ * }
+ * ```
+ */
+export type PhantomData<T> = Brand<T, typeof PhantomDataBrand>;
+
+export type Invariant<T> = (_: T) => T;
+export type Covariant<T> = (_: never) => T;
+export type Contravariant<T> = (_: T) => void;

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(
@@ -523,6 +526,10 @@ function normalizeScalarField(
   }
 }
 
+export function isArray(value: unknown): value is readonly unknown[] {
+  return Array.isArray(value);
+}
+
 /**
  * Mutate targetParentRecord with a given linked field ast node.
  */
@@ -555,7 +562,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 +728,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 +744,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 +922,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 ===
@@ -630,7 +630,7 @@ export function readScalarFieldData(
   root: StoreLink,
   variables: Variables,
 ): ReadDataResult<
-  string | number | boolean | StoreLink | DataTypeValue[] | null
+  string | number | boolean | StoreLink | readonly DataTypeValue[] | null
 > {
   const storeRecordName = getParentRecordKey(field, variables);
   const value = storeRecord[storeRecordName];

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/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/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/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/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/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/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/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 ' +