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

package/src/core/IsographEnvironment.ts

@@ -1,29 +1,33 @@
 import { ParentCache } from '@isograph/react-disposable-state';
 import type { Brand } from './brand';
-import { isArray } from './cache';
-import {
+import type {
   IsographEntrypoint,
   IsographOperation,
   IsographPersistedOperation,
-  type ReaderWithRefetchQueries,
-  type ReaderWithRefetchQueriesLoader,
+  ReaderWithRefetchQueries,
+  ReaderWithRefetchQueriesLoader,
 } from './entrypoint';
-import {
+import type {
+  ExtractStartUpdate,
   FragmentReference,
+  StableIdForFragmentReference,
+  UnknownTReadFromStore,
   Variables,
-  type StableIdForFragmentReference,
-  type UnknownTReadFromStore,
 } from './FragmentReference';
 import type { RetainedQuery } from './garbageCollection';
-import { LogFunction, WrappedLogFunction } from './logging';
+import type { LogFunction, WrappedLogFunction } from './logging';
 import { type StoreLayer } from './optimisticProxy';
 import {
   PromiseWrapper,
   wrapPromise,
   wrapResolvedValue,
 } from './PromiseWrapper';
-import { WithEncounteredRecords } from './read';
+import type {
+  NetworkRequestReaderOptions,
+  WithEncounteredRecords,
+} from './read';
 import type { ReaderAst, StartUpdate } from './reader';
+import { isArray } from './util';
 
 export type ComponentOrFieldName = string;
 export type StringifiedArgs = string;
@@ -66,6 +70,7 @@ export type CacheMap<T> = { [index: string]: ParentCache<T> };
 export type IsographEnvironment = {
   store: StoreLayer;
   readonly networkFunction: IsographNetworkFunction;
+  readonly componentFunction: IsographComponentFunction;
   readonly missingFieldHandler: MissingFieldHandler | null;
   readonly componentCache: FieldCache<React.FC<any>>;
   readonly eagerReaderCache: FieldCache<StartUpdate<any> | undefined>;
@@ -97,6 +102,15 @@ export type IsographNetworkFunction = (
   variables: Variables,
 ) => Promise<any>;
 
+export type IsographComponentFunction = <
+  TReadFromStore extends UnknownTReadFromStore = any,
+>(
+  environment: IsographEnvironment,
+  fragmentReference: FragmentReference<TReadFromStore, any>,
+  networkRequestOptions: NetworkRequestReaderOptions,
+  startUpdate: ExtractStartUpdate<TReadFromStore>,
+) => React.FC<any>;
+
 export interface Link<T extends TypeName> extends StoreLink {
   readonly __link: Brand<DataId, T>;
   readonly __typename: T;
@@ -146,9 +160,10 @@ export interface BaseStoreLayerData extends StoreLayerData {
 }
 
 const DEFAULT_GC_BUFFER_SIZE = 10;
-export function createIsographEnvironment(
+export function createIsographEnvironmentCore(
   baseStoreLayerData: BaseStoreLayerData,
   networkFunction: IsographNetworkFunction,
+  componentFunction: IsographComponentFunction,
   missingFieldHandler?: MissingFieldHandler | null,
   logFunction?: LogFunction | null,
 ): IsographEnvironment {
@@ -164,6 +179,7 @@ export function createIsographEnvironment(
   return {
     store,
     networkFunction,
+    componentFunction,
     missingFieldHandler: missingFieldHandler ?? null,
     componentCache: {},
     eagerReaderCache: {},

package/src/core/areEqualWithDeepComparison.ts

@@ -6,12 +6,8 @@ function mergeUsingReaderAst(
   oldItem: unknown,
   newItem: unknown,
 ): unknown {
-  if (newItem === null) {
-    return oldItem === null ? oldItem : newItem;
-  }
-
-  if (newItem === undefined) {
-    return oldItem === undefined ? oldItem : newItem;
+  if (newItem == null || oldItem == null) {
+    return newItem;
   }
 
   if (Array.isArray(newItem)) {

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.
@@ -520,7 +236,7 @@ function normalizeScalarField(
 
   if (networkResponseData == null) {
     targetStoreRecord[parentRecordKey] = null;
-    return existingValue !== null;
+    return existingValue === undefined || existingValue != null;
   }
 
   if (isScalarOrEmptyArray(networkResponseData)) {
@@ -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.
  */
@@ -555,7 +267,7 @@ function normalizeLinkedField(
 
   if (networkResponseData == null) {
     targetParentRecord[parentRecordKey] = null;
-    return existingValue !== null;
+    return existingValue === undefined || existingValue != null;
   }
 
   if (
@@ -741,7 +453,7 @@ function isScalarOrEmptyArray(
     return data.every((x) => isScalarOrEmptyArray(x));
   }
   const isScalarValue =
-    data === null ||
+    data == null ||
     typeof data === 'string' ||
     typeof data === 'number' ||
     typeof data === 'boolean';
@@ -758,7 +470,7 @@ function isNullOrEmptyArray(
     return data.every((x) => isNullOrEmptyArray(x));
   }
 
-  return data === null;
+  return data == null;
 }
 
 export function getParentRecordKey(
@@ -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/check.ts

@@ -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

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,