@isograph/react 0.3.0 → 0.3.1

package/src/core/logging.ts

@@ -1,31 +1,25 @@
 import { CleanupFn } from '@isograph/disposable-types';
+import { NetworkResponseObject, type EncounteredIds } from './cache';
+import { CheckResult } from './check';
+import {
+  IsographEntrypoint,
+  RefetchQueryNormalizationArtifact,
+  type NormalizationAstNodes,
+} from './entrypoint';
+import { FragmentReference, Variables } from './FragmentReference';
 import {
   IsographEnvironment,
   IsographStore,
   StoreRecord,
   type Link,
 } from './IsographEnvironment';
-import {
-  IsographEntrypoint,
-  NormalizationAst,
-  RefetchQueryNormalizationArtifact,
-} from './entrypoint';
-import { FragmentReference, Variables } from './FragmentReference';
-import { NetworkResponseObject, type EncounteredIds } from './cache';
-import { Arguments } from './util';
 import { ReadDataResult } from './read';
-import { CheckResult } from './check';
+import { Arguments } from './util';
 
 export type LogMessage =
-  | {
-      kind: 'GettingSuspenseCacheItem';
-      index: string;
-      availableCacheItems: ReadonlyArray<string>;
-      found: boolean;
-    }
   | {
       kind: 'AboutToNormalize';
-      normalizationAst: NormalizationAst;
+      normalizationAst: NormalizationAstNodes;
       networkResponse: NetworkResponseObject;
       variables: Variables;
     }
@@ -50,7 +44,7 @@ export type LogMessage =
       kind: 'MakeNetworkRequest';
       artifact:
         | RefetchQueryNormalizationArtifact
-        | IsographEntrypoint<any, any>;
+        | IsographEntrypoint<any, any, any>;
       variables: Variables;
       networkRequestId: string;
     }
@@ -76,6 +70,8 @@ export type LogMessage =
   | {
       kind: 'DoneReading';
       response: ReadDataResult<any>;
+      fieldName: string;
+      root: Link;
     }
   | {
       kind: 'NonEntrypointReceived';
@@ -84,6 +80,9 @@ export type LogMessage =
   | {
       kind: 'EnvironmentCheck';
       result: CheckResult;
+    }
+  | {
+      kind: 'EnvironmentCreated';
     };
 
 export type LogFunction = (logMessage: LogMessage) => void;
@@ -95,12 +94,15 @@ export type WrappedLogFunction = {
 
 export function logMessage(
   environment: IsographEnvironment,
-  message: LogMessage,
+  getMessage: () => LogMessage,
 ) {
-  for (const logger of environment.loggers) {
-    try {
-      logger.log(message);
-    } catch {}
+  if (environment.loggers.size > 0) {
+    const message = getMessage();
+    for (const logger of environment.loggers) {
+      try {
+        logger.log(message);
+      } catch {}
+    }
   }
 }
 

package/src/core/makeNetworkRequest.ts

@@ -1,33 +1,48 @@
 import { ItemCleanupPair } from '@isograph/disposable-types';
+import { normalizeData } from './cache';
+import { check, DEFAULT_SHOULD_FETCH_VALUE, FetchOptions } from './check';
+import { getOrCreateCachedComponent } from './componentCache';
 import {
   IsographEntrypoint,
   RefetchQueryNormalizationArtifact,
+  type NormalizationAst,
+  type NormalizationAstLoader,
 } from './entrypoint';
-import { Variables } from './FragmentReference';
+import {
+  ExtractParameters,
+  type FragmentReference,
+  type UnknownTReadFromStore,
+} from './FragmentReference';
 import {
   garbageCollectEnvironment,
   RetainedQuery,
   retainQuery,
   unretainQuery,
 } from './garbageCollection';
-import { IsographEnvironment, ROOT_ID } from './IsographEnvironment';
+import { IsographEnvironment, Link, ROOT_ID } from './IsographEnvironment';
+import { logMessage } from './logging';
 import {
   AnyError,
   PromiseWrapper,
   wrapPromise,
   wrapResolvedValue,
 } from './PromiseWrapper';
-import { normalizeData } from './cache';
-import { logMessage } from './logging';
-import { check, DEFAULT_SHOULD_FETCH_VALUE, FetchOptions } from './check';
+import { readButDoNotEvaluate } from './read';
+import { getOrCreateCachedStartUpdate } from './startUpdate';
 
 let networkRequestId = 0;
 
-export function maybeMakeNetworkRequest(
+export function maybeMakeNetworkRequest<
+  TReadFromStore extends UnknownTReadFromStore,
+  TClientFieldValue,
+  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+>(
   environment: IsographEnvironment,
-  artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<any, any>,
-  variables: Variables,
-  fetchOptions?: FetchOptions,
+  artifact:
+    | RefetchQueryNormalizationArtifact
+    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>,
+  variables: ExtractParameters<TReadFromStore>,
+  fetchOptions?: FetchOptions<TClientFieldValue>,
 ): ItemCleanupPair<PromiseWrapper<void, AnyError>> {
   switch (fetchOptions?.shouldFetch ?? DEFAULT_SHOULD_FETCH_VALUE) {
     case 'Yes': {
@@ -37,15 +52,24 @@ export function maybeMakeNetworkRequest(
       return [wrapResolvedValue(undefined), () => {}];
     }
     case 'IfNecessary': {
+      if (
+        artifact.networkRequestInfo.normalizationAst.kind ===
+        'NormalizationAstLoader'
+      ) {
+        throw new Error(
+          'Using lazy loaded normalizationAst with shouldFetch: "IfNecessary" is not supported as it will lead to slower initial load time.',
+        );
+      }
       const result = check(
         environment,
-        artifact.networkRequestInfo.normalizationAst,
+        artifact.networkRequestInfo.normalizationAst.selections,
         variables,
         {
           __link: ROOT_ID,
           __typename: artifact.concreteType,
         },
       );
+
       if (result.kind === 'EnoughData') {
         return [wrapResolvedValue(undefined), () => {}];
       } else {
@@ -60,51 +84,74 @@ export function maybeMakeNetworkRequest(
   }
 }
 
-export function makeNetworkRequest(
+function loadNormalizationAst(
+  normalizationAst: NormalizationAstLoader | NormalizationAst,
+) {
+  switch (normalizationAst.kind) {
+    case 'NormalizationAst': {
+      return normalizationAst;
+    }
+    case 'NormalizationAstLoader': {
+      return normalizationAst.loader();
+    }
+  }
+}
+
+export function makeNetworkRequest<
+  TReadFromStore extends UnknownTReadFromStore,
+  TClientFieldValue,
+  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+>(
   environment: IsographEnvironment,
-  artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<any, any>,
-  variables: Variables,
-  fetchOptions?: FetchOptions,
+  artifact:
+    | RefetchQueryNormalizationArtifact
+    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>,
+  variables: ExtractParameters<TReadFromStore>,
+  fetchOptions?: FetchOptions<TClientFieldValue>,
 ): ItemCleanupPair<PromiseWrapper<void, AnyError>> {
   // TODO this should be a DataId and stored in the store
   const myNetworkRequestId = networkRequestId + '';
   networkRequestId++;
 
-  logMessage(environment, {
+  logMessage(environment, () => ({
     kind: 'MakeNetworkRequest',
     artifact,
     variables,
     networkRequestId: myNetworkRequestId,
-  });
+  }));
 
   let status: NetworkRequestStatus = {
     kind: 'UndisposedIncomplete',
   };
   // This should be an observable, not a promise
-  const promise = environment
-    .networkFunction(artifact.networkRequestInfo.queryText, variables)
-    .then((networkResponse) => {
-      logMessage(environment, {
+  const promise = Promise.all([
+    environment.networkFunction(
+      artifact.networkRequestInfo.queryText,
+      variables,
+    ),
+    loadNormalizationAst(artifact.networkRequestInfo.normalizationAst),
+  ])
+    .then(([networkResponse, normalizationAst]) => {
+      logMessage(environment, () => ({
         kind: 'ReceivedNetworkResponse',
         networkResponse,
         networkRequestId: myNetworkRequestId,
-      });
+      }));
 
       if (networkResponse.errors != null) {
         try {
           fetchOptions?.onError?.();
         } catch {}
-        // @ts-expect-error Why are we getting the wrong constructor here?
         throw new Error('GraphQL network response had errors', {
           cause: networkResponse,
         });
       }
 
+      const root = { __link: ROOT_ID, __typename: artifact.concreteType };
       if (status.kind === 'UndisposedIncomplete') {
-        const root = { __link: ROOT_ID, __typename: artifact.concreteType };
         normalizeData(
           environment,
-          artifact.networkRequestInfo.normalizationAst,
+          normalizationAst.selections,
           networkResponse.data ?? {},
           variables,
           artifact.kind === 'Entrypoint'
@@ -113,7 +160,7 @@ export function makeNetworkRequest(
           root,
         );
         const retainedQuery = {
-          normalizationAst: artifact.networkRequestInfo.normalizationAst,
+          normalizationAst: normalizationAst.selections,
           variables,
           root,
         };
@@ -124,16 +171,30 @@ export function makeNetworkRequest(
         retainQuery(environment, retainedQuery);
       }
 
-      try {
-        fetchOptions?.onComplete?.();
-      } catch {}
+      const onComplete = fetchOptions?.onComplete;
+      if (onComplete != null) {
+        let data = readDataForOnComplete(
+          artifact,
+          environment,
+          root,
+          variables,
+        );
+
+        try {
+          // @ts-expect-error this problem will be fixed when we remove RefetchQueryNormalizationArtifact
+          // (or we can fix this by having a single param of type { kind: 'Entrypoint', entrypoint,
+          // fetchOptions: FetchOptions<TReadFromStore> } | { kind: 'RefetchQuery', refetchQuery,
+          // fetchOptions: FetchOptions<void> }).
+          onComplete(data);
+        } catch {}
+      }
     })
     .catch((e) => {
-      logMessage(environment, {
+      logMessage(environment, () => ({
         kind: 'ReceivedNetworkError',
         networkRequestId: myNetworkRequestId,
         error: e,
-      });
+      }));
       try {
         fetchOptions?.onError?.();
       } catch {}
@@ -173,3 +234,95 @@ type NetworkRequestStatus =
       readonly kind: 'UndisposedComplete';
       readonly retainedQuery: RetainedQuery;
     };
+
+function readDataForOnComplete<
+  TReadFromStore extends UnknownTReadFromStore,
+  TClientFieldValue,
+  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+>(
+  artifact:
+    | RefetchQueryNormalizationArtifact
+    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>,
+  environment: IsographEnvironment,
+  root: Link,
+  variables: ExtractParameters<TReadFromStore>,
+): 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.
+  // This is awkward, since we don't express that in the types of the parameters
+  // (i.e. FetchOptions could be passed, along with a RefetchQueryNormalizationArtifact).
+  //
+  // However, this isn't a big deal: RefetchQueryNormalizationArtifact is going away.
+  if (artifact.kind === 'Entrypoint') {
+    // TODO this is a smell!
+    const fakeNetworkRequest = wrapResolvedValue(undefined);
+    // TODO this is a smell — we know the network response is not in flight,
+    // so we don't really care!
+    const fakeNetworkRequestOptions = {
+      suspendIfInFlight: false,
+      throwOnNetworkError: false,
+    };
+
+    const fragment: FragmentReference<TReadFromStore, TClientFieldValue> = {
+      kind: 'FragmentReference',
+      // TODO this smells.
+      readerWithRefetchQueries: wrapResolvedValue(
+        artifact.readerWithRefetchQueries,
+      ),
+      root,
+      variables,
+      networkRequest: fakeNetworkRequest,
+    };
+    const fragmentResult = readButDoNotEvaluate(
+      environment,
+      fragment,
+      fakeNetworkRequestOptions,
+    ).item;
+    const readerArtifact = artifact.readerWithRefetchQueries.readerArtifact;
+    switch (readerArtifact.kind) {
+      case 'ComponentReaderArtifact': {
+        // @ts-expect-error We should find a way to encode this in the type system:
+        // if we have a ComponentReaderArtifact, we will necessarily have a
+        // TClientFieldValue which is a React.FC<...>
+        return getOrCreateCachedComponent(
+          environment,
+          readerArtifact.fieldName,
+          {
+            kind: 'FragmentReference',
+            readerWithRefetchQueries: wrapResolvedValue({
+              kind: 'ReaderWithRefetchQueries',
+              readerArtifact: readerArtifact,
+              nestedRefetchQueries:
+                artifact.readerWithRefetchQueries.nestedRefetchQueries,
+            }),
+            root,
+            variables,
+            networkRequest: fakeNetworkRequest,
+          } as const,
+          fakeNetworkRequestOptions,
+        );
+      }
+      case 'EagerReaderArtifact': {
+        return readerArtifact.resolver({
+          data: fragmentResult,
+          parameters: variables,
+          ...(readerArtifact.hasUpdatable
+            ? {
+                startUpdate: getOrCreateCachedStartUpdate(
+                  environment,
+                  fragment,
+                  artifact.readerWithRefetchQueries.readerArtifact.fieldName,
+                ),
+              }
+            : undefined),
+        });
+      }
+      default: {
+        const _: never = readerArtifact;
+        _;
+        throw new Error('Expected case');
+      }
+    }
+  }
+  return null;
+}