@isograph/react 0.4.3 → 0.5.1

package/src/core/cache.ts

@@ -1,43 +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,
-  ROOT_ID,
-  StoreLink,
-  StoreRecord,
   type IsographEnvironment,
+  ROOT_ID,
+  type StoreLink,
+  type StoreRecord,
   type TypeName,
 } from './IsographEnvironment';
 import { logMessage } from './logging';
-import { maybeMakeNetworkRequest } from './makeNetworkRequest';
-import { wrapPromise, wrapResolvedValue } from './PromiseWrapper';
-import { readButDoNotEvaluate, WithEncounteredRecords } from './read';
-import { ReaderLinkedField, ReaderScalarField, type ReaderAst } from './reader';
-import { Argument, ArgumentValue } from './util';
+import {
+  getMutableStoreRecordProxy,
+  type StoreLayerWithData,
+} from './optimisticProxy';
+import type { ReaderLinkedField, ReaderScalarField } from './reader';
+import { type Argument, type ArgumentValue, isArray, stableCopy } from './util';
 
 export const TYPENAME_FIELD_NAME = '__typename';
 
@@ -56,111 +46,31 @@ 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 || typeof value !== 'object') {
-    return value;
-  }
-  if (Array.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,
->(
-  environment: IsographEnvironment,
-  entrypoint: IsographEntrypoint<
-    TReadFromStore,
-    TClientFieldValue,
-    TNormalizationAst
-  >,
-  variables: ExtractParameters<TReadFromStore>,
-  fetchOptions?: FetchOptions<TClientFieldValue>,
-): 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 readerWithRefetchQueries =
-      entrypoint.readerWithRefetchQueries.kind ===
-      'ReaderWithRefetchQueriesLoader'
-        ? wrapPromise(entrypoint.readerWithRefetchQueries.loader())
-        : wrapResolvedValue(entrypoint.readerWithRefetchQueries);
-    const [networkRequest, disposeNetworkRequest] = maybeMakeNetworkRequest(
-      environment,
-      entrypoint,
-      variables,
-      readerWithRefetchQueries,
-      fetchOptions ?? null,
-    );
-
-    const itemCleanupPair: ItemCleanupPair<
-      FragmentReference<TReadFromStore, TClientFieldValue>
-    > = [
-      {
-        kind: 'FragmentReference',
-        readerWithRefetchQueries,
-        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
   | null
   | NetworkResponseObject
-  | (NetworkResponseObject | null)[]
-  | (NetworkResponseScalarValue | null)[];
+  | readonly (NetworkResponseObject | null)[]
+  | readonly (NetworkResponseScalarValue | null)[];
 
 export type NetworkResponseObject = {
   // N.B. undefined is here to support optional id's, but
   // undefined should not *actually* be present in the network response.
-  [index: string]: undefined | NetworkResponseValue;
-  id?: DataId;
-  __typename?: TypeName;
+  readonly [index: string]: undefined | NetworkResponseValue;
+  readonly id?: DataId;
+  readonly __typename?: TypeName;
 };
 
 export function normalizeData(
   environment: IsographEnvironment,
+  storeLayer: StoreLayerWithData,
   normalizationAst: NormalizationAstNodes,
   networkResponse: NetworkResponseObject,
   variables: Variables,
   root: StoreLink,
+  encounteredIds: EncounteredIds,
 ): EncounteredIds {
-  const encounteredIds: EncounteredIds = new Map();
-
   logMessage(environment, () => ({
     kind: 'AboutToNormalize',
     normalizationAst,
@@ -168,11 +78,11 @@ export function normalizeData(
     variables,
   }));
 
-  const recordsById = (environment.store[root.__typename] ??= {});
-  const newStoreRecord = (recordsById[root.__link] ??= {});
+  const newStoreRecord = getMutableStoreRecordProxy(storeLayer, root);
 
   normalizeDataIntoRecord(
     environment,
+    storeLayer,
     normalizationAst,
     networkResponse,
     newStoreRecord,
@@ -181,13 +91,6 @@ export function normalizeData(
     encounteredIds,
   );
 
-  logMessage(environment, () => ({
-    kind: 'AfterNormalization',
-    store: environment.store,
-    encounteredIds,
-  }));
-
-  callSubscriptions(environment, encounteredIds);
   return encounteredIds;
 }
 
@@ -217,27 +120,6 @@ export function subscribeToAnyChangesToRecord(
   return () => environment.subscriptions.delete(subscription);
 }
 
-// TODO we should re-read and call callback if the value has changed
-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,
-  };
-  environment.subscriptions.add(fragmentSubscription);
-  return () => environment.subscriptions.delete(fragmentSubscription);
-}
-
 export function onNextChangeToRecord(
   environment: IsographEnvironment,
   recordLink: StoreLink,
@@ -254,160 +136,13 @@ 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,
-            )
-          ) {
-            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;
-            }
-          }
-          return;
-        }
-        case 'AnyRecords': {
-          logAnyError(
-            environment,
-            { situation: 'calling AnyRecords callback' },
-            () => subscription.callback(),
-          );
-          return;
-        }
-        case 'AnyChangesToRecord': {
-          if (
-            recordsEncounteredWhenNormalizing
-              .get(subscription.recordLink.__typename)
-              ?.has(subscription.recordLink.__link)
-          ) {
-            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 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.
  */
 function normalizeDataIntoRecord(
   environment: IsographEnvironment,
+  storeLayer: StoreLayerWithData,
   normalizationAst: NormalizationAstNodes,
   networkResponseParentRecord: NetworkResponseObject,
   targetParentRecord: StoreRecord,
@@ -432,6 +167,7 @@ function normalizeDataIntoRecord(
       case 'Linked': {
         const linkedFieldResultedInChange = normalizeLinkedField(
           environment,
+          storeLayer,
           normalizationNode,
           networkResponseParentRecord,
           targetParentRecord,
@@ -446,6 +182,7 @@ function normalizeDataIntoRecord(
       case 'InlineFragment': {
         const inlineFragmentResultedInChange = normalizeInlineFragment(
           environment,
+          storeLayer,
           normalizationNode,
           networkResponseParentRecord,
           targetParentRecord,
@@ -457,12 +194,6 @@ function normalizeDataIntoRecord(
           recordHasBeenUpdated || inlineFragmentResultedInChange;
         break;
       }
-      default: {
-        // Ensure we have covered all variants
-        let _: never = normalizationNode;
-        _;
-        throw new Error('Unexpected normalization node kind');
-      }
     }
   }
   if (recordHasBeenUpdated) {
@@ -495,12 +226,14 @@ function normalizeScalarField(
   const networkResponseKey = getNetworkResponseKey(astNode);
   const networkResponseData = networkResponseParentRecord[networkResponseKey];
   const parentRecordKey = getParentRecordKey(astNode, variables);
+  const existingValue = targetStoreRecord[parentRecordKey];
 
-  if (
-    networkResponseData == null ||
-    isScalarOrEmptyArray(networkResponseData)
-  ) {
-    const existingValue = targetStoreRecord[parentRecordKey];
+  if (networkResponseData == null) {
+    targetStoreRecord[parentRecordKey] = null;
+    return existingValue === undefined || existingValue != null;
+  }
+
+  if (isScalarOrEmptyArray(networkResponseData)) {
     targetStoreRecord[parentRecordKey] = networkResponseData;
     return existingValue !== networkResponseData;
   } else {
@@ -513,6 +246,7 @@ function normalizeScalarField(
  */
 function normalizeLinkedField(
   environment: IsographEnvironment,
+  storeLayer: StoreLayerWithData,
   astNode: NormalizationLinkedField,
   networkResponseParentRecord: NetworkResponseObject,
   targetParentRecord: StoreRecord,
@@ -527,7 +261,7 @@ function normalizeLinkedField(
 
   if (networkResponseData == null) {
     targetParentRecord[parentRecordKey] = null;
-    return existingValue !== null;
+    return existingValue === undefined || existingValue != null;
   }
 
   if (
@@ -539,7 +273,7 @@ function normalizeLinkedField(
     );
   }
 
-  if (Array.isArray(networkResponseData)) {
+  if (isArray(networkResponseData)) {
     // TODO check astNode.plural or the like
     const dataIds: (StoreLink | null)[] = [];
     for (let i = 0; i < networkResponseData.length; i++) {
@@ -550,6 +284,7 @@ function normalizeLinkedField(
       }
       const newStoreRecordId = normalizeNetworkResponseObject(
         environment,
+        storeLayer,
         astNode,
         networkResponseObject,
         targetParentRecordLink,
@@ -576,6 +311,7 @@ function normalizeLinkedField(
   } else {
     const newStoreRecordId = normalizeNetworkResponseObject(
       environment,
+      storeLayer,
       astNode,
       networkResponseData,
       targetParentRecordLink,
@@ -609,6 +345,7 @@ function normalizeLinkedField(
  */
 function normalizeInlineFragment(
   environment: IsographEnvironment,
+  storeLayer: StoreLayerWithData,
   astNode: NormalizationInlineFragment,
   networkResponseParentRecord: NetworkResponseObject,
   targetParentRecord: StoreRecord,
@@ -620,6 +357,7 @@ function normalizeInlineFragment(
   if (networkResponseParentRecord[TYPENAME_FIELD_NAME] === typeToRefineTo) {
     const hasBeenModified = normalizeDataIntoRecord(
       environment,
+      storeLayer,
       astNode.selections,
       networkResponseParentRecord,
       targetParentRecord,
@@ -636,7 +374,7 @@ function dataIdsAreTheSame(
   existingValue: DataTypeValue,
   newDataIds: (StoreLink | null)[],
 ): boolean {
-  if (Array.isArray(existingValue)) {
+  if (isArray(existingValue)) {
     if (newDataIds.length !== existingValue.length) {
       return false;
     }
@@ -657,6 +395,7 @@ function dataIdsAreTheSame(
 
 function normalizeNetworkResponseObject(
   environment: IsographEnvironment,
+  storeLayer: StoreLayerWithData,
   astNode: NormalizationLinkedField,
   networkResponseData: NetworkResponseObject,
   targetParentRecordLink: StoreLink,
@@ -681,15 +420,16 @@ function normalizeNetworkResponseObject(
     );
   }
 
-  const recordsById = (environment.store[__typename] ??= {});
-  const newStoreRecord = (recordsById[newStoreRecordId] ??= {});
+  const link = { __link: newStoreRecordId, __typename };
+  const newStoreRecord = getMutableStoreRecordProxy(storeLayer, link);
 
   normalizeDataIntoRecord(
     environment,
+    storeLayer,
     astNode.selections,
     networkResponseData,
     newStoreRecord,
-    { __link: newStoreRecordId, __typename: __typename },
+    link,
     variables,
     mutableEncounteredIds,
   );
@@ -698,30 +438,33 @@ function normalizeNetworkResponseObject(
 }
 
 function isScalarOrEmptyArray(
-  data: NonNullable<NetworkResponseValue>,
-): data is NetworkResponseScalarValue | (NetworkResponseScalarValue | null)[] {
+  data: NetworkResponseValue,
+): data is
+  | NetworkResponseScalarValue
+  | readonly (NetworkResponseScalarValue | null)[] {
   // N.B. empty arrays count as empty arrays of scalar fields.
-  if (Array.isArray(data)) {
-    // This is maybe fixed in a new version of Typescript??
-    return (data as any).every((x: any) => isScalarOrEmptyArray(x));
+  if (isArray(data)) {
+    return data.every((x) => isScalarOrEmptyArray(x));
   }
   const isScalarValue =
-    data === null ||
+    data == null ||
     typeof data === 'string' ||
     typeof data === 'number' ||
     typeof data === 'boolean';
   return isScalarValue;
 }
 
-function isNullOrEmptyArray(data: unknown): data is never[] | null[] | null {
-  if (Array.isArray(data)) {
+function isNullOrEmptyArray(
+  data: unknown,
+): data is readonly never[] | null[] | null {
+  if (isArray(data)) {
     if (data.length === 0) {
       return true;
     }
     return data.every((x) => isNullOrEmptyArray(x));
   }
 
-  return data === null;
+  return data == null;
 }
 
 export function getParentRecordKey(
@@ -771,13 +514,6 @@ function getStoreKeyChunkForArgumentValue(
     case 'Enum': {
       return argumentValue.value;
     }
-    default: {
-      // TODO configure eslint to allow unused vars starting with _
-      // Ensure we have covered all variants
-      const _: never = argumentValue;
-      _;
-      throw new Error('Unexpected case');
-    }
   }
 }
 
@@ -838,12 +574,6 @@ function getArgumentValueChunk(argumentValue: ArgumentValue): string {
     case 'Enum': {
       return 'e_' + argumentValue.value;
     }
-    default: {
-      // Ensure we have covered all variants
-      let _: never = argumentValue;
-      _;
-      throw new Error('Unexpected case');
-    }
   }
 }