@isograph/react 0.0.0-main-e403ba82 → 0.0.0-main-82cbc3c0

package/src/core/garbageCollection.ts

@@ -1,11 +1,11 @@
 import { getParentRecordKey } from './cache';
-import { NormalizationAstNodes, type NormalizationAst } from './entrypoint';
-import { Variables } from './FragmentReference';
+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;
     }
@@ -175,11 +175,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,23 +1,22 @@
-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 { 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 {
   garbageCollectEnvironment,
@@ -42,6 +41,7 @@ import {
 } from './PromiseWrapper';
 import { readButDoNotEvaluate } from './read';
 import { getOrCreateCachedStartUpdate } from './startUpdate';
+import { callSubscriptions } from './subscribe';
 
 let networkRequestId = 0;
 

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;
             }
           }
@@ -193,7 +194,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;
       }
@@ -355,7 +356,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':
@@ -394,7 +395,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 +428,7 @@ export function revertOptimisticStoreLayerAndMaybeReplace(
 
   let newMergedData = {};
   let childNode = optimisticNode.childStoreLayer;
-  if (normalizeData !== null) {
+  if (normalizeData != null) {
     const networkResponseStoreLayer: NetworkResponseStoreLayer = {
       kind: 'NetworkResponseStoreLayer',
       data: {},

package/src/core/read.ts

@@ -1,4 +1,4 @@
-import { CleanupFn, type ItemCleanupPair } from '@isograph/disposable-types';
+import type { CleanupFn, ItemCleanupPair } from '@isograph/disposable-types';
 import {
   getParentRecordKey,
   insertEmptySetIfMissing,
@@ -7,16 +7,16 @@ import {
 } from './cache';
 import { FetchOptions } from './check';
 import { getOrCreateCachedComponent } from './componentCache';
-import {
+import type {
   IsographEntrypoint,
+  ReaderWithRefetchQueries,
   RefetchQueryNormalizationArtifactWrapper,
-  type ReaderWithRefetchQueries,
 } from './entrypoint';
-import {
+import type {
   ExtractData,
   FragmentReference,
+  UnknownTReadFromStore,
   Variables,
-  type UnknownTReadFromStore,
 } from './FragmentReference';
 import {
   assertLink,
@@ -38,17 +38,17 @@ import {
   wrapPromise,
   wrapResolvedValue,
 } from './PromiseWrapper';
-import {
+import type {
+  LoadablySelectedField,
   ReaderAst,
-  type LoadablySelectedField,
-  type ReaderClientPointer,
-  type ReaderImperativelyLoadedField,
-  type ReaderLinkedField,
-  type ReaderNonLoadableResolverField,
-  type ReaderScalarField,
+  ReaderClientPointer,
+  ReaderImperativelyLoadedField,
+  ReaderLinkedField,
+  ReaderNonLoadableResolverField,
+  ReaderScalarField,
 } from './reader';
 import { getOrCreateCachedStartUpdate } from './startUpdate';
-import { Arguments } from './util';
+import type { Arguments } from './util';
 
 export type WithEncounteredRecords<T> = {
   readonly encounteredRecords: EncounteredIds;
@@ -164,7 +164,7 @@ function readData<TReadFromStore>(
     };
   }
 
-  if (storeRecord === null) {
+  if (storeRecord == null) {
     return {
       kind: 'Success',
       data: null as any,
@@ -736,7 +736,7 @@ export function readLinkedFieldData(
             JSON.stringify(item),
           recordLink: root,
         };
-      } else if (link === null) {
+      } else if (link == null) {
         results.push(null);
         continue;
       }
@@ -827,7 +827,7 @@ export function readLinkedFieldData(
     } else {
       link = altLink;
     }
-  } else if (link === null) {
+  } else if (link == null) {
     return {
       kind: 'Success',
       data: null,
@@ -869,7 +869,7 @@ export function readLinkedFieldData(
 function isClientPointer(
   field: ReaderLinkedField,
 ): field is ReaderClientPointer {
-  return field.refetchQueryIndex !== null;
+  return field.refetchQueryIndex != null;
 }
 
 export function readClientPointerData(

package/src/core/startUpdate.ts

@@ -1,5 +1,4 @@
 import {
-  callSubscriptions,
   getParentRecordKey,
   insertEmptySetIfMissing,
   type EncounteredIds,
@@ -37,6 +36,7 @@ import {
   type ReadDataResultSuccess,
 } from './read';
 import type { ReaderAst } from './reader';
+import { callSubscriptions } from './subscribe';
 
 export function getOrCreateCachedStartUpdate<
   TReadFromStore extends UnknownTReadFromStore,

package/src/core/subscribe.ts

@@ -0,0 +1,195 @@
+import { mergeObjectsUsingReaderAst } from './areEqualWithDeepComparison';
+import type { EncounteredIds } from './cache';
+import type {
+  FragmentReference,
+  UnknownTReadFromStore,
+} from './FragmentReference';
+import type {
+  FragmentSubscription,
+  IsographEnvironment,
+} from './IsographEnvironment';
+import { logMessage } from './logging';
+import { type WithEncounteredRecords, readButDoNotEvaluate } from './read';
+import type { ReaderAst } from './reader';
+
+export function subscribe<TReadFromStore extends UnknownTReadFromStore>(
+  environment: IsographEnvironment,
+  encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,
+  fragmentReference: FragmentReference<TReadFromStore, any>,
+  callback: (
+    newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,
+  ) => void,
+  readerAst: ReaderAst<TReadFromStore>,
+): () => void {
+  const fragmentSubscription: FragmentSubscription<TReadFromStore> = {
+    kind: 'FragmentSubscription',
+    callback,
+    encounteredDataAndRecords,
+    fragmentReference,
+    readerAst,
+  };
+
+  // subscribe is called in an effect. (We should actually subscribe during the
+  // initial render.) Because it's called in an effect, we might have missed some
+  // changes since the initial render! So, at this point, we re-read and call the
+  // subscription (i.e. re-render) if the fragment data has changed.
+  callSubscriptionIfDataChanged(environment, fragmentSubscription);
+
+  environment.subscriptions.add(fragmentSubscription);
+  return () => environment.subscriptions.delete(fragmentSubscription);
+}
+
+// Calls to readButDoNotEvaluate can suspend (i.e. throw a promise).
+// Maybe in the future, they will be able to throw errors.
+//
+// That's probably okay to ignore. We don't, however, want to prevent
+// updating other subscriptions if one subscription had missing data.
+function logAnyError(
+  environment: IsographEnvironment,
+  context: any,
+  f: () => void,
+) {
+  try {
+    f();
+  } catch (e) {
+    logMessage(environment, () => ({
+      kind: 'ErrorEncounteredInWithErrorHandling',
+      error: e,
+      context,
+    }));
+  }
+}
+
+export function callSubscriptions(
+  environment: IsographEnvironment,
+  recordsEncounteredWhenNormalizing: EncounteredIds,
+) {
+  environment.subscriptions.forEach((subscription) =>
+    logAnyError(environment, { situation: 'calling subscriptions' }, () => {
+      switch (subscription.kind) {
+        case 'FragmentSubscription': {
+          // TODO if there are multiple components subscribed to the same
+          // fragment, we will call readButNotEvaluate multiple times. We
+          // should fix that.
+          if (
+            hasOverlappingIds(
+              recordsEncounteredWhenNormalizing,
+              subscription.encounteredDataAndRecords.encounteredRecords,
+            )
+          ) {
+            callSubscriptionIfDataChanged(environment, subscription);
+          }
+          return;
+        }
+        case 'AnyRecords': {
+          logAnyError(
+            environment,
+            { situation: 'calling AnyRecords callback' },
+            () => subscription.callback(),
+          );
+          return;
+        }
+        case 'AnyChangesToRecord': {
+          if (
+            recordsEncounteredWhenNormalizing
+              .get(subscription.recordLink.__typename)
+              ?.has(subscription.recordLink.__link) != null
+          ) {
+            logAnyError(
+              environment,
+              { situation: 'calling AnyChangesToRecord callback' },
+              () => subscription.callback(),
+            );
+          }
+          return;
+        }
+        default: {
+          // Ensure we have covered all variants
+          const _: never = subscription;
+          _;
+          throw new Error('Unexpected case');
+        }
+      }
+    }),
+  );
+}
+
+function callSubscriptionIfDataChanged<
+  TReadFromStore extends UnknownTReadFromStore,
+>(
+  environment: IsographEnvironment,
+  subscription: FragmentSubscription<TReadFromStore>,
+) {
+  const newEncounteredDataAndRecords = readButDoNotEvaluate(
+    environment,
+    subscription.fragmentReference,
+    // Is this wrong?
+    // Reasons to think no:
+    // - we are only updating the read-out value, and the network
+    //   options only affect whether we throw.
+    // - the component will re-render, and re-throw on its own, anyway.
+    //
+    // Reasons to think not:
+    // - it seems more efficient to suspend here and not update state,
+    //   if we expect that the component will just throw anyway
+    // - consistency
+    // - it's also weird, this is called from makeNetworkRequest, where
+    //   we don't currently pass network request options
+    {
+      suspendIfInFlight: false,
+      throwOnNetworkError: false,
+    },
+  );
+
+  const mergedItem = mergeObjectsUsingReaderAst(
+    subscription.readerAst,
+    subscription.encounteredDataAndRecords.item,
+    newEncounteredDataAndRecords.item,
+  );
+
+  logMessage(environment, () => ({
+    kind: 'DeepEqualityCheck',
+    fragmentReference: subscription.fragmentReference,
+    old: subscription.encounteredDataAndRecords.item,
+    new: newEncounteredDataAndRecords.item,
+    deeplyEqual: mergedItem === subscription.encounteredDataAndRecords.item,
+  }));
+
+  if (mergedItem !== subscription.encounteredDataAndRecords.item) {
+    logAnyError(
+      environment,
+      { situation: 'calling FragmentSubscription callback' },
+      () => {
+        subscription.callback(newEncounteredDataAndRecords);
+      },
+    );
+    subscription.encounteredDataAndRecords = newEncounteredDataAndRecords;
+  }
+}
+
+function hasOverlappingIds(
+  ids1: EncounteredIds,
+  ids2: EncounteredIds,
+): boolean {
+  for (const [typeName, set1] of ids1.entries()) {
+    const set2 = ids2.get(typeName);
+    if (set2 === undefined) {
+      continue;
+    }
+
+    if (isNotDisjointFrom(set1, set2)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// TODO use a polyfill library
+function isNotDisjointFrom<T>(set1: Set<T>, set2: Set<T>): boolean {
+  for (const id of set1) {
+    if (set2.has(id)) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/core/util.ts

@@ -31,3 +31,29 @@ export type ArgumentValue =
       readonly kind: 'Object';
       readonly value: Arguments;
     };
+
+export function isArray(value: unknown): value is readonly unknown[] {
+  return Array.isArray(value);
+}
+
+/**
+ * Creates a copy of the provided value, ensuring any nested objects have their
+ * keys sorted such that equivalent values would have identical JSON.stringify
+ * results.
+ */
+export function stableCopy<T>(value: T): T {
+  if (value == null || typeof value !== 'object') {
+    return value;
+  }
+  if (isArray(value)) {
+    // @ts-ignore
+    return value.map(stableCopy);
+  }
+  const keys = Object.keys(value).sort();
+  const stable: { [index: string]: any } = {};
+  for (let i = 0; i < keys.length; i++) {
+    // @ts-ignore
+    stable[keys[i]] = stableCopy(value[keys[i]]);
+  }
+  return stable as any;
+}