@isograph/react 0.3.1 → 0.4.0

package/src/core/logging.ts

@@ -11,7 +11,7 @@ import {
   IsographEnvironment,
   IsographStore,
   StoreRecord,
-  type Link,
+  type StoreLink,
 } from './IsographEnvironment';
 import { ReadDataResult } from './read';
 import { Arguments } from './util';
@@ -38,7 +38,7 @@ export type LogMessage =
   | {
       kind: 'ComponentRerendered';
       componentName: string;
-      rootLink: Link;
+      rootLink: StoreLink;
     }
   | {
       kind: 'MakeNetworkRequest';
@@ -61,7 +61,7 @@ export type LogMessage =
     }
   | {
       kind: 'MissingFieldHandlerCalled';
-      root: Link;
+      root: StoreLink;
       storeRecord: StoreRecord;
       fieldName: string;
       arguments: Arguments | null;
@@ -71,7 +71,7 @@ export type LogMessage =
       kind: 'DoneReading';
       response: ReadDataResult<any>;
       fieldName: string;
-      root: Link;
+      root: StoreLink;
     }
   | {
       kind: 'NonEntrypointReceived';
@@ -83,6 +83,18 @@ export type LogMessage =
     }
   | {
       kind: 'EnvironmentCreated';
+    }
+  | {
+      kind: 'StartUpdateError';
+      error: any;
+    }
+  | {
+      kind: 'StartUpdateComplete';
+      updatedIds: EncounteredIds;
+    }
+  | {
+      kind: 'ErrorEncounteredInWithErrorHandling';
+      error: any;
     };
 
 export type LogFunction = (logMessage: LogMessage) => void;

package/src/core/makeNetworkRequest.ts

@@ -4,6 +4,7 @@ import { check, DEFAULT_SHOULD_FETCH_VALUE, FetchOptions } from './check';
 import { getOrCreateCachedComponent } from './componentCache';
 import {
   IsographEntrypoint,
+  ReaderWithRefetchQueries,
   RefetchQueryNormalizationArtifact,
   type NormalizationAst,
   type NormalizationAstLoader,
@@ -19,7 +20,7 @@ import {
   retainQuery,
   unretainQuery,
 } from './garbageCollection';
-import { IsographEnvironment, Link, ROOT_ID } from './IsographEnvironment';
+import { IsographEnvironment, ROOT_ID, StoreLink } from './IsographEnvironment';
 import { logMessage } from './logging';
 import {
   AnyError,
@@ -35,18 +36,28 @@ let networkRequestId = 0;
 export function maybeMakeNetworkRequest<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
+  TArtifact extends
+    | RefetchQueryNormalizationArtifact
+    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
 >(
   environment: IsographEnvironment,
-  artifact:
-    | RefetchQueryNormalizationArtifact
-    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>,
+  artifact: TArtifact,
   variables: ExtractParameters<TReadFromStore>,
-  fetchOptions?: FetchOptions<TClientFieldValue>,
+  readerWithRefetchQueries: PromiseWrapper<
+    ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
+  > | null,
+  fetchOptions: FetchOptions<TClientFieldValue> | null,
 ): ItemCleanupPair<PromiseWrapper<void, AnyError>> {
   switch (fetchOptions?.shouldFetch ?? DEFAULT_SHOULD_FETCH_VALUE) {
     case 'Yes': {
-      return makeNetworkRequest(environment, artifact, variables, fetchOptions);
+      return makeNetworkRequest(
+        environment,
+        artifact,
+        variables,
+        readerWithRefetchQueries,
+        fetchOptions,
+      );
     }
     case 'No': {
       return [wrapResolvedValue(undefined), () => {}];
@@ -77,6 +88,7 @@ export function maybeMakeNetworkRequest<
           environment,
           artifact,
           variables,
+          readerWithRefetchQueries,
           fetchOptions,
         );
       }
@@ -100,14 +112,18 @@ function loadNormalizationAst(
 export function makeNetworkRequest<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
+  TArtifact extends
+    | RefetchQueryNormalizationArtifact
+    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
 >(
   environment: IsographEnvironment,
-  artifact:
-    | RefetchQueryNormalizationArtifact
-    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>,
+  artifact: TArtifact,
   variables: ExtractParameters<TReadFromStore>,
-  fetchOptions?: FetchOptions<TClientFieldValue>,
+  readerWithRefetchQueries: PromiseWrapper<
+    ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
+  > | null,
+  fetchOptions: FetchOptions<TClientFieldValue> | null,
 ): ItemCleanupPair<PromiseWrapper<void, AnyError>> {
   // TODO this should be a DataId and stored in the store
   const myNetworkRequestId = networkRequestId + '';
@@ -126,12 +142,13 @@ export function makeNetworkRequest<
   // This should be an observable, not a promise
   const promise = Promise.all([
     environment.networkFunction(
-      artifact.networkRequestInfo.queryText,
+      artifact.networkRequestInfo.operation,
       variables,
     ),
     loadNormalizationAst(artifact.networkRequestInfo.normalizationAst),
+    readerWithRefetchQueries?.promise,
   ])
-    .then(([networkResponse, normalizationAst]) => {
+    .then(([networkResponse, normalizationAst, readerWithRefetchQueries]) => {
       logMessage(environment, () => ({
         kind: 'ReceivedNetworkResponse',
         networkResponse,
@@ -154,9 +171,6 @@ export function makeNetworkRequest<
           normalizationAst.selections,
           networkResponse.data ?? {},
           variables,
-          artifact.kind === 'Entrypoint'
-            ? artifact.readerWithRefetchQueries.nestedRefetchQueries
-            : [],
           root,
         );
         const retainedQuery = {
@@ -178,6 +192,7 @@ export function makeNetworkRequest<
           environment,
           root,
           variables,
+          readerWithRefetchQueries,
         );
 
         try {
@@ -238,14 +253,18 @@ type NetworkRequestStatus =
 function readDataForOnComplete<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
-  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
->(
-  artifact:
+  TArtifact extends
     | RefetchQueryNormalizationArtifact
     | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>,
+  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+>(
+  artifact: TArtifact,
   environment: IsographEnvironment,
-  root: Link,
+  root: StoreLink,
   variables: ExtractParameters<TReadFromStore>,
+  readerWithRefetchQueries:
+    | ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
+    | undefined,
 ): TClientFieldValue | null {
   // An entrypoint, but not a RefetchQueryNormalizationArtifact, has a reader ASTs.
   // So, we can only pass data to onComplete if makeNetworkRequest was passed an entrypoint.
@@ -262,12 +281,17 @@ function readDataForOnComplete<
       suspendIfInFlight: false,
       throwOnNetworkError: false,
     };
+    const resolvedReaderWithRefetchQueries =
+      readerWithRefetchQueries as ReaderWithRefetchQueries<
+        TReadFromStore,
+        TClientFieldValue
+      >;
 
     const fragment: FragmentReference<TReadFromStore, TClientFieldValue> = {
       kind: 'FragmentReference',
       // TODO this smells.
       readerWithRefetchQueries: wrapResolvedValue(
-        artifact.readerWithRefetchQueries,
+        resolvedReaderWithRefetchQueries,
       ),
       root,
       variables,
@@ -278,7 +302,7 @@ function readDataForOnComplete<
       fragment,
       fakeNetworkRequestOptions,
     ).item;
-    const readerArtifact = artifact.readerWithRefetchQueries.readerArtifact;
+    const readerArtifact = resolvedReaderWithRefetchQueries.readerArtifact;
     switch (readerArtifact.kind) {
       case 'ComponentReaderArtifact': {
         // @ts-expect-error We should find a way to encode this in the type system:
@@ -293,7 +317,7 @@ function readDataForOnComplete<
               kind: 'ReaderWithRefetchQueries',
               readerArtifact: readerArtifact,
               nestedRefetchQueries:
-                artifact.readerWithRefetchQueries.nestedRefetchQueries,
+                resolvedReaderWithRefetchQueries.nestedRefetchQueries,
             }),
             root,
             variables,
@@ -311,7 +335,8 @@ function readDataForOnComplete<
                 startUpdate: getOrCreateCachedStartUpdate(
                   environment,
                   fragment,
-                  artifact.readerWithRefetchQueries.readerArtifact.fieldName,
+                  resolvedReaderWithRefetchQueries.readerArtifact.fieldName,
+                  fakeNetworkRequestOptions,
                 ),
               }
             : undefined),

package/src/core/read.ts

@@ -1,7 +1,7 @@
-import { CleanupFn } from '@isograph/disposable-types';
+import { CleanupFn, type ItemCleanupPair } from '@isograph/disposable-types';
 import {
   getParentRecordKey,
-  insertIfNotExists,
+  insertEmptySetIfMissing,
   onNextChangeToRecord,
   type EncounteredIds,
 } from './cache';
@@ -23,24 +23,24 @@ import {
   getOrLoadIsographArtifact,
   IsographEnvironment,
   type DataTypeValue,
-  type Link,
+  type StoreLink,
   type StoreRecord,
 } from './IsographEnvironment';
 import { logMessage } from './logging';
 import { maybeMakeNetworkRequest } from './makeNetworkRequest';
 import {
   getPromiseState,
+  NOT_SET,
   PromiseWrapper,
   readPromise,
-  Result,
   wrapPromise,
   wrapResolvedValue,
 } from './PromiseWrapper';
 import {
   ReaderAst,
+  type LoadablySelectedField,
   type ReaderImperativelyLoadedField,
   type ReaderLinkedField,
-  type ReaderLoadableField,
   type ReaderNonLoadableResolverField,
   type ReaderScalarField,
 } from './reader';
@@ -104,12 +104,8 @@ export function readButDoNotEvaluate<
       // promise results in an infinite loop (including re-issuing the query until the
       // process OOM's or something.) Hence, we throw an error.
 
-      // TODO investigate why we cannot check against NOT_SET here and we have to cast
-      const result = fragmentReference.networkRequest.result as Result<
-        any,
-        any
-      >;
-      if (result.kind === 'Err') {
+      const result = fragmentReference.networkRequest.result;
+      if (result !== NOT_SET && result.kind === 'Err') {
         throw new Error('NetworkError', { cause: result.error });
       }
 
@@ -138,20 +134,20 @@ export type ReadDataResult<Data> =
       readonly kind: 'MissingData';
       readonly reason: string;
       readonly nestedReason?: ReadDataResult<unknown>;
-      readonly recordLink: Link;
+      readonly recordLink: StoreLink;
     };
 
 function readData<TReadFromStore>(
   environment: IsographEnvironment,
   ast: ReaderAst<TReadFromStore>,
-  root: Link,
+  root: StoreLink,
   variables: Variables,
   nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   networkRequest: PromiseWrapper<void, any>,
   networkRequestOptions: NetworkRequestReaderOptions,
   mutableEncounteredRecords: EncounteredIds,
 ): ReadDataResult<ExtractData<TReadFromStore>> {
-  const encounteredIds = insertIfNotExists(
+  const encounteredIds = insertEmptySetIfMissing(
     mutableEncounteredRecords,
     root.__typename,
   );
@@ -196,7 +192,9 @@ function readData<TReadFromStore>(
           storeRecord,
           root,
           variables,
+          nestedRefetchQueries,
           networkRequest,
+          networkRequestOptions,
           (ast, root) =>
             readData(
               environment,
@@ -282,8 +280,8 @@ function readData<TReadFromStore>(
 
 export function readLoadablySelectedFieldData(
   environment: IsographEnvironment,
-  field: ReaderLoadableField,
-  root: Link,
+  field: LoadablySelectedField,
+  root: StoreLink,
   variables: Variables,
   networkRequest: PromiseWrapper<void, any>,
   networkRequestOptions: NetworkRequestReaderOptions,
@@ -346,23 +344,23 @@ export function readLoadablySelectedFieldData(
           const fragmentReferenceAndDisposeFromEntrypoint = (
             entrypoint: IsographEntrypoint<any, any, any>,
           ): [FragmentReference<any, any>, CleanupFn] => {
+            const readerWithRefetchQueries =
+              entrypoint.readerWithRefetchQueries.kind ===
+              'ReaderWithRefetchQueriesLoader'
+                ? wrapPromise(entrypoint.readerWithRefetchQueries.loader())
+                : wrapResolvedValue(entrypoint.readerWithRefetchQueries);
             const [networkRequest, disposeNetworkRequest] =
               maybeMakeNetworkRequest(
                 environment,
                 entrypoint,
                 localVariables,
-                fetchOptions,
+                readerWithRefetchQueries,
+                fetchOptions ?? null,
               );
 
             const fragmentReference: FragmentReference<any, any> = {
               kind: 'FragmentReference',
-              readerWithRefetchQueries: wrapResolvedValue({
-                kind: 'ReaderWithRefetchQueries',
-                readerArtifact:
-                  entrypoint.readerWithRefetchQueries.readerArtifact,
-                nestedRefetchQueries:
-                  entrypoint.readerWithRefetchQueries.nestedRefetchQueries,
-              } as const),
+              readerWithRefetchQueries,
 
               // TODO localVariables is not guaranteed to have an id field
               root,
@@ -396,6 +394,14 @@ export function readLoadablySelectedFieldData(
                   }
                 | { kind: 'Disposed' } = { kind: 'EntrypointNotLoaded' };
 
+              const readerWithRefetchQueries = wrapPromise(
+                isographArtifactPromiseWrapper.promise.then((entrypoint) =>
+                  entrypoint.readerWithRefetchQueries.kind ===
+                  'ReaderWithRefetchQueriesLoader'
+                    ? entrypoint.readerWithRefetchQueries.loader()
+                    : entrypoint.readerWithRefetchQueries,
+                ),
+              );
               const networkRequest = wrapPromise(
                 isographArtifactPromiseWrapper.promise.then((entrypoint) => {
                   if (entrypointLoaderState.kind === 'EntrypointNotLoaded') {
@@ -404,7 +410,8 @@ export function readLoadablySelectedFieldData(
                         environment,
                         entrypoint,
                         localVariables,
-                        fetchOptions,
+                        readerWithRefetchQueries,
+                        fetchOptions ?? null,
                       );
                     entrypointLoaderState = {
                       kind: 'NetworkRequestStarted',
@@ -414,14 +421,10 @@ export function readLoadablySelectedFieldData(
                   }
                 }),
               );
-              const readerWithRefetchPromise =
-                isographArtifactPromiseWrapper.promise.then(
-                  (entrypoint) => entrypoint.readerWithRefetchQueries,
-                );
 
               const fragmentReference: FragmentReference<any, any> = {
                 kind: 'FragmentReference',
-                readerWithRefetchQueries: wrapPromise(readerWithRefetchPromise),
+                readerWithRefetchQueries,
 
                 // TODO localVariables is not guaranteed to have an id field
                 root,
@@ -531,7 +534,7 @@ function writeQueryArgsToVariables(
 export function readResolverFieldData(
   environment: IsographEnvironment,
   field: ReaderNonLoadableResolverField,
-  root: Link,
+  root: StoreLink,
   variables: Variables,
   nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   networkRequest: PromiseWrapper<void, any>,
@@ -591,6 +594,7 @@ export function readResolverFieldData(
               environment,
               fragment,
               readerWithRefetchQueries.readerArtifact.fieldName,
+              networkRequestOptions,
             )
           : undefined,
       };
@@ -621,9 +625,11 @@ export function readResolverFieldData(
 export function readScalarFieldData(
   field: ReaderScalarField,
   storeRecord: StoreRecord,
-  root: Link,
+  root: StoreLink,
   variables: Variables,
-): ReadDataResult<string | number | boolean | Link | DataTypeValue[] | null> {
+): ReadDataResult<
+  string | number | boolean | StoreLink | DataTypeValue[] | null
+> {
   const storeRecordName = getParentRecordKey(field, variables);
   const value = storeRecord[storeRecordName];
   // TODO consider making scalars into discriminated unions. This probably has
@@ -642,13 +648,14 @@ export function readLinkedFieldData(
   environment: IsographEnvironment,
   field: ReaderLinkedField,
   storeRecord: StoreRecord,
-  root: Link,
+  root: StoreLink,
   variables: Variables,
+  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   networkRequest: PromiseWrapper<void, any>,
-
+  networkRequestOptions: NetworkRequestReaderOptions,
   readData: <TReadFromStore>(
     ast: ReaderAst<TReadFromStore>,
-    root: Link,
+    root: StoreLink,
   ) => ReadDataResult<object>,
 ): ReadDataResult<unknown> {
   const storeRecordName = getParentRecordKey(field, variables);
@@ -726,7 +733,7 @@ export function readLinkedFieldData(
       variables: generateChildVariableMap(
         variables,
         // TODO this is wrong
-        // should use field.condition.variables
+        // should use field.arguments
         // but it doesn't exist
         [],
       ),
@@ -742,17 +749,12 @@ export function readLinkedFieldData(
               environment,
               fragment,
               readerWithRefetchQueries.readerArtifact.fieldName,
+              networkRequestOptions,
             ),
           }
         : undefined),
     });
-    if (condition === true) {
-      link = root;
-    } else if (condition === false) {
-      link = null;
-    } else {
-      link = condition;
-    }
+    link = condition;
   }
 
   if (link === undefined) {
@@ -797,6 +799,109 @@ export function readLinkedFieldData(
     };
   }
   const targetId = link;
+  const { refetchQueryIndex } = field;
+  if (refetchQueryIndex != null) {
+    // if field.refetchQueryIndex is not null, then the field is a client pointer, i.e.
+    // it is like a loadable field that returns the selections.
+    const refetchReaderParams = readData(
+      [
+        {
+          kind: 'Scalar',
+          fieldName: 'id',
+          alias: null,
+          arguments: null,
+          isUpdatable: false,
+        },
+      ],
+      targetId,
+    );
+
+    if (refetchReaderParams.kind === 'MissingData') {
+      return {
+        kind: 'MissingData',
+        reason:
+          'Missing data for ' + field.alias + ' on root ' + targetId.__link,
+        nestedReason: refetchReaderParams,
+        recordLink: refetchReaderParams.recordLink,
+      };
+    }
+
+    const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
+    if (refetchQuery == null) {
+      throw new Error(
+        'refetchQuery is null in RefetchField. This is indicative of a bug in Isograph.',
+      );
+    }
+    const refetchQueryArtifact = refetchQuery.artifact;
+    const allowedVariables = refetchQuery.allowedVariables;
+
+    return {
+      kind: 'Success',
+      data: (
+        args: any,
+        // TODO get the associated type for FetchOptions from the loadably selected field
+        fetchOptions?: FetchOptions<any>,
+      ) => {
+        const includeReadOutData = (variables: any, readOutData: any) => {
+          variables.id = readOutData.id;
+          return variables;
+        };
+        const localVariables = includeReadOutData(
+          args ?? {},
+          refetchReaderParams.data,
+        );
+        writeQueryArgsToVariables(localVariables, field.arguments, variables);
+
+        return [
+          // Stable id
+          targetId.__typename +
+            ':' +
+            targetId.__link +
+            '/' +
+            field.fieldName +
+            '/' +
+            stableStringifyArgs(localVariables),
+          // Fetcher
+          (): ItemCleanupPair<FragmentReference<any, any>> | undefined => {
+            const variables = includeReadOutData(
+              filterVariables({ ...args, ...localVariables }, allowedVariables),
+              refetchReaderParams.data,
+            );
+
+            const readerWithRefetchQueries = wrapResolvedValue({
+              kind: 'ReaderWithRefetchQueries',
+              readerArtifact: {
+                kind: 'EagerReaderArtifact',
+                fieldName: field.fieldName,
+                readerAst: field.selections,
+                resolver: ({ data }: { data: any }) => data,
+                hasUpdatable: false,
+              },
+              nestedRefetchQueries,
+            } as const);
+
+            const [networkRequest, disposeNetworkRequest] =
+              maybeMakeNetworkRequest(
+                environment,
+                refetchQueryArtifact,
+                variables,
+                readerWithRefetchQueries,
+                fetchOptions ?? null,
+              );
+
+            const fragmentReference: FragmentReference<any, any> = {
+              kind: 'FragmentReference',
+              readerWithRefetchQueries: readerWithRefetchQueries,
+              root: targetId,
+              variables,
+              networkRequest,
+            };
+            return [fragmentReference, disposeNetworkRequest];
+          },
+        ];
+      },
+    };
+  }
   const data = readData(field.selections, targetId);
   if (data.kind === 'MissingData') {
     return {
@@ -841,7 +946,7 @@ function stableStringifyArgs(args: object) {
 export function readImperativelyLoadedField(
   environment: IsographEnvironment,
   field: ReaderImperativelyLoadedField,
-  root: Link,
+  root: StoreLink,
   variables: Variables,
   nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   networkRequest: PromiseWrapper<void, any>,
@@ -871,11 +976,11 @@ export function readImperativelyLoadedField(
       recordLink: data.recordLink,
     };
   } else {
-    const refetchQueryIndex = field.refetchQuery;
+    const { refetchQueryIndex } = field;
     const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
     if (refetchQuery == null) {
       throw new Error(
-        'refetchQuery is null in RefetchField. This is indicative of a bug in Isograph.',
+        'Refetch query not found. This is indicative of a bug in Isograph.',
       );
     }
     const refetchQueryArtifact = refetchQuery.artifact;
@@ -887,7 +992,7 @@ export function readImperativelyLoadedField(
       kind: 'Success',
       data: (args: any) => [
         // Stable id
-        root.__link + '__' + field.name,
+        root.__typename + ':' + root.__link + '__' + field.name,
         // Fetcher
         field.refetchReaderArtifact.resolver(
           environment,

package/src/core/reader.ts

@@ -14,7 +14,7 @@ import {
 import {
   ComponentOrFieldName,
   IsographEnvironment,
-  type Link,
+  type StoreLink,
 } from './IsographEnvironment';
 import { Arguments } from './util';
 
@@ -71,7 +71,7 @@ export type RefetchReaderArtifact = {
     variables: any,
     // TODO type this better
     filteredVariables: any,
-    rootLink: Link,
+    rootLink: StoreLink,
     readerArtifact: TopLevelReaderArtifact<any, any, any> | null,
     // TODO type this better
     nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
@@ -83,7 +83,7 @@ export type ReaderAstNode =
   | ReaderLinkedField
   | ReaderNonLoadableResolverField
   | ReaderImperativelyLoadedField
-  | ReaderLoadableField
+  | LoadablySelectedField
   | ReaderLinkField;
 
 // @ts-ignore
@@ -109,10 +109,14 @@ export type ReaderLinkedField = {
   readonly selections: ReaderAst<unknown>;
   readonly arguments: Arguments | null;
   readonly condition: EagerReaderArtifact<
-    { data: object; parameters: any; startUpdate?: StartUpdate<object> },
-    boolean | Link | null
+    { data: any; parameters: any; startUpdate?: StartUpdate<any> },
+    StoreLink | null
   > | null;
   readonly isUpdatable: boolean;
+  /**
+   * If refetchQueryIndex != null, then the linked field is a client pointer.
+   */
+  readonly refetchQueryIndex: number | null;
 };
 
 export type ReaderNonLoadableResolverField = {
@@ -128,11 +132,11 @@ export type ReaderImperativelyLoadedField = {
   readonly kind: 'ImperativelyLoadedField';
   readonly alias: string;
   readonly refetchReaderArtifact: RefetchReaderArtifact;
-  readonly refetchQuery: number;
+  readonly refetchQueryIndex: number;
   readonly name: string;
 };
 
-export type ReaderLoadableField = {
+export type LoadablySelectedField = {
   readonly kind: 'LoadablySelectedField';
   readonly alias: string;