@isograph/react 0.0.0-main-4adb5045 → 0.0.0-main-82400fb8

package/src/core/cache.ts

@@ -1,51 +1,33 @@
-import {
-  Factory,
-  ItemCleanupPair,
-  ParentCache,
-} from '@isograph/react-disposable-state';
-import {
-  IsographEntrypoint,
+import { type Factory, ParentCache } from '@isograph/react-disposable-state';
+import type {
+  NormalizationAstNodes,
   NormalizationInlineFragment,
   NormalizationLinkedField,
   NormalizationScalarField,
-  type NormalizationAst,
-  type NormalizationAstLoader,
-  type NormalizationAstNodes,
-} from '../core/entrypoint';
-import { mergeObjectsUsingReaderAst } from './areEqualWithDeepComparison';
-import { FetchOptions } from './check';
-import {
-  ExtractParameters,
+} from './entrypoint';
+import type {
   FragmentReference,
+  UnknownTReadFromStore,
   Variables,
-  type UnknownTReadFromStore,
-  type VariableValue,
+  VariableValue,
 } from './FragmentReference';
 import {
-  DataId,
-  DataTypeValue,
-  FragmentSubscription,
+  type DataId,
+  type DataTypeValue,
   getLink,
-  getOrLoadReaderWithRefetchQueries,
-  ROOT_ID,
-  StoreLink,
-  StoreRecord,
   type IsographEnvironment,
+  ROOT_ID,
+  type StoreLink,
+  type StoreRecord,
   type TypeName,
 } from './IsographEnvironment';
 import { logMessage } from './logging';
 import {
-  maybeMakeNetworkRequest,
-  retainQueryWithoutMakingNetworkRequest,
-} from './makeNetworkRequest';
-import {
-  addNetworkResponseStoreLayer,
   getMutableStoreRecordProxy,
   type StoreLayerWithData,
 } from './optimisticProxy';
-import { readButDoNotEvaluate, WithEncounteredRecords } from './read';
-import { ReaderLinkedField, ReaderScalarField, type ReaderAst } from './reader';
-import { Argument, ArgumentValue } from './util';
+import type { ReaderLinkedField, ReaderScalarField } from './reader';
+import { type Argument, type ArgumentValue, isArray, stableCopy } from './util';
 
 export const TYPENAME_FIELD_NAME = '__typename';
 
@@ -64,90 +46,6 @@ export function getOrCreateItemInSuspenseCache<
   return environment.fragmentCache[index];
 }
 
-/**
- * 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;
-}
-
-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);
-}
-
 export type NetworkResponseScalarValue = string | number | boolean;
 export type NetworkResponseValue =
   | NetworkResponseScalarValue
@@ -222,33 +120,6 @@ export function subscribeToAnyChangesToRecord(
   return () => environment.subscriptions.delete(subscription);
 }
 
-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);
-}
-
 export function onNextChangeToRecord(
   environment: IsographEnvironment,
   recordLink: StoreLink,
@@ -265,161 +136,6 @@ export function onNextChangeToRecord(
   });
 }
 
-// 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;
-}
-
 export type EncounteredIds = Map<TypeName, Set<DataId>>;
 /**
  * Mutate targetParentRecord according to the normalizationAst and networkResponseParentRecord.
@@ -531,10 +247,6 @@ function normalizeScalarField(
   }
 }
 
-export function isArray(value: unknown): value is readonly unknown[] {
-  return Array.isArray(value);
-}
-
 /**
  * Mutate targetParentRecord with a given linked field ast node.
  */
@@ -926,61 +638,3 @@ function getDataIdOfNetworkResponse(
   }
   return storeKey;
 }
-
-export function writeData<
-  TReadFromStore extends UnknownTReadFromStore,
-  TRawResponseType extends NetworkResponseObject,
-  TClientFieldValue,
->(
-  environment: IsographEnvironment,
-  entrypoint: IsographEntrypoint<
-    TReadFromStore,
-    TClientFieldValue,
-    NormalizationAst,
-    TRawResponseType
-  >,
-  data: TRawResponseType,
-  variables: ExtractParameters<TReadFromStore>,
-): ItemCleanupPair<FragmentReference<TReadFromStore, TClientFieldValue>> {
-  const encounteredIds: EncounteredIds = new Map();
-  environment.store = addNetworkResponseStoreLayer(environment.store);
-  normalizeData(
-    environment,
-    environment.store,
-    entrypoint.networkRequestInfo.normalizationAst.selections,
-    data,
-    variables,
-    { __link: ROOT_ID, __typename: entrypoint.concreteType },
-    encounteredIds,
-  );
-  logMessage(environment, () => ({
-    kind: 'AfterNormalization',
-    store: environment.store,
-    encounteredIds,
-  }));
-
-  callSubscriptions(environment, encounteredIds);
-
-  const { fieldName, readerArtifactKind, readerWithRefetchQueries } =
-    getOrLoadReaderWithRefetchQueries(
-      environment,
-      entrypoint.readerWithRefetchQueries,
-    );
-  const [networkRequest, disposeNetworkRequest] =
-    retainQueryWithoutMakingNetworkRequest(environment, entrypoint, variables);
-
-  return [
-    {
-      kind: 'FragmentReference',
-      readerWithRefetchQueries,
-      fieldName,
-      readerArtifactKind,
-      root: { __link: ROOT_ID, __typename: entrypoint.concreteType },
-      variables,
-      networkRequest,
-    },
-    () => {
-      disposeNetworkRequest();
-    },
-  ];
-}

package/src/core/componentCache.ts

@@ -1,13 +1,9 @@
-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 { IsographEnvironment } from './IsographEnvironment';
+import type { NetworkRequestReaderOptions } from './read';
 import { createStartUpdate } from './startUpdate';
 
 export function getOrCreateCachedComponent(
@@ -24,41 +20,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

@@ -5,8 +5,8 @@ import type {
   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,

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,

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,