@isograph/react 0.3.1 → 0.4.1

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;