@isograph/react 0.5.0 → 0.5.1

package/src/core/check.ts

@@ -1,12 +1,12 @@
 import { getParentRecordKey } from './cache';
-import { NormalizationAstNodes } from './entrypoint';
-import { Variables } from './FragmentReference';
-import {
-  getLink,
+import type { NormalizationAstNodes } from './entrypoint';
+import type { Variables } from './FragmentReference';
+import type {
   IsographEnvironment,
   StoreLink,
   StoreRecord,
 } from './IsographEnvironment';
+import { getLink } from './IsographEnvironment';
 import { logMessage } from './logging';
 import { getStoreRecordProxy } from './optimisticProxy';
 
@@ -108,12 +108,12 @@ function checkFromRecord(
             kind: 'MissingData',
             record: recordLink,
           };
-        } else if (linkedValue === null) {
+        } else if (linkedValue == null) {
           continue;
         } else if (Array.isArray(linkedValue)) {
           arrayItemsLoop: for (const item of linkedValue) {
             const link = getLink(item);
-            if (link === null) {
+            if (link == null) {
               throw new Error(
                 'Unexpected non-link in the Isograph store. ' +
                   'This is indicative of a bug in Isograph.',
@@ -127,7 +127,7 @@ function checkFromRecord(
                 kind: 'MissingData',
                 record: link,
               };
-            } else if (linkedRecord === null) {
+            } else if (linkedRecord == null) {
               continue arrayItemsLoop;
             } else {
               // TODO in __DEV__ assert linkedRecord is an object
@@ -146,7 +146,7 @@ function checkFromRecord(
           }
         } else {
           const link = getLink(linkedValue);
-          if (link === null) {
+          if (link == null) {
             throw new Error(
               'Unexpected non-link in the Isograph store. ' +
                 'This is indicative of a bug in Isograph.',
@@ -160,7 +160,7 @@ function checkFromRecord(
               kind: 'MissingData',
               record: link,
             };
-          } else if (linkedRecord === null) {
+          } else if (linkedRecord == null) {
             continue normalizationAstLoop;
           } else {
             // TODO in __DEV__ assert linkedRecord is an object
@@ -206,13 +206,6 @@ function checkFromRecord(
 
         continue normalizationAstLoop;
       }
-      default: {
-        let _: never = normalizationAstNode;
-        _;
-        throw new Error(
-          'Unexpected case. This is indicative of a bug in Isograph.',
-        );
-      }
     }
   }
 

package/src/core/componentCache.ts

@@ -1,13 +1,7 @@
-import { useReadAndSubscribe } from '../react/useReadAndSubscribe';
-import { maybeUnwrapNetworkRequest } from '../react/useResult';
-import {
-  FragmentReference,
-  stableIdForFragmentReference,
-} from './FragmentReference';
-import { IsographEnvironment } from './IsographEnvironment';
-import { logMessage } from './logging';
-import { readPromise } from './PromiseWrapper';
-import { NetworkRequestReaderOptions } from './read';
+import type { FragmentReference } from './FragmentReference';
+import { stableIdForFragmentReference } from './FragmentReference';
+import type { IsographEnvironment } from './IsographEnvironment';
+import type { NetworkRequestReaderOptions } from './read';
 import { createStartUpdate } from './startUpdate';
 
 export function getOrCreateCachedComponent(
@@ -24,41 +18,10 @@ export function getOrCreateCachedComponent(
 
   return (environment.componentCache[
     stableIdForFragmentReference(fragmentReference)
-  ] ??= (() => {
-    function Component(additionalRuntimeProps: { [key: string]: any }) {
-      maybeUnwrapNetworkRequest(
-        fragmentReference.networkRequest,
-        networkRequestOptions,
-      );
-      const readerWithRefetchQueries = readPromise(
-        fragmentReference.readerWithRefetchQueries,
-      );
-
-      const data = useReadAndSubscribe(
-        fragmentReference,
-        networkRequestOptions,
-        readerWithRefetchQueries.readerArtifact.readerAst,
-      );
-
-      logMessage(environment, () => ({
-        kind: 'ComponentRerendered',
-        componentName: fragmentReference.fieldName,
-        rootLink: fragmentReference.root,
-      }));
-
-      return readerWithRefetchQueries.readerArtifact.resolver(
-        {
-          data,
-          parameters: fragmentReference.variables,
-          startUpdate: readerWithRefetchQueries.readerArtifact.hasUpdatable
-            ? startUpdate
-            : undefined,
-        },
-        additionalRuntimeProps,
-      );
-    }
-    const idString = `(type: ${fragmentReference.root.__typename}, id: ${fragmentReference.root.__link})`;
-    Component.displayName = `${fragmentReference.fieldName} ${idString} @component`;
-    return Component;
-  })());
+  ] ??= environment.componentFunction(
+    environment,
+    fragmentReference,
+    networkRequestOptions,
+    startUpdate,
+  ));
 }

package/src/core/entrypoint.ts

@@ -1,9 +1,12 @@
 import type { Contravariant, PhantomData } from './brand';
 import type { NetworkResponseObject } from './cache';
-import type { UnknownTReadFromStore } from './FragmentReference';
+import type {
+  FragmentReference,
+  UnknownTReadFromStore,
+} from './FragmentReference';
 import type { ComponentOrFieldName, TypeName } from './IsographEnvironment';
-import { TopLevelReaderArtifact } from './reader';
-import { Arguments } from './util';
+import type { TopLevelReaderArtifact } from './reader';
+import type { Arguments } from './util';
 
 export type ReaderWithRefetchQueries<
   TReadFromStore extends UnknownTReadFromStore,
@@ -75,6 +78,13 @@ export type IsographEntrypoint<
   readonly '~TRawResponseType'?: PhantomData<Contravariant<TRawResponseType>>;
 };
 
+export type FragmentReferenceOfEntrypoint<
+  TEntrypoint extends IsographEntrypoint<any, any, any, any>,
+> = FragmentReference<
+  ExtractReadFromStore<TEntrypoint>,
+  ExtractClientFieldValue<TEntrypoint>
+>;
+
 export type IsographEntrypointLoader<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
@@ -173,6 +183,8 @@ export function assertIsEntrypoint<
 
 export type ExtractReadFromStore<Type> =
   Type extends IsographEntrypoint<infer X, any, any, any> ? X : never;
+export type ExtractClientFieldValue<Type> =
+  Type extends IsographEntrypoint<any, infer X, any, any> ? X : never;
 export type ExtractRawResponseType<Type> =
   Type extends IsographEntrypoint<any, any, any, infer X> ? X : never;
 export type ExtractResolverResult<Type> =

package/src/core/garbageCollection.ts

@@ -1,11 +1,11 @@
-import { getParentRecordKey } from './cache';
-import { NormalizationAstNodes, type NormalizationAst } from './entrypoint';
-import { Variables } from './FragmentReference';
+import { getParentRecordKey, TYPENAME_FIELD_NAME } from './cache';
+import type { NormalizationAstNodes, NormalizationAst } from './entrypoint';
+import type { Variables } from './FragmentReference';
 import {
   assertLink,
-  DataId,
-  IsographEnvironment,
-  StoreRecord,
+  type DataId,
+  type IsographEnvironment,
+  type StoreRecord,
   type StoreLayerData,
   type StoreLink,
   type TypeName,
@@ -101,7 +101,7 @@ export function garbageCollectBaseStoreLayer(
     const retainedTypeIds = retainedIds[typeName];
 
     // delete all objects
-    if (retainedTypeIds == undefined || retainedTypeIds.size == 0) {
+    if (retainedTypeIds === undefined || retainedTypeIds.size === 0) {
       delete baseStoreLayer.data[typeName];
       continue;
     }
@@ -135,7 +135,7 @@ function recordReachableIds(
   ] ??= new Set());
   retainedRecordsIds.add(retainedQuery.root.__link);
 
-  if (record) {
+  if (record != null) {
     recordReachableIdsFromRecord(
       dataLayer,
       record,
@@ -155,6 +155,17 @@ function recordReachableIdsFromRecord(
 ) {
   for (const selection of selections) {
     switch (selection.kind) {
+      case 'InlineFragment':
+        if (currentRecord[TYPENAME_FIELD_NAME] === selection.type) {
+          recordReachableIdsFromRecord(
+            dataLayer,
+            currentRecord,
+            mutableRetainedIds,
+            selection.selections,
+            variables,
+          );
+        }
+        continue;
       case 'Linked':
         const linkKey = getParentRecordKey(selection, variables ?? {});
         const linkedFieldOrFields = currentRecord[linkKey];
@@ -175,11 +186,11 @@ function recordReachableIdsFromRecord(
         }
 
         let typeStore =
-          selection.concreteType !== null
+          selection.concreteType != null
             ? dataLayer[selection.concreteType]
             : null;
 
-        if (typeStore == null && selection.concreteType !== null) {
+        if (typeStore == null && selection.concreteType != null) {
           continue;
         }
 

package/src/core/getOrCreateCacheForArtifact.ts

@@ -0,0 +1,86 @@
+import type { ItemCleanupPair } from '@isograph/isograph-disposable-types/dist';
+import type { ParentCache } from '@isograph/isograph-react-disposable-state/dist';
+import {
+  type NetworkResponseObject,
+  getOrCreateItemInSuspenseCache,
+} from './cache';
+import type { FetchOptions } from './check';
+import type {
+  IsographEntrypoint,
+  NormalizationAst,
+  NormalizationAstLoader,
+} from './entrypoint';
+import type {
+  ExtractParameters,
+  FragmentReference,
+  UnknownTReadFromStore,
+} from './FragmentReference';
+import {
+  type IsographEnvironment,
+  getOrLoadReaderWithRefetchQueries,
+  ROOT_ID,
+} from './IsographEnvironment';
+import { maybeMakeNetworkRequest } from './makeNetworkRequest';
+import { stableCopy } from './util';
+
+export function getOrCreateCacheForArtifact<
+  TReadFromStore extends UnknownTReadFromStore,
+  TClientFieldValue,
+  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
+>(
+  environment: IsographEnvironment,
+  entrypoint: IsographEntrypoint<
+    TReadFromStore,
+    TClientFieldValue,
+    TNormalizationAst,
+    TRawResponseType
+  >,
+  variables: ExtractParameters<TReadFromStore>,
+  fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>,
+): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>> {
+  let cacheKey = '';
+  switch (entrypoint.networkRequestInfo.operation.kind) {
+    case 'Operation':
+      cacheKey =
+        entrypoint.networkRequestInfo.operation.text +
+        JSON.stringify(stableCopy(variables));
+      break;
+    case 'PersistedOperation':
+      cacheKey =
+        entrypoint.networkRequestInfo.operation.operationId +
+        JSON.stringify(stableCopy(variables));
+      break;
+  }
+  const factory = () => {
+    const { fieldName, readerArtifactKind, readerWithRefetchQueries } =
+      getOrLoadReaderWithRefetchQueries(
+        environment,
+        entrypoint.readerWithRefetchQueries,
+      );
+    const [networkRequest, disposeNetworkRequest] = maybeMakeNetworkRequest(
+      environment,
+      entrypoint,
+      variables,
+      readerWithRefetchQueries,
+      fetchOptions ?? null,
+    );
+
+    const itemCleanupPair: ItemCleanupPair<
+      FragmentReference<TReadFromStore, TClientFieldValue>
+    > = [
+      {
+        kind: 'FragmentReference',
+        readerWithRefetchQueries,
+        fieldName,
+        readerArtifactKind,
+        root: { __link: ROOT_ID, __typename: entrypoint.concreteType },
+        variables,
+        networkRequest: networkRequest,
+      },
+      disposeNetworkRequest,
+    ];
+    return itemCleanupPair;
+  };
+  return getOrCreateItemInSuspenseCache(environment, cacheKey, factory);
+}

package/src/core/logging.ts

@@ -1,19 +1,19 @@
-import { CleanupFn } from '@isograph/disposable-types';
-import { NetworkResponseObject, type EncounteredIds } from './cache';
-import { CheckResult } from './check';
-import {
+import type { CleanupFn } from '@isograph/disposable-types';
+import type { NetworkResponseObject, EncounteredIds } from './cache';
+import type { CheckResult } from './check';
+import type {
   IsographEntrypoint,
   RefetchQueryNormalizationArtifact,
-  type NormalizationAstNodes,
+  NormalizationAstNodes,
 } from './entrypoint';
-import { FragmentReference, Variables } from './FragmentReference';
-import {
+import type { FragmentReference, Variables } from './FragmentReference';
+import type {
   IsographEnvironment,
   StoreRecord,
-  type StoreLink,
+  StoreLink,
 } from './IsographEnvironment';
-import { ReadDataResult } from './read';
-import { Arguments } from './util';
+import type { ReadDataResult } from './read';
+import type { Arguments } from './util';
 import type { StoreLayer } from './optimisticProxy';
 
 /**

package/src/core/makeNetworkRequest.ts

@@ -1,31 +1,32 @@
-import { ItemCleanupPair } from '@isograph/disposable-types';
+import type { ItemCleanupPair } from '@isograph/disposable-types';
 import {
-  callSubscriptions,
   normalizeData,
   type EncounteredIds,
   type NetworkResponseObject,
 } from './cache';
-import { check, DEFAULT_SHOULD_FETCH_VALUE, FetchOptions } from './check';
+import type { FetchOptions } from './check';
+import { check, DEFAULT_SHOULD_FETCH_VALUE } from './check';
 import { getOrCreateCachedComponent } from './componentCache';
-import {
+import type {
   IsographEntrypoint,
+  NormalizationAst,
+  NormalizationAstLoader,
   ReaderWithRefetchQueries,
   RefetchQueryNormalizationArtifact,
-  type NormalizationAst,
-  type NormalizationAstLoader,
 } from './entrypoint';
-import {
+import type {
   ExtractParameters,
-  type FragmentReference,
-  type UnknownTReadFromStore,
+  FragmentReference,
+  UnknownTReadFromStore,
 } from './FragmentReference';
+import type { RetainedQuery } from './garbageCollection';
 import {
   garbageCollectEnvironment,
-  RetainedQuery,
   retainQuery,
   unretainQuery,
 } from './garbageCollection';
-import { IsographEnvironment, ROOT_ID, StoreLink } from './IsographEnvironment';
+import type { IsographEnvironment, StoreLink } from './IsographEnvironment';
+import { ROOT_ID } from './IsographEnvironment';
 import { logMessage } from './logging';
 import {
   addNetworkResponseStoreLayer,
@@ -34,14 +35,11 @@ import {
   type OptimisticStoreLayer,
   type StoreLayerWithData,
 } from './optimisticProxy';
-import {
-  AnyError,
-  PromiseWrapper,
-  wrapPromise,
-  wrapResolvedValue,
-} from './PromiseWrapper';
+import type { AnyError, PromiseWrapper } from './PromiseWrapper';
+import { wrapPromise, wrapResolvedValue } from './PromiseWrapper';
 import { readButDoNotEvaluate } from './read';
 import { getOrCreateCachedStartUpdate } from './startUpdate';
+import { callSubscriptions } from './subscribe';
 
 let networkRequestId = 0;
 
@@ -460,11 +458,6 @@ function readDataForOnComplete<
             : undefined),
         });
       }
-      default: {
-        const _: never = readerArtifact;
-        _;
-        throw new Error('Expected case');
-      }
     }
   }
   return null;
@@ -557,7 +550,7 @@ function revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(
   status: NetworkRequestStatusUndisposedIncomplete,
   normalizeData: null | ((storeLayer: StoreLayerWithData) => void),
 ): NetworkRequestStatusUndisposedComplete {
-  if (status.optimistic) {
+  if (status.optimistic != null) {
     revertOptimisticStoreLayerAndMaybeReplace(
       environment,
       status.optimistic,

package/src/core/optimisticProxy.ts

@@ -1,8 +1,5 @@
-import {
-  callSubscriptions,
-  insertEmptySetIfMissing,
-  type EncounteredIds,
-} from './cache';
+import { insertEmptySetIfMissing, type EncounteredIds } from './cache';
+import { callSubscriptions } from './subscribe';
 import type {
   BaseStoreLayerData,
   IsographEnvironment,
@@ -29,15 +26,18 @@ export function getStoreRecordProxy(
   link: StoreLink,
 ): Readonly<StoreRecord> | null | undefined {
   let startNode: StoreLayer | null = storeLayer;
-  while (startNode !== null) {
+  while (startNode != null) {
     const storeRecord = startNode.data[link.__typename]?.[link.__link];
-    if (storeRecord === null) {
-      return null;
+    if (storeRecord === undefined) {
+      startNode = startNode.parentStoreLayer;
+      continue;
     }
-    if (storeRecord != null) {
-      return getMutableStoreRecordProxy(startNode, link);
+
+    if (storeRecord == null) {
+      return null;
     }
-    startNode = startNode.parentStoreLayer;
+
+    return getMutableStoreRecordProxy(startNode, link);
   }
 
   return undefined;
@@ -52,13 +52,13 @@ export function getMutableStoreRecordProxy(
     {
       get(_, propertyName) {
         let currentStoreLayer: StoreLayer | null = childMostStoreLayer;
-        while (currentStoreLayer !== null) {
+        while (currentStoreLayer != null) {
           const storeRecord =
             currentStoreLayer.data[link.__typename]?.[link.__link];
-          if (storeRecord === null) {
-            return undefined;
-          }
-          if (storeRecord != null) {
+          if (storeRecord !== undefined) {
+            if (storeRecord == null) {
+              return undefined;
+            }
             const value = Reflect.get(storeRecord, propertyName);
             if (value !== undefined) {
               return value;
@@ -69,15 +69,16 @@ export function getMutableStoreRecordProxy(
       },
       has(_, propertyName) {
         let currentStoreLayer: StoreLayer | null = childMostStoreLayer;
-        while (currentStoreLayer !== null) {
+        while (currentStoreLayer != null) {
           const storeRecord =
             currentStoreLayer.data[link.__typename]?.[link.__link];
-          if (storeRecord === null) {
-            return false;
-          }
-          if (storeRecord != null) {
+          if (storeRecord !== undefined) {
+            if (storeRecord == null) {
+              return false;
+            }
+
             const value = Reflect.has(storeRecord, propertyName);
-            if (value !== undefined) {
+            if (value) {
               return true;
             }
           }
@@ -178,10 +179,6 @@ export function addNetworkResponseStoreLayer(
 
       return node;
     }
-    default: {
-      parent satisfies never;
-      throw new Error('Unreachable. This is a bug in Isograph.');
-    }
   }
 }
 
@@ -193,7 +190,7 @@ function mergeDataLayer(target: StoreLayerData, source: StoreLayerData): void {
     }
     const targetRecordById = (target[typeName] ??= {});
     for (const [id, sourceRecord] of Object.entries(sourceById)) {
-      if (sourceRecord === null) {
+      if (sourceRecord == null) {
         targetRecordById[id] = null;
         continue;
       }
@@ -239,10 +236,6 @@ export function addStartUpdateStoreLayer(
       startUpdate(node);
       return node;
     }
-    default: {
-      parent satisfies never;
-      throw new Error('Unreachable. This is a bug in Isograph.');
-    }
   }
 }
 
@@ -269,10 +262,6 @@ export function addOptimisticUpdaterStoreLayer(
 
       return node;
     }
-    default: {
-      parent satisfies never;
-      throw new Error('Unreachable. This is a bug in Isograph.');
-    }
   }
 }
 
@@ -296,10 +285,6 @@ export function addOptimisticNetworkResponseStoreLayer(
 
       return node;
     }
-    default: {
-      parent satisfies never;
-      throw new Error('Unreachable. This is a bug in Isograph.');
-    }
   }
 }
 
@@ -321,7 +306,7 @@ function mergeLayersWithDataIntoBaseLayer(
   baseStoreLayer: BaseStoreLayer,
 ) {
   while (
-    storeLayerToMerge &&
+    storeLayerToMerge != null &&
     storeLayerToMerge.kind !== 'OptimisticUpdaterStoreLayer'
   ) {
     mergeDataLayer(baseStoreLayer.data, storeLayerToMerge.data);
@@ -355,7 +340,7 @@ function reexecuteUpdatesAndMergeData(
   // reflects whatever replaced the optimistic layer
   newMergedData: StoreLayerData,
 ): void {
-  while (storeLayer !== null) {
+  while (storeLayer != null) {
     mergeDataLayer(oldMergedData, storeLayer.data);
     switch (storeLayer.kind) {
       case 'OptimisticNetworkResponseStoreLayer':
@@ -371,10 +356,6 @@ function reexecuteUpdatesAndMergeData(
         storeLayer.startUpdate(storeLayer);
         break;
       }
-      default: {
-        storeLayer satisfies never;
-        throw new Error('Unreachable. This is a bug in Isograph.');
-      }
     }
     mergeDataLayer(newMergedData, storeLayer.data);
 
@@ -394,7 +375,7 @@ function setChildOfNode<TStoreLayer extends StoreLayer>(
   newChildStoreLayer: TStoreLayer['childStoreLayer'],
 ) {
   storeLayerToModify.childStoreLayer = newChildStoreLayer;
-  if (newChildStoreLayer !== null) {
+  if (newChildStoreLayer != null) {
     newChildStoreLayer.parentStoreLayer = storeLayerToModify;
   } else {
     environment.store = storeLayerToModify;
@@ -427,7 +408,7 @@ export function revertOptimisticStoreLayerAndMaybeReplace(
 
   let newMergedData = {};
   let childNode = optimisticNode.childStoreLayer;
-  if (normalizeData !== null) {
+  if (normalizeData != null) {
     const networkResponseStoreLayer: NetworkResponseStoreLayer = {
       kind: 'NetworkResponseStoreLayer',
       data: {},