@isograph/react 0.2.0 → 0.3.1

package/src/core/read.ts

@@ -1,41 +1,67 @@
-import { CleanupFn } from '@isograph/isograph-disposable-types/dist';
-import { getParentRecordKey, onNextChange } from './cache';
+import { CleanupFn } from '@isograph/disposable-types';
+import {
+  getParentRecordKey,
+  insertIfNotExists,
+  onNextChangeToRecord,
+  type EncounteredIds,
+} from './cache';
+import { FetchOptions } from './check';
 import { getOrCreateCachedComponent } from './componentCache';
 import {
   IsographEntrypoint,
   RefetchQueryNormalizationArtifactWrapper,
+  type ReaderWithRefetchQueries,
 } from './entrypoint';
-import { FragmentReference, Variables } from './FragmentReference';
+import {
+  ExtractData,
+  FragmentReference,
+  Variables,
+  type UnknownTReadFromStore,
+} from './FragmentReference';
 import {
   assertLink,
-  DataId,
-  defaultMissingFieldHandler,
   getOrLoadIsographArtifact,
   IsographEnvironment,
+  type DataTypeValue,
+  type Link,
+  type StoreRecord,
 } from './IsographEnvironment';
-import { makeNetworkRequest } from './makeNetworkRequest';
+import { logMessage } from './logging';
+import { maybeMakeNetworkRequest } from './makeNetworkRequest';
 import {
   getPromiseState,
   PromiseWrapper,
   readPromise,
+  Result,
   wrapPromise,
   wrapResolvedValue,
 } from './PromiseWrapper';
-import { ReaderAst } from './reader';
+import {
+  ReaderAst,
+  type ReaderImperativelyLoadedField,
+  type ReaderLinkedField,
+  type ReaderLoadableField,
+  type ReaderNonLoadableResolverField,
+  type ReaderScalarField,
+} from './reader';
+import { getOrCreateCachedStartUpdate } from './startUpdate';
 import { Arguments } from './util';
 
 export type WithEncounteredRecords<T> = {
-  readonly encounteredRecords: Set<DataId>;
-  readonly item: T;
+  readonly encounteredRecords: EncounteredIds;
+  readonly item: ExtractData<T>;
 };
 
-export function readButDoNotEvaluate<TReadFromStore extends Object>(
+export function readButDoNotEvaluate<
+  TReadFromStore extends UnknownTReadFromStore,
+>(
   environment: IsographEnvironment,
   fragmentReference: FragmentReference<TReadFromStore, unknown>,
   networkRequestOptions: NetworkRequestReaderOptions,
 ): WithEncounteredRecords<TReadFromStore> {
-  const mutableEncounteredRecords = new Set<DataId>();
+  const mutableEncounteredRecords: EncounteredIds = new Map();
 
+  // TODO consider moving this to the outside
   const readerWithRefetchQueries = readPromise(
     fragmentReference.readerWithRefetchQueries,
   );
@@ -50,13 +76,17 @@ export function readButDoNotEvaluate<TReadFromStore extends Object>(
     networkRequestOptions,
     mutableEncounteredRecords,
   );
-  // @ts-expect-error
-  if (typeof window !== 'undefined' && window.__LOG) {
-    console.log('done reading', { response });
-  }
+
+  logMessage(environment, () => ({
+    kind: 'DoneReading',
+    response,
+    fieldName: readerWithRefetchQueries.readerArtifact.fieldName,
+    root: fragmentReference.root,
+  }));
+
   if (response.kind === 'MissingData') {
     // There are two cases here that we care about:
-    // 1. the network request is in flight, we haven't suspend on it, and we want
+    // 1. the network request is in flight, we haven't suspended on it, and we want
     //    to throw if it errors out. So, networkRequestOptions.suspendIfInFlight === false
     //    and networkRequestOptions.throwOnNetworkError === true.
     // 2. everything else
@@ -68,13 +98,27 @@ export function readButDoNotEvaluate<TReadFromStore extends Object>(
       !networkRequestOptions.suspendIfInFlight &&
       networkRequestOptions.throwOnNetworkError
     ) {
-      // TODO assert that the network request state is not Err
+      // What are we doing here? If the network response has errored out, we can do
+      // two things: throw a rejected promise, or throw an error. Both work identically
+      // in the browser. However, during initial SSR on NextJS, throwing a rejected
+      // 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') {
+        throw new Error('NetworkError', { cause: result.error });
+      }
+
       throw new Promise((resolve, reject) => {
-        onNextChange(environment).then(resolve);
+        onNextChangeToRecord(environment, response.recordLink).then(resolve);
         fragmentReference.networkRequest.promise.catch(reject);
       });
     }
-    throw onNextChange(environment);
+    throw onNextChangeToRecord(environment, response.recordLink);
   } else {
     return {
       encounteredRecords: mutableEncounteredRecords,
@@ -83,34 +127,41 @@ export function readButDoNotEvaluate<TReadFromStore extends Object>(
   }
 }
 
-type ReadDataResult<TReadFromStore> =
-  | {
-      readonly kind: 'Success';
-      readonly data: TReadFromStore;
-      readonly encounteredRecords: Set<DataId>;
-    }
+export type ReadDataResultSuccess<Data> = {
+  readonly kind: 'Success';
+  readonly data: Data;
+};
+
+export type ReadDataResult<Data> =
+  | ReadDataResultSuccess<Data>
   | {
       readonly kind: 'MissingData';
       readonly reason: string;
       readonly nestedReason?: ReadDataResult<unknown>;
+      readonly recordLink: Link;
     };
 
 function readData<TReadFromStore>(
   environment: IsographEnvironment,
   ast: ReaderAst<TReadFromStore>,
-  root: DataId,
+  root: Link,
   variables: Variables,
   nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   networkRequest: PromiseWrapper<void, any>,
   networkRequestOptions: NetworkRequestReaderOptions,
-  mutableEncounteredRecords: Set<DataId>,
-): ReadDataResult<TReadFromStore> {
-  mutableEncounteredRecords.add(root);
-  let storeRecord = environment.store[root];
+  mutableEncounteredRecords: EncounteredIds,
+): ReadDataResult<ExtractData<TReadFromStore>> {
+  const encounteredIds = insertIfNotExists(
+    mutableEncounteredRecords,
+    root.__typename,
+  );
+  encounteredIds.add(root.__link);
+  let storeRecord = environment.store[root.__typename]?.[root.__link];
   if (storeRecord === undefined) {
     return {
       kind: 'MissingData',
-      reason: 'No record for root ' + root,
+      reason: 'No record for root ' + root.__link,
+      recordLink: root,
     };
   }
 
@@ -118,7 +169,6 @@ function readData<TReadFromStore>(
     return {
       kind: 'Success',
       data: null as any,
-      encounteredRecords: mutableEncounteredRecords,
     };
   }
 
@@ -127,382 +177,95 @@ function readData<TReadFromStore>(
   for (const field of ast) {
     switch (field.kind) {
       case 'Scalar': {
-        const storeRecordName = getParentRecordKey(field, variables);
-        const value = storeRecord[storeRecordName];
-        // TODO consider making scalars into discriminated unions. This probably has
-        // to happen for when we handle errors.
-        if (value === undefined) {
-          return {
-            kind: 'MissingData',
-            reason: 'No value for ' + storeRecordName + ' on root ' + root,
-          };
+        const data = readScalarFieldData(field, storeRecord, root, variables);
+
+        if (data.kind === 'MissingData') {
+          return data;
         }
-        target[field.alias ?? field.fieldName] = value;
+        target[field.alias ?? field.fieldName] = data.data;
+        break;
+      }
+      case 'Link': {
+        target[field.alias] = root;
         break;
       }
       case 'Linked': {
-        const storeRecordName = getParentRecordKey(field, variables);
-        const value = storeRecord[storeRecordName];
-        if (Array.isArray(value)) {
-          const results = [];
-          for (const item of value) {
-            const link = assertLink(item);
-            if (link === undefined) {
-              return {
-                kind: 'MissingData',
-                reason:
-                  'No link for ' +
-                  storeRecordName +
-                  ' on root ' +
-                  root +
-                  '. Link is ' +
-                  JSON.stringify(item),
-              };
-            } else if (link === null) {
-              results.push(null);
-              continue;
-            }
-            const result = readData(
+        const data = readLinkedFieldData(
+          environment,
+          field,
+          storeRecord,
+          root,
+          variables,
+          networkRequest,
+          (ast, root) =>
+            readData(
               environment,
-              field.selections,
-              link.__link,
+              ast,
+              root,
               variables,
               nestedRefetchQueries,
               networkRequest,
               networkRequestOptions,
               mutableEncounteredRecords,
-            );
-            if (result.kind === 'MissingData') {
-              return {
-                kind: 'MissingData',
-                reason:
-                  'Missing data for ' +
-                  storeRecordName +
-                  ' on root ' +
-                  root +
-                  '. Link is ' +
-                  JSON.stringify(item),
-                nestedReason: result,
-              };
-            }
-            results.push(result.data);
-          }
-          target[field.alias ?? field.fieldName] = results;
-          break;
-        }
-        let link = assertLink(value);
-        if (link === undefined) {
-          // TODO make this configurable, and also generated and derived from the schema
-          const missingFieldHandler =
-            environment.missingFieldHandler ?? defaultMissingFieldHandler;
-          const altLink = missingFieldHandler(
-            storeRecord,
-            root,
-            field.fieldName,
-            field.arguments,
-            variables,
-          );
-          if (altLink === undefined) {
-            return {
-              kind: 'MissingData',
-              reason:
-                'No link for ' +
-                storeRecordName +
-                ' on root ' +
-                root +
-                '. Link is ' +
-                JSON.stringify(value),
-            };
-          } else {
-            link = altLink;
-          }
-        } else if (link === null) {
-          target[field.alias ?? field.fieldName] = null;
-          break;
-        }
-        const targetId = link.__link;
-        const data = readData(
-          environment,
-          field.selections,
-          targetId,
-          variables,
-          nestedRefetchQueries,
-          networkRequest,
-          networkRequestOptions,
-          mutableEncounteredRecords,
+            ),
         );
         if (data.kind === 'MissingData') {
-          return {
-            kind: 'MissingData',
-            reason: 'Missing data for ' + storeRecordName + ' on root ' + root,
-            nestedReason: data,
-          };
+          return data;
         }
         target[field.alias ?? field.fieldName] = data.data;
         break;
       }
       case 'ImperativelyLoadedField': {
-        // First, we read the data using the refetch reader AST (i.e. read out the
-        // id field).
-        const data = readData(
+        const data = readImperativelyLoadedField(
           environment,
-          field.refetchReaderArtifact.readerAst,
+          field,
           root,
           variables,
-          // Refetch fields just read the id, and don't need refetch query artifacts
-          [],
-          // This is probably indicative of the fact that we are doing redundant checks
-          // on the status of this network request...
+          nestedRefetchQueries,
           networkRequest,
           networkRequestOptions,
           mutableEncounteredRecords,
         );
         if (data.kind === 'MissingData') {
-          return {
-            kind: 'MissingData',
-            reason: 'Missing data for ' + field.alias + ' on root ' + root,
-            nestedReason: data,
-          };
-        } else {
-          const refetchQueryIndex = field.refetchQuery;
-          if (refetchQueryIndex == null) {
-            throw new Error('refetchQuery is null in RefetchField');
-          }
-          const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
-          const refetchQueryArtifact = refetchQuery.artifact;
-          const allowedVariables = refetchQuery.allowedVariables;
-
-          // Second, we allow the user to call the resolver, which will ultimately
-          // use the resolver reader AST to get the resolver parameters.
-          target[field.alias] = (args: any) => [
-            // Stable id
-            root + '__' + field.name,
-            // Fetcher
-            field.refetchReaderArtifact.resolver(
-              environment,
-              refetchQueryArtifact,
-              data.data,
-              filterVariables({ ...args, ...variables }, allowedVariables),
-              root,
-              // TODO these params should be removed
-              null,
-              [],
-            ),
-          ];
+          return data;
         }
+        target[field.alias] = data.data;
         break;
       }
       case 'Resolver': {
-        const usedRefetchQueries = field.usedRefetchQueries;
-        const resolverRefetchQueries = usedRefetchQueries.map(
-          (index) => nestedRefetchQueries[index],
+        const data = readResolverFieldData(
+          environment,
+          field,
+          root,
+          variables,
+          nestedRefetchQueries,
+          networkRequest,
+          networkRequestOptions,
+          mutableEncounteredRecords,
         );
-
-        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;
-          }
-          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');
-          }
+        if (data.kind === 'MissingData') {
+          return data;
         }
+        target[field.alias] = data.data;
         break;
       }
       case 'LoadablySelectedField': {
-        const refetchReaderParams = readData(
+        const data = readLoadablySelectedFieldData(
           environment,
-          field.refetchReaderAst,
+          field,
           root,
           variables,
-          // Refetch fields just read the id, and don't need refetch query artifacts
-          [],
           networkRequest,
           networkRequestOptions,
           mutableEncounteredRecords,
         );
-        if (refetchReaderParams.kind === 'MissingData') {
-          return {
-            kind: 'MissingData',
-            reason: 'Missing data for ' + field.alias + ' on root ' + root,
-            nestedReason: refetchReaderParams,
-          };
-        } else {
-          target[field.alias] = (args: any) => {
-            // TODO we should use the reader AST for this
-            const includeReadOutData = (variables: any, readOutData: any) => {
-              variables.id = readOutData.id;
-              return variables;
-            };
-            const localVariables = includeReadOutData(
-              args ?? {},
-              refetchReaderParams.data,
-            );
-            writeQueryArgsToVariables(
-              localVariables,
-              field.queryArguments,
-              variables,
-            );
-
-            return [
-              // Stable id
-              root +
-                '/' +
-                field.name +
-                '/' +
-                stableStringifyArgs(localVariables),
-              // Fetcher
-              () => {
-                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,
-                  );
-                } 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
-
-                    let entrypointLoaderState:
-                      | {
-                          kind: 'EntrypointNotLoaded';
-                        }
-                      | {
-                          kind: 'NetworkRequestStarted';
-                          disposeNetworkRequest: CleanupFn;
-                        }
-                      | { kind: 'Disposed' } = { kind: 'EntrypointNotLoaded' };
-
-                    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' };
-                      },
-                    ];
-                  }
-                }
-              },
-            ];
-          };
+        if (data.kind === 'MissingData') {
+          return data;
         }
+        target[field.alias] = data.data;
         break;
       }
+
       default: {
         // Ensure we have covered all variants
         let _: never = field;
@@ -514,7 +277,172 @@ function readData<TReadFromStore>(
   return {
     kind: 'Success',
     data: target as any,
-    encounteredRecords: mutableEncounteredRecords,
+  };
+}
+
+export function readLoadablySelectedFieldData(
+  environment: IsographEnvironment,
+  field: ReaderLoadableField,
+  root: Link,
+  variables: Variables,
+  networkRequest: PromiseWrapper<void, any>,
+  networkRequestOptions: NetworkRequestReaderOptions,
+  mutableEncounteredRecords: EncounteredIds,
+): ReadDataResult<unknown> {
+  const refetchReaderParams = readData(
+    environment,
+    field.refetchReaderAst,
+    root,
+    variables,
+    // Refetch fields just read the id, and don't need refetch query artifacts
+    [],
+    networkRequest,
+    networkRequestOptions,
+    mutableEncounteredRecords,
+  );
+
+  if (refetchReaderParams.kind === 'MissingData') {
+    return {
+      kind: 'MissingData',
+      reason: 'Missing data for ' + field.alias + ' on root ' + root.__link,
+      nestedReason: refetchReaderParams,
+      recordLink: refetchReaderParams.recordLink,
+    };
+  }
+
+  return {
+    kind: 'Success',
+    data: (
+      args: any,
+      // TODO get the associated type for FetchOptions from the loadably selected field
+      fetchOptions?: FetchOptions<any>,
+    ) => {
+      // TODO we should use the reader AST for this
+      const includeReadOutData = (variables: any, readOutData: any) => {
+        variables.id = readOutData.id;
+        return variables;
+      };
+      const localVariables = includeReadOutData(
+        args ?? {},
+        refetchReaderParams.data,
+      );
+      writeQueryArgsToVariables(
+        localVariables,
+        field.queryArguments,
+        variables,
+      );
+
+      return [
+        // Stable id
+        root.__typename +
+          ':' +
+          root.__link +
+          '/' +
+          field.name +
+          '/' +
+          stableStringifyArgs(localVariables),
+        // Fetcher
+        () => {
+          const fragmentReferenceAndDisposeFromEntrypoint = (
+            entrypoint: IsographEntrypoint<any, any, any>,
+          ): [FragmentReference<any, any>, CleanupFn] => {
+            const [networkRequest, disposeNetworkRequest] =
+              maybeMakeNetworkRequest(
+                environment,
+                entrypoint,
+                localVariables,
+                fetchOptions,
+              );
+
+            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,
+              variables: localVariables,
+              networkRequest,
+            };
+            return [fragmentReference, disposeNetworkRequest];
+          };
+
+          if (field.entrypoint.kind === 'Entrypoint') {
+            return fragmentReferenceAndDisposeFromEntrypoint(field.entrypoint);
+          } 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
+
+              let entrypointLoaderState:
+                | {
+                    kind: 'EntrypointNotLoaded';
+                  }
+                | {
+                    kind: 'NetworkRequestStarted';
+                    disposeNetworkRequest: CleanupFn;
+                  }
+                | { kind: 'Disposed' } = { kind: 'EntrypointNotLoaded' };
+
+              const networkRequest = wrapPromise(
+                isographArtifactPromiseWrapper.promise.then((entrypoint) => {
+                  if (entrypointLoaderState.kind === 'EntrypointNotLoaded') {
+                    const [networkRequest, disposeNetworkRequest] =
+                      maybeMakeNetworkRequest(
+                        environment,
+                        entrypoint,
+                        localVariables,
+                        fetchOptions,
+                      );
+                    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,
+                variables: localVariables,
+                networkRequest,
+              };
+
+              return [
+                fragmentReference,
+                () => {
+                  if (entrypointLoaderState.kind === 'NetworkRequestStarted') {
+                    entrypointLoaderState.disposeNetworkRequest();
+                  }
+                  entrypointLoaderState = { kind: 'Disposed' };
+                },
+              ];
+            }
+          }
+        },
+      ];
+    },
   };
 }
 
@@ -541,8 +469,15 @@ function generateChildVariableMap(
   type Writable<T> = { -readonly [P in keyof T]: T[P] };
   const childVars: Writable<Variables> = {};
   for (const [name, value] of fieldArguments) {
-    if (value.kind === 'Variable') {
-      childVars[name] = variables[value.name];
+    if (value.kind === 'Object') {
+      childVars[name] = generateChildVariableMap(variables, value.value);
+    } else if (value.kind === 'Variable') {
+      const variable = variables[value.name];
+      // Variable could be null if it was not provided but has a default case,
+      // so we allow the loop to continue rather than throwing an error.
+      if (variable != null) {
+        childVars[name] = variable;
+      }
     } else {
       childVars[name] = value.value;
     }
@@ -560,6 +495,14 @@ function writeQueryArgsToVariables(
   }
   for (const [name, argType] of queryArgs) {
     switch (argType.kind) {
+      case 'Object': {
+        writeQueryArgsToVariables(
+          (targetVariables[name] = {}),
+          argType.value,
+          variables,
+        );
+        break;
+      }
       case 'Variable': {
         targetVariables[name] = variables[argType.name];
         break;
@@ -585,6 +528,287 @@ function writeQueryArgsToVariables(
   }
 }
 
+export function readResolverFieldData(
+  environment: IsographEnvironment,
+  field: ReaderNonLoadableResolverField,
+  root: Link,
+  variables: Variables,
+  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
+  networkRequest: PromiseWrapper<void, any>,
+  networkRequestOptions: NetworkRequestReaderOptions,
+  mutableEncounteredRecords: EncounteredIds,
+): ReadDataResult<unknown> {
+  const usedRefetchQueries = field.usedRefetchQueries;
+  const resolverRefetchQueries = usedRefetchQueries.map((index) => {
+    const resolverRefetchQuery = nestedRefetchQueries[index];
+    if (resolverRefetchQuery == null) {
+      throw new Error(
+        'resolverRefetchQuery is null in Resolver. This is indicative of a bug in Isograph.',
+      );
+    }
+    return resolverRefetchQuery;
+  });
+
+  const readerWithRefetchQueries = {
+    kind: 'ReaderWithRefetchQueries',
+    readerArtifact: field.readerArtifact,
+    nestedRefetchQueries: resolverRefetchQueries,
+  } satisfies ReaderWithRefetchQueries<any, any>;
+
+  const fragment = {
+    kind: 'FragmentReference',
+    readerWithRefetchQueries: wrapResolvedValue(readerWithRefetchQueries),
+    root,
+    variables: generateChildVariableMap(variables, field.arguments),
+    networkRequest,
+  } satisfies FragmentReference<any, any>;
+
+  switch (field.readerArtifact.kind) {
+    case 'EagerReaderArtifact': {
+      const data = readData(
+        environment,
+        field.readerArtifact.readerAst,
+        root,
+        generateChildVariableMap(variables, field.arguments),
+        resolverRefetchQueries,
+        networkRequest,
+        networkRequestOptions,
+        mutableEncounteredRecords,
+      );
+      if (data.kind === 'MissingData') {
+        return {
+          kind: 'MissingData',
+          reason: 'Missing data for ' + field.alias + ' on root ' + root.__link,
+          nestedReason: data,
+          recordLink: data.recordLink,
+        };
+      }
+      const firstParameter = {
+        data: data.data,
+        parameters: variables,
+        startUpdate: field.readerArtifact.hasUpdatable
+          ? getOrCreateCachedStartUpdate(
+              environment,
+              fragment,
+              readerWithRefetchQueries.readerArtifact.fieldName,
+            )
+          : undefined,
+      };
+      return {
+        kind: 'Success',
+        data: field.readerArtifact.resolver(firstParameter),
+      };
+    }
+    case 'ComponentReaderArtifact': {
+      return {
+        kind: 'Success',
+        data: getOrCreateCachedComponent(
+          environment,
+          field.readerArtifact.fieldName,
+          fragment,
+          networkRequestOptions,
+        ),
+      };
+    }
+    default: {
+      let _: never = field.readerArtifact;
+      _;
+      throw new Error('Unexpected kind');
+    }
+  }
+}
+
+export function readScalarFieldData(
+  field: ReaderScalarField,
+  storeRecord: StoreRecord,
+  root: Link,
+  variables: Variables,
+): ReadDataResult<string | number | boolean | Link | DataTypeValue[] | null> {
+  const storeRecordName = getParentRecordKey(field, variables);
+  const value = storeRecord[storeRecordName];
+  // TODO consider making scalars into discriminated unions. This probably has
+  // to happen for when we handle errors.
+  if (value === undefined) {
+    return {
+      kind: 'MissingData',
+      reason: 'No value for ' + storeRecordName + ' on root ' + root.__link,
+      recordLink: root,
+    };
+  }
+  return { kind: 'Success', data: value };
+}
+
+export function readLinkedFieldData(
+  environment: IsographEnvironment,
+  field: ReaderLinkedField,
+  storeRecord: StoreRecord,
+  root: Link,
+  variables: Variables,
+  networkRequest: PromiseWrapper<void, any>,
+
+  readData: <TReadFromStore>(
+    ast: ReaderAst<TReadFromStore>,
+    root: Link,
+  ) => ReadDataResult<object>,
+): ReadDataResult<unknown> {
+  const storeRecordName = getParentRecordKey(field, variables);
+  const value = storeRecord[storeRecordName];
+  if (Array.isArray(value)) {
+    const results = [];
+    for (const item of value) {
+      const link = assertLink(item);
+      if (link === undefined) {
+        return {
+          kind: 'MissingData',
+          reason:
+            'No link for ' +
+            storeRecordName +
+            ' on root ' +
+            root.__link +
+            '. Link is ' +
+            JSON.stringify(item),
+          recordLink: root,
+        };
+      } else if (link === null) {
+        results.push(null);
+        continue;
+      }
+
+      const result = readData(field.selections, link);
+      if (result.kind === 'MissingData') {
+        return {
+          kind: 'MissingData',
+          reason:
+            'Missing data for ' +
+            storeRecordName +
+            ' on root ' +
+            root.__link +
+            '. Link is ' +
+            JSON.stringify(item),
+          nestedReason: result,
+          recordLink: result.recordLink,
+        };
+      }
+      results.push(result.data);
+    }
+    return {
+      kind: 'Success',
+      data: results,
+    };
+  }
+  let link = assertLink(value);
+
+  if (field.condition) {
+    const data = readData(field.condition.readerAst, root);
+    if (data.kind === 'MissingData') {
+      return {
+        kind: 'MissingData',
+        reason:
+          'Missing data for ' + storeRecordName + ' on root ' + root.__link,
+        nestedReason: data,
+        recordLink: data.recordLink,
+      };
+    }
+
+    const readerWithRefetchQueries = {
+      kind: 'ReaderWithRefetchQueries',
+      readerArtifact: field.condition,
+      // TODO this is wrong
+      // should map field.condition.usedRefetchQueries
+      // but it doesn't exist
+      nestedRefetchQueries: [],
+    } satisfies ReaderWithRefetchQueries<any, any>;
+
+    const fragment = {
+      kind: 'FragmentReference',
+      readerWithRefetchQueries: wrapResolvedValue(readerWithRefetchQueries),
+      root,
+      variables: generateChildVariableMap(
+        variables,
+        // TODO this is wrong
+        // should use field.condition.variables
+        // but it doesn't exist
+        [],
+      ),
+      networkRequest,
+    } satisfies FragmentReference<any, any>;
+
+    const condition = field.condition.resolver({
+      data: data.data,
+      parameters: {},
+      ...(field.condition.hasUpdatable
+        ? {
+            startUpdate: getOrCreateCachedStartUpdate(
+              environment,
+              fragment,
+              readerWithRefetchQueries.readerArtifact.fieldName,
+            ),
+          }
+        : undefined),
+    });
+    if (condition === true) {
+      link = root;
+    } else if (condition === false) {
+      link = null;
+    } else {
+      link = condition;
+    }
+  }
+
+  if (link === undefined) {
+    // TODO make this configurable, and also generated and derived from the schema
+    const missingFieldHandler = environment.missingFieldHandler;
+
+    const altLink = missingFieldHandler?.(
+      storeRecord,
+      root,
+      field.fieldName,
+      field.arguments,
+      variables,
+    );
+    logMessage(environment, () => ({
+      kind: 'MissingFieldHandlerCalled',
+      root,
+      storeRecord,
+      fieldName: field.fieldName,
+      arguments: field.arguments,
+      variables,
+    }));
+
+    if (altLink === undefined) {
+      return {
+        kind: 'MissingData',
+        reason:
+          'No link for ' +
+          storeRecordName +
+          ' on root ' +
+          root.__link +
+          '. Link is ' +
+          JSON.stringify(value),
+        recordLink: root,
+      };
+    } else {
+      link = altLink;
+    }
+  } else if (link === null) {
+    return {
+      kind: 'Success',
+      data: null,
+    };
+  }
+  const targetId = link;
+  const data = readData(field.selections, targetId);
+  if (data.kind === 'MissingData') {
+    return {
+      kind: 'MissingData',
+      reason: 'Missing data for ' + storeRecordName + ' on root ' + root.__link,
+      nestedReason: data,
+      recordLink: data.recordLink,
+    };
+  }
+  return data;
+}
+
 export type NetworkRequestReaderOptions = {
   suspendIfInFlight: boolean;
   throwOnNetworkError: boolean;
@@ -603,7 +827,7 @@ export function getNetworkRequestOptionsWithDefaults(
 // TODO call stableStringifyArgs on the variable values, as well.
 // This doesn't matter for now, since we are just using primitive values
 // in the demo.
-function stableStringifyArgs(args: Object) {
+function stableStringifyArgs(args: object) {
   const keys = Object.keys(args);
   keys.sort();
   let s = '';
@@ -613,3 +837,69 @@ function stableStringifyArgs(args: Object) {
   }
   return s;
 }
+
+export function readImperativelyLoadedField(
+  environment: IsographEnvironment,
+  field: ReaderImperativelyLoadedField,
+  root: Link,
+  variables: Variables,
+  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
+  networkRequest: PromiseWrapper<void, any>,
+  networkRequestOptions: NetworkRequestReaderOptions,
+  mutableEncounteredRecords: EncounteredIds,
+): ReadDataResult<unknown> {
+  // First, we read the data using the refetch reader AST (i.e. read out the
+  // id field).
+  const data = readData(
+    environment,
+    field.refetchReaderArtifact.readerAst,
+    root,
+    variables,
+    // Refetch fields just read the id, and don't need refetch query artifacts
+    [],
+    // This is probably indicative of the fact that we are doing redundant checks
+    // on the status of this network request...
+    networkRequest,
+    networkRequestOptions,
+    mutableEncounteredRecords,
+  );
+  if (data.kind === 'MissingData') {
+    return {
+      kind: 'MissingData',
+      reason: 'Missing data for ' + field.alias + ' on root ' + root.__link,
+      nestedReason: data,
+      recordLink: data.recordLink,
+    };
+  } else {
+    const refetchQueryIndex = field.refetchQuery;
+    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;
+
+    // Second, we allow the user to call the resolver, which will ultimately
+    // use the resolver reader AST to get the resolver parameters.
+    return {
+      kind: 'Success',
+      data: (args: any) => [
+        // Stable id
+        root.__link + '__' + field.name,
+        // Fetcher
+        field.refetchReaderArtifact.resolver(
+          environment,
+          refetchQueryArtifact,
+          data.data,
+          filterVariables({ ...args, ...variables }, allowedVariables),
+          root,
+          // TODO these params should be removed
+          null,
+          [],
+        ),
+      ],
+    };
+  }
+}