@isograph/react 0.0.0-main-7fb13e90 → 0.0.0-main-9b984d79

package/dist/core/IsographEnvironment.d.ts

@@ -3,6 +3,8 @@ import { ParentCache } from '@isograph/react-disposable-state';
 import { RetainedQuery } from './garbageCollection';
 import { WithEncounteredRecords } from './read';
 import { FragmentReference, Variables } from './FragmentReference';
+import { PromiseWrapper } from './PromiseWrapper';
+import { IsographEntrypoint } from './entrypoint';
 export type ComponentOrFieldName = string;
 export type StringifiedArgs = string;
 type ComponentCache = {
@@ -35,6 +37,7 @@ export type IsographEnvironment = {
     readonly componentCache: ComponentCache;
     readonly subscriptions: Subscriptions;
     readonly fragmentCache: CacheMap<FragmentReference<any, any>>;
+    readonly entrypointArtifactCache: Map<string, PromiseWrapper<IsographEntrypoint<any, any>>>;
     readonly retainedQueries: Set<RetainedQuery>;
     readonly gcBuffer: Array<RetainedQuery>;
     readonly gcBufferSize: number;
@@ -64,4 +67,5 @@ export declare function defaultMissingFieldHandler(_storeRecord: StoreRecord, _r
 } | null, variables: Variables | null): Link | undefined;
 export declare function assertLink(link: DataTypeValue): Link | null | undefined;
 export declare function getLink(maybeLink: DataTypeValue): Link | null;
+export declare function getOrLoadIsographArtifact(environment: IsographEnvironment, key: string, loader: () => Promise<IsographEntrypoint<any, any>>): PromiseWrapper<IsographEntrypoint<any, any>>;
 export {};

package/dist/core/IsographEnvironment.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLink = exports.assertLink = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = void 0;
+exports.getOrLoadIsographArtifact = exports.getLink = exports.assertLink = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = void 0;
+const PromiseWrapper_1 = require("./PromiseWrapper");
 exports.ROOT_ID = '__ROOT';
 const DEFAULT_GC_BUFFER_SIZE = 10;
 function createIsographEnvironment(store, networkFunction, missingFieldHandler) {
@@ -11,6 +12,7 @@ function createIsographEnvironment(store, networkFunction, missingFieldHandler)
         componentCache: {},
         subscriptions: new Set(),
         fragmentCache: {},
+        entrypointArtifactCache: new Map(),
         retainedQueries: new Set(),
         gcBuffer: [],
         gcBufferSize: DEFAULT_GC_BUFFER_SIZE,
@@ -58,3 +60,13 @@ function getLink(maybeLink) {
     return null;
 }
 exports.getLink = getLink;
+function getOrLoadIsographArtifact(environment, key, loader) {
+    const value = environment.entrypointArtifactCache.get(key);
+    if (value != null) {
+        return value;
+    }
+    const wrapped = (0, PromiseWrapper_1.wrapPromise)(loader());
+    environment.entrypointArtifactCache.set(key, wrapped);
+    return wrapped;
+}
+exports.getOrLoadIsographArtifact = getOrLoadIsographArtifact;

package/dist/core/entrypoint.d.ts

@@ -12,6 +12,11 @@ export type IsographEntrypoint<TReadFromStore extends Object, TClientFieldValue>
     readonly normalizationAst: NormalizationAst;
     readonly readerWithRefetchQueries: ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>;
 };
+export type IsographEntrypointLoader<TReadFromStore extends Object, TClientFieldValue> = {
+    readonly kind: 'EntrypointLoader';
+    readonly typeAndField: string;
+    readonly loader: () => Promise<IsographEntrypoint<TReadFromStore, TClientFieldValue>>;
+};
 export type NormalizationAstNode = NormalizationScalarField | NormalizationLinkedField | NormalizationInlineFragment;
 export type NormalizationAst = ReadonlyArray<NormalizationAstNode>;
 export type NormalizationScalarField = {

package/dist/core/read.js

@@ -193,32 +193,40 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, netwo
             case 'Resolver': {
                 const usedRefetchQueries = field.usedRefetchQueries;
                 const resolverRefetchQueries = usedRefetchQueries.map((index) => nestedRefetchQueries[index]);
-                const kind = field.readerArtifact.kind;
-                if (kind === 'EagerReaderArtifact') {
-                    const data = readData(environment, field.readerArtifact.readerAst, root, variables, resolverRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
-                    if (data.kind === 'MissingData') {
-                        return {
-                            kind: 'MissingData',
-                            reason: 'Missing data for ' + field.alias + ' on root ' + root,
-                            nestedReason: data,
-                        };
+                switch (field.readerArtifact.kind) {
+                    case 'EagerReaderArtifact': {
+                        const data = readData(environment, field.readerArtifact.readerAst, root, variables, resolverRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
+                        if (data.kind === 'MissingData') {
+                            return {
+                                kind: 'MissingData',
+                                reason: 'Missing data for ' + field.alias + ' on root ' + root,
+                                nestedReason: data,
+                            };
+                        }
+                        else {
+                            target[field.alias] = field.readerArtifact.resolver(data.data);
+                        }
+                        break;
                     }
-                    else {
-                        target[field.alias] = field.readerArtifact.resolver(data.data);
+                    case 'ComponentReaderArtifact': {
+                        target[field.alias] = (0, componentCache_1.getOrCreateCachedComponent)(environment, field.readerArtifact.componentName, {
+                            kind: 'FragmentReference',
+                            readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)({
+                                kind: 'ReaderWithRefetchQueries',
+                                readerArtifact: field.readerArtifact,
+                                nestedRefetchQueries: resolverRefetchQueries,
+                            }),
+                            root,
+                            variables: generateChildVariableMap(variables, field.arguments),
+                            networkRequest,
+                        }, networkRequestOptions);
+                        break;
+                    }
+                    default: {
+                        let _ = field.readerArtifact;
+                        _;
+                        throw new Error('Unexpected kind');
                     }
-                }
-                else if (kind === 'ComponentReaderArtifact') {
-                    target[field.alias] = (0, componentCache_1.getOrCreateCachedComponent)(environment, field.readerArtifact.componentName, {
-                        kind: 'FragmentReference',
-                        readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)({
-                            kind: 'ReaderWithRefetchQueries',
-                            readerArtifact: field.readerArtifact,
-                            nestedRefetchQueries: resolverRefetchQueries,
-                        }),
-                        root,
-                        variables: generateChildVariableMap(variables, field.arguments),
-                        networkRequest,
-                    }, networkRequestOptions);
                 }
                 break;
             }
@@ -251,21 +259,65 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, netwo
                                 stableStringifyArgs(localVariables),
                             // Fetcher
                             () => {
-                                const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, field.entrypoint, localVariables);
-                                const fragmentReference = {
-                                    kind: 'FragmentReference',
-                                    readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)({
-                                        kind: 'ReaderWithRefetchQueries',
-                                        readerArtifact: field.entrypoint.readerWithRefetchQueries.readerArtifact,
-                                        nestedRefetchQueries: field.entrypoint.readerWithRefetchQueries
-                                            .nestedRefetchQueries,
-                                    }),
-                                    // TODO localVariables is not guaranteed to have an id field
-                                    root: localVariables.id,
-                                    variables: localVariables,
-                                    networkRequest,
+                                const fragmentReferenceAndDisposeFromEntrypoint = (entrypoint) => {
+                                    const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, entrypoint, localVariables);
+                                    const fragmentReference = {
+                                        kind: 'FragmentReference',
+                                        readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)({
+                                            kind: 'ReaderWithRefetchQueries',
+                                            readerArtifact: entrypoint.readerWithRefetchQueries.readerArtifact,
+                                            nestedRefetchQueries: entrypoint.readerWithRefetchQueries
+                                                .nestedRefetchQueries,
+                                        }),
+                                        // TODO localVariables is not guaranteed to have an id field
+                                        root: localVariables.id,
+                                        variables: localVariables,
+                                        networkRequest,
+                                    };
+                                    return [fragmentReference, disposeNetworkRequest];
                                 };
-                                return [fragmentReference, disposeNetworkRequest];
+                                if (field.entrypoint.kind === 'Entrypoint') {
+                                    return fragmentReferenceAndDisposeFromEntrypoint(field.entrypoint);
+                                }
+                                else {
+                                    const isographArtifactPromiseWrapper = (0, IsographEnvironment_1.getOrLoadIsographArtifact)(environment, field.entrypoint.typeAndField, field.entrypoint.loader);
+                                    const state = (0, PromiseWrapper_1.getPromiseState)(isographArtifactPromiseWrapper);
+                                    if (state.kind === 'Ok') {
+                                        return fragmentReferenceAndDisposeFromEntrypoint(state.value);
+                                    }
+                                    else {
+                                        // Promise is pending or thrown
+                                        let entrypointLoaderState = { kind: 'EntrypointNotLoaded' };
+                                        const networkRequest = (0, PromiseWrapper_1.wrapPromise)(isographArtifactPromiseWrapper.promise.then((entrypoint) => {
+                                            if (entrypointLoaderState.kind === 'EntrypointNotLoaded') {
+                                                const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, entrypoint, localVariables);
+                                                entrypointLoaderState = {
+                                                    kind: 'NetworkRequestStarted',
+                                                    disposeNetworkRequest,
+                                                };
+                                                return networkRequest.promise;
+                                            }
+                                        }));
+                                        const readerWithRefetchPromise = isographArtifactPromiseWrapper.promise.then((entrypoint) => entrypoint.readerWithRefetchQueries);
+                                        const fragmentReference = {
+                                            kind: 'FragmentReference',
+                                            readerWithRefetchQueries: (0, PromiseWrapper_1.wrapPromise)(readerWithRefetchPromise),
+                                            // TODO localVariables is not guaranteed to have an id field
+                                            root: localVariables.id,
+                                            variables: localVariables,
+                                            networkRequest,
+                                        };
+                                        return [
+                                            fragmentReference,
+                                            () => {
+                                                if (entrypointLoaderState.kind === 'NetworkRequestStarted') {
+                                                    entrypointLoaderState.disposeNetworkRequest();
+                                                }
+                                                entrypointLoaderState = { kind: 'Disposed' };
+                                            },
+                                        ];
+                                    }
+                                }
                             },
                         ];
                     };

package/dist/core/reader.d.ts

@@ -2,7 +2,7 @@
 import { Factory } from '@isograph/disposable-types';
 import { FragmentReference } from './FragmentReference';
 import { ComponentOrFieldName, DataId, IsographEnvironment } from './IsographEnvironment';
-import { IsographEntrypoint, RefetchQueryNormalizationArtifact, RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
+import { IsographEntrypoint, IsographEntrypointLoader, RefetchQueryNormalizationArtifact, RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
 import { Arguments } from './util';
 export type TopLevelReaderArtifact<TReadFromStore extends Object, TClientFieldValue, TComponentProps extends Record<string, never>> = EagerReaderArtifact<TReadFromStore, TClientFieldValue> | ComponentReaderArtifact<TReadFromStore, TComponentProps>;
 export type EagerReaderArtifact<TReadFromStore extends Object, TClientFieldValue> = {
@@ -56,7 +56,7 @@ export type ReaderLoadableField = {
     readonly name: string;
     readonly queryArguments: Arguments | null;
     readonly refetchReaderAst: ReaderAst<any>;
-    readonly entrypoint: IsographEntrypoint<any, any>;
+    readonly entrypoint: IsographEntrypoint<any, any> | IsographEntrypointLoader<any, any>;
 };
 type StableId = string;
 export type LoadableField<TArgs, TResult> = (args: TArgs) => [StableId, Factory<FragmentReference<any, TResult>>];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-7fb13e90",
+  "version": "0.0.0-main-9b984d79",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -17,9 +17,9 @@
     "tsc": "tsc"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-7fb13e90",
-    "@isograph/react-disposable-state": "0.0.0-main-7fb13e90",
-    "@isograph/reference-counted-pointer": "0.0.0-main-7fb13e90"
+    "@isograph/disposable-types": "0.0.0-main-9b984d79",
+    "@isograph/react-disposable-state": "0.0.0-main-9b984d79",
+    "@isograph/reference-counted-pointer": "0.0.0-main-9b984d79"
   },
   "peerDependencies": {
     "react": "18.2.0"

package/src/core/IsographEnvironment.ts

@@ -2,6 +2,8 @@ import { ParentCache } from '@isograph/react-disposable-state';
 import { RetainedQuery } from './garbageCollection';
 import { WithEncounteredRecords } from './read';
 import { FragmentReference, Variables } from './FragmentReference';
+import { PromiseWrapper, wrapPromise } from './PromiseWrapper';
+import { IsographEntrypoint } from './entrypoint';
 
 export type ComponentOrFieldName = string;
 export type StringifiedArgs = string;
@@ -27,6 +29,7 @@ type AnyRecordSubscription = {
 
 type Subscription = FragmentSubscription<Object> | AnyRecordSubscription;
 type Subscriptions = Set<Subscription>;
+// Should this be a map?
 type CacheMap<T> = { [index: string]: ParentCache<T> };
 
 export type IsographEnvironment = {
@@ -38,6 +41,11 @@ export type IsographEnvironment = {
   // N.B. this must be <any, any>, but all *usages* of this should go through
   // a function that adds type parameters.
   readonly fragmentCache: CacheMap<FragmentReference<any, any>>;
+  // TODO make this a CacheMap and add GC
+  readonly entrypointArtifactCache: Map<
+    string,
+    PromiseWrapper<IsographEntrypoint<any, any>>
+  >;
   readonly retainedQueries: Set<RetainedQuery>;
   readonly gcBuffer: Array<RetainedQuery>;
   readonly gcBufferSize: number;
@@ -103,6 +111,7 @@ export function createIsographEnvironment(
     componentCache: {},
     subscriptions: new Set(),
     fragmentCache: {},
+    entrypointArtifactCache: new Map(),
     retainedQueries: new Set(),
     gcBuffer: [],
     gcBufferSize: DEFAULT_GC_BUFFER_SIZE,
@@ -158,3 +167,17 @@ export function getLink(maybeLink: DataTypeValue): Link | null {
   }
   return null;
 }
+
+export function getOrLoadIsographArtifact(
+  environment: IsographEnvironment,
+  key: string,
+  loader: () => Promise<IsographEntrypoint<any, any>>,
+): PromiseWrapper<IsographEntrypoint<any, any>> {
+  const value = environment.entrypointArtifactCache.get(key);
+  if (value != null) {
+    return value;
+  }
+  const wrapped = wrapPromise(loader());
+  environment.entrypointArtifactCache.set(key, wrapped);
+  return wrapped;
+}

package/src/core/entrypoint.ts

@@ -29,6 +29,17 @@ export type IsographEntrypoint<
   >;
 };
 
+export type IsographEntrypointLoader<
+  TReadFromStore extends Object,
+  TClientFieldValue,
+> = {
+  readonly kind: 'EntrypointLoader';
+  readonly typeAndField: string;
+  readonly loader: () => Promise<
+    IsographEntrypoint<TReadFromStore, TClientFieldValue>
+  >;
+};
+
 export type NormalizationAstNode =
   | NormalizationScalarField
   | NormalizationLinkedField

package/src/core/read.ts

@@ -1,17 +1,24 @@
+import { CleanupFn } from '@isograph/isograph-disposable-types/dist';
 import { getParentRecordKey, onNextChange } from './cache';
 import { getOrCreateCachedComponent } from './componentCache';
-import { RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
+import {
+  IsographEntrypoint,
+  RefetchQueryNormalizationArtifactWrapper,
+} from './entrypoint';
 import { FragmentReference, Variables } from './FragmentReference';
 import {
   assertLink,
   DataId,
   defaultMissingFieldHandler,
+  getOrLoadIsographArtifact,
   IsographEnvironment,
 } from './IsographEnvironment';
 import { makeNetworkRequest } from './makeNetworkRequest';
 import {
+  getPromiseState,
   PromiseWrapper,
   readPromise,
+  wrapPromise,
   wrapResolvedValue,
 } from './PromiseWrapper';
 import { ReaderAst } from './reader';
@@ -291,44 +298,53 @@ function readData<TReadFromStore>(
           (index) => nestedRefetchQueries[index],
         );
 
-        const kind = field.readerArtifact.kind;
-        if (kind === 'EagerReaderArtifact') {
-          const data = readData(
-            environment,
-            field.readerArtifact.readerAst,
-            root,
-            variables,
-            resolverRefetchQueries,
-            networkRequest,
-            networkRequestOptions,
-            mutableEncounteredRecords,
-          );
-          if (data.kind === 'MissingData') {
-            return {
-              kind: 'MissingData',
-              reason: 'Missing data for ' + field.alias + ' on root ' + root,
-              nestedReason: data,
-            };
-          } else {
-            target[field.alias] = field.readerArtifact.resolver(data.data);
-          }
-        } else if (kind === 'ComponentReaderArtifact') {
-          target[field.alias] = getOrCreateCachedComponent(
-            environment,
-            field.readerArtifact.componentName,
-            {
-              kind: 'FragmentReference',
-              readerWithRefetchQueries: wrapResolvedValue({
-                kind: 'ReaderWithRefetchQueries',
-                readerArtifact: field.readerArtifact,
-                nestedRefetchQueries: resolverRefetchQueries,
-              }),
+        switch (field.readerArtifact.kind) {
+          case 'EagerReaderArtifact': {
+            const data = readData(
+              environment,
+              field.readerArtifact.readerAst,
               root,
-              variables: generateChildVariableMap(variables, field.arguments),
+              variables,
+              resolverRefetchQueries,
               networkRequest,
-            } as const,
-            networkRequestOptions,
-          );
+              networkRequestOptions,
+              mutableEncounteredRecords,
+            );
+            if (data.kind === 'MissingData') {
+              return {
+                kind: 'MissingData',
+                reason: 'Missing data for ' + field.alias + ' on root ' + root,
+                nestedReason: data,
+              };
+            } else {
+              target[field.alias] = field.readerArtifact.resolver(data.data);
+            }
+            break;
+          }
+          case 'ComponentReaderArtifact': {
+            target[field.alias] = getOrCreateCachedComponent(
+              environment,
+              field.readerArtifact.componentName,
+              {
+                kind: 'FragmentReference',
+                readerWithRefetchQueries: wrapResolvedValue({
+                  kind: 'ReaderWithRefetchQueries',
+                  readerArtifact: field.readerArtifact,
+                  nestedRefetchQueries: resolverRefetchQueries,
+                }),
+                root,
+                variables: generateChildVariableMap(variables, field.arguments),
+                networkRequest,
+              } as const,
+              networkRequestOptions,
+            );
+            break;
+          }
+          default: {
+            let _: never = field.readerArtifact;
+            _;
+            throw new Error('Unexpected kind');
+          }
         }
         break;
       }
@@ -376,30 +392,111 @@ function readData<TReadFromStore>(
                 stableStringifyArgs(localVariables),
               // Fetcher
               () => {
-                const [networkRequest, disposeNetworkRequest] =
-                  makeNetworkRequest(
-                    environment,
+                const fragmentReferenceAndDisposeFromEntrypoint = (
+                  entrypoint: IsographEntrypoint<any, any>,
+                ): [FragmentReference<any, any>, CleanupFn] => {
+                  const [networkRequest, disposeNetworkRequest] =
+                    makeNetworkRequest(environment, entrypoint, localVariables);
+
+                  const fragmentReference: FragmentReference<any, any> = {
+                    kind: 'FragmentReference',
+                    readerWithRefetchQueries: wrapResolvedValue({
+                      kind: 'ReaderWithRefetchQueries',
+                      readerArtifact:
+                        entrypoint.readerWithRefetchQueries.readerArtifact,
+                      nestedRefetchQueries:
+                        entrypoint.readerWithRefetchQueries
+                          .nestedRefetchQueries,
+                    } as const),
+
+                    // TODO localVariables is not guaranteed to have an id field
+                    root: localVariables.id,
+                    variables: localVariables,
+                    networkRequest,
+                  };
+                  return [fragmentReference, disposeNetworkRequest];
+                };
+
+                if (field.entrypoint.kind === 'Entrypoint') {
+                  return fragmentReferenceAndDisposeFromEntrypoint(
                     field.entrypoint,
-                    localVariables,
                   );
+                } else {
+                  const isographArtifactPromiseWrapper =
+                    getOrLoadIsographArtifact(
+                      environment,
+                      field.entrypoint.typeAndField,
+                      field.entrypoint.loader,
+                    );
+                  const state = getPromiseState(isographArtifactPromiseWrapper);
+                  if (state.kind === 'Ok') {
+                    return fragmentReferenceAndDisposeFromEntrypoint(
+                      state.value,
+                    );
+                  } else {
+                    // Promise is pending or thrown
 
-                const fragmentReference: FragmentReference<any, any> = {
-                  kind: 'FragmentReference',
-                  readerWithRefetchQueries: wrapResolvedValue({
-                    kind: 'ReaderWithRefetchQueries',
-                    readerArtifact:
-                      field.entrypoint.readerWithRefetchQueries.readerArtifact,
-                    nestedRefetchQueries:
-                      field.entrypoint.readerWithRefetchQueries
-                        .nestedRefetchQueries,
-                  } as const),
+                    let entrypointLoaderState:
+                      | {
+                          kind: 'EntrypointNotLoaded';
+                        }
+                      | {
+                          kind: 'NetworkRequestStarted';
+                          disposeNetworkRequest: CleanupFn;
+                        }
+                      | { kind: 'Disposed' } = { kind: 'EntrypointNotLoaded' };
 
-                  // TODO localVariables is not guaranteed to have an id field
-                  root: localVariables.id,
-                  variables: localVariables,
-                  networkRequest,
-                };
-                return [fragmentReference, disposeNetworkRequest];
+                    const networkRequest = wrapPromise(
+                      isographArtifactPromiseWrapper.promise.then(
+                        (entrypoint) => {
+                          if (
+                            entrypointLoaderState.kind === 'EntrypointNotLoaded'
+                          ) {
+                            const [networkRequest, disposeNetworkRequest] =
+                              makeNetworkRequest(
+                                environment,
+                                entrypoint,
+                                localVariables,
+                              );
+                            entrypointLoaderState = {
+                              kind: 'NetworkRequestStarted',
+                              disposeNetworkRequest,
+                            };
+                            return networkRequest.promise;
+                          }
+                        },
+                      ),
+                    );
+                    const readerWithRefetchPromise =
+                      isographArtifactPromiseWrapper.promise.then(
+                        (entrypoint) => entrypoint.readerWithRefetchQueries,
+                      );
+
+                    const fragmentReference: FragmentReference<any, any> = {
+                      kind: 'FragmentReference',
+                      readerWithRefetchQueries: wrapPromise(
+                        readerWithRefetchPromise,
+                      ),
+
+                      // TODO localVariables is not guaranteed to have an id field
+                      root: localVariables.id,
+                      variables: localVariables,
+                      networkRequest,
+                    };
+
+                    return [
+                      fragmentReference,
+                      () => {
+                        if (
+                          entrypointLoaderState.kind === 'NetworkRequestStarted'
+                        ) {
+                          entrypointLoaderState.disposeNetworkRequest();
+                        }
+                        entrypointLoaderState = { kind: 'Disposed' };
+                      },
+                    ];
+                  }
+                }
               },
             ];
           };

package/src/core/reader.ts

@@ -7,6 +7,7 @@ import {
 } from './IsographEnvironment';
 import {
   IsographEntrypoint,
+  IsographEntrypointLoader,
   RefetchQueryNormalizationArtifact,
   RefetchQueryNormalizationArtifactWrapper,
 } from './entrypoint';
@@ -111,7 +112,10 @@ export type ReaderLoadableField = {
   readonly queryArguments: Arguments | null;
   readonly refetchReaderAst: ReaderAst<any>;
 
-  readonly entrypoint: IsographEntrypoint<any, any>;
+  // TODO we should not type these as any
+  readonly entrypoint:
+    | IsographEntrypoint<any, any>
+    | IsographEntrypointLoader<any, any>;
 };
 
 type StableId = string;

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

@@ -41,7 +41,7 @@ const artifact: IsographEntrypoint<
     kind: "ReaderWithRefetchQueries",
     nestedRefetchQueries,
     readerArtifact: readerResolver,
-  }
+  },
 };
 
 export default artifact;

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

@@ -77,7 +77,7 @@ const artifact: IsographEntrypoint<
     kind: "ReaderWithRefetchQueries",
     nestedRefetchQueries,
     readerArtifact: readerResolver,
-  }
+  },
 };
 
 export default artifact;

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

@@ -40,7 +40,7 @@ const artifact: IsographEntrypoint<
     kind: "ReaderWithRefetchQueries",
     nestedRefetchQueries,
     readerArtifact: readerResolver,
-  }
+  },
 };
 
 export default artifact;