@isograph/react 0.3.0 → 0.4.0

package/src/core/cache.ts

@@ -3,56 +3,52 @@ import {
   ItemCleanupPair,
   ParentCache,
 } from '@isograph/react-disposable-state';
-import {
-  DataId,
-  Link,
-  ROOT_ID,
-  StoreRecord,
-  type IsographEnvironment,
-  DataTypeValue,
-  getLink,
-  FragmentSubscription,
-  type TypeName,
-} from './IsographEnvironment';
 import {
   IsographEntrypoint,
-  NormalizationAst,
   NormalizationInlineFragment,
   NormalizationLinkedField,
   NormalizationScalarField,
-  RefetchQueryNormalizationArtifactWrapper,
+  type NormalizationAst,
+  type NormalizationAstLoader,
+  type NormalizationAstNodes,
 } from '../core/entrypoint';
-import { ReaderLinkedField, ReaderScalarField, type ReaderAst } from './reader';
-import { Argument, ArgumentValue } from './util';
-import { WithEncounteredRecords, readButDoNotEvaluate } from './read';
+import { mergeObjectsUsingReaderAst } from './areEqualWithDeepComparison';
+import { FetchOptions } from './check';
 import {
+  ExtractParameters,
   FragmentReference,
   Variables,
-  ExtractParameters,
+  type UnknownTReadFromStore,
+  type VariableValue,
 } from './FragmentReference';
-import { mergeObjectsUsingReaderAst } from './areEqualWithDeepComparison';
-import { maybeMakeNetworkRequest } from './makeNetworkRequest';
-import { wrapResolvedValue } from './PromiseWrapper';
+import {
+  DataId,
+  DataTypeValue,
+  FragmentSubscription,
+  getLink,
+  ROOT_ID,
+  StoreLink,
+  StoreRecord,
+  type IsographEnvironment,
+  type TypeName,
+} from './IsographEnvironment';
 import { logMessage } from './logging';
-import { FetchOptions } from './check';
+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';
 
 export const TYPENAME_FIELD_NAME = '__typename';
 
 export function getOrCreateItemInSuspenseCache<
-  TReadFromStore extends { parameters: object; data: object },
+  TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
 >(
   environment: IsographEnvironment,
   index: string,
   factory: Factory<FragmentReference<TReadFromStore, TClientFieldValue>>,
 ): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>> {
-  // TODO this is probably a useless message, we should remove it
-  logMessage(environment, {
-    kind: 'GettingSuspenseCacheItem',
-    index,
-    availableCacheItems: Object.keys(environment.fragmentCache),
-    found: !!environment.fragmentCache[index],
-  });
   if (environment.fragmentCache[index] == null) {
     environment.fragmentCache[index] = new ParentCache(factory);
   }
@@ -83,23 +79,44 @@ export function stableCopy<T>(value: T): T {
 }
 
 export function getOrCreateCacheForArtifact<
-  TReadFromStore extends { parameters: object; data: object },
+  TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
+  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
 >(
   environment: IsographEnvironment,
-  entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>,
+  entrypoint: IsographEntrypoint<
+    TReadFromStore,
+    TClientFieldValue,
+    TNormalizationAst
+  >,
   variables: ExtractParameters<TReadFromStore>,
-  fetchOptions?: FetchOptions,
+  fetchOptions?: FetchOptions<TClientFieldValue>,
 ): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>> {
-  const cacheKey =
-    entrypoint.networkRequestInfo.queryText +
-    JSON.stringify(stableCopy(variables));
+  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,
-      fetchOptions,
+      readerWithRefetchQueries,
+      fetchOptions ?? null,
     );
 
     const itemCleanupPair: ItemCleanupPair<
@@ -107,12 +124,7 @@ export function getOrCreateCacheForArtifact<
     > = [
       {
         kind: 'FragmentReference',
-        readerWithRefetchQueries: wrapResolvedValue({
-          kind: 'ReaderWithRefetchQueries',
-          readerArtifact: entrypoint.readerWithRefetchQueries.readerArtifact,
-          nestedRefetchQueries:
-            entrypoint.readerWithRefetchQueries.nestedRefetchQueries,
-        }),
+        readerWithRefetchQueries,
         root: { __link: ROOT_ID, __typename: entrypoint.concreteType },
         variables,
         networkRequest: networkRequest,
@@ -124,8 +136,8 @@ export function getOrCreateCacheForArtifact<
   return getOrCreateItemInSuspenseCache(environment, cacheKey, factory);
 }
 
-type NetworkResponseScalarValue = string | number | boolean;
-type NetworkResponseValue =
+export type NetworkResponseScalarValue = string | number | boolean;
+export type NetworkResponseValue =
   | NetworkResponseScalarValue
   | null
   | NetworkResponseObject
@@ -142,20 +154,19 @@ export type NetworkResponseObject = {
 
 export function normalizeData(
   environment: IsographEnvironment,
-  normalizationAst: NormalizationAst,
+  normalizationAst: NormalizationAstNodes,
   networkResponse: NetworkResponseObject,
   variables: Variables,
-  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
-  root: Link,
+  root: StoreLink,
 ): EncounteredIds {
   const encounteredIds: EncounteredIds = new Map();
 
-  logMessage(environment, {
+  logMessage(environment, () => ({
     kind: 'AboutToNormalize',
     normalizationAst,
     networkResponse,
     variables,
-  });
+  }));
 
   const recordsById = (environment.store[root.__typename] ??= {});
   const newStoreRecord = (recordsById[root.__link] ??= {});
@@ -167,15 +178,14 @@ export function normalizeData(
     newStoreRecord,
     root,
     variables,
-    nestedRefetchQueries,
     encounteredIds,
   );
 
-  logMessage(environment, {
+  logMessage(environment, () => ({
     kind: 'AfterNormalization',
     store: environment.store,
     encounteredIds,
-  });
+  }));
 
   callSubscriptions(environment, encounteredIds);
   return encounteredIds;
@@ -195,7 +205,7 @@ export function subscribeToAnyChange(
 
 export function subscribeToAnyChangesToRecord(
   environment: IsographEnvironment,
-  recordLink: Link,
+  recordLink: StoreLink,
   callback: () => void,
 ): () => void {
   const subscription = {
@@ -208,9 +218,7 @@ export function subscribeToAnyChangesToRecord(
 }
 
 // TODO we should re-read and call callback if the value has changed
-export function subscribe<
-  TReadFromStore extends { parameters: object; data: object },
->(
+export function subscribe<TReadFromStore extends UnknownTReadFromStore>(
   environment: IsographEnvironment,
   encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,
   fragmentReference: FragmentReference<TReadFromStore, any>,
@@ -232,7 +240,7 @@ export function subscribe<
 
 export function onNextChangeToRecord(
   environment: IsographEnvironment,
-  recordLink: Link,
+  recordLink: StoreLink,
 ): Promise<void> {
   return new Promise((resolve) => {
     const unsubscribe = subscribeToAnyChangesToRecord(
@@ -251,20 +259,28 @@ export function onNextChangeToRecord(
 //
 // That's probably okay to ignore. We don't, however, want to prevent
 // updating other subscriptions if one subscription had missing data.
-function withErrorHandling<T>(f: (t: T) => void): (t: T) => void {
+function withErrorHandling<T>(
+  environment: IsographEnvironment,
+  f: (t: T) => void,
+): (t: T) => void {
   return (t) => {
     try {
       return f(t);
-    } catch {}
+    } catch (e) {
+      logMessage(environment, () => ({
+        kind: 'ErrorEncounteredInWithErrorHandling',
+        error: e,
+      }));
+    }
   };
 }
 
-function callSubscriptions(
+export function callSubscriptions(
   environment: IsographEnvironment,
   recordsEncounteredWhenNormalizing: EncounteredIds,
 ) {
   environment.subscriptions.forEach(
-    withErrorHandling((subscription) => {
+    withErrorHandling(environment, (subscription) => {
       switch (subscription.kind) {
         case 'FragmentSubscription': {
           // TODO if there are multiple components subscribed to the same
@@ -303,14 +319,14 @@ function callSubscriptions(
               newEncounteredDataAndRecords.item,
             );
 
-            logMessage(environment, {
+            logMessage(environment, () => ({
               kind: 'DeepEqualityCheck',
               fragmentReference: subscription.fragmentReference,
               old: subscription.encounteredDataAndRecords.item,
               new: newEncounteredDataAndRecords.item,
               deeplyEqual:
                 mergedItem === subscription.encounteredDataAndRecords.item,
-            });
+            }));
 
             if (mergedItem !== subscription.encounteredDataAndRecords.item) {
               subscription.callback(newEncounteredDataAndRecords);
@@ -376,12 +392,11 @@ export type EncounteredIds = Map<TypeName, Set<DataId>>;
  */
 function normalizeDataIntoRecord(
   environment: IsographEnvironment,
-  normalizationAst: NormalizationAst,
+  normalizationAst: NormalizationAstNodes,
   networkResponseParentRecord: NetworkResponseObject,
   targetParentRecord: StoreRecord,
-  targetParentRecordLink: Link,
+  targetParentRecordLink: StoreLink,
   variables: Variables,
-  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   mutableEncounteredIds: EncounteredIds,
 ): RecordHasBeenUpdated {
   let recordHasBeenUpdated = false;
@@ -406,7 +421,6 @@ function normalizeDataIntoRecord(
           targetParentRecord,
           targetParentRecordLink,
           variables,
-          nestedRefetchQueries,
           mutableEncounteredIds,
         );
         recordHasBeenUpdated =
@@ -421,7 +435,6 @@ function normalizeDataIntoRecord(
           targetParentRecord,
           targetParentRecordLink,
           variables,
-          nestedRefetchQueries,
           mutableEncounteredIds,
         );
         recordHasBeenUpdated =
@@ -437,7 +450,7 @@ function normalizeDataIntoRecord(
     }
   }
   if (recordHasBeenUpdated) {
-    let encounteredRecordsIds = insertIfNotExists(
+    let encounteredRecordsIds = insertEmptySetIfMissing(
       mutableEncounteredIds,
       targetParentRecordLink.__typename,
     );
@@ -447,7 +460,7 @@ function normalizeDataIntoRecord(
   return recordHasBeenUpdated;
 }
 
-export function insertIfNotExists<K, V>(map: Map<K, Set<V>>, key: K) {
+export function insertEmptySetIfMissing<K, V>(map: Map<K, Set<V>>, key: K) {
   let result = map.get(key);
   if (result === undefined) {
     result = new Set();
@@ -487,9 +500,8 @@ function normalizeLinkedField(
   astNode: NormalizationLinkedField,
   networkResponseParentRecord: NetworkResponseObject,
   targetParentRecord: StoreRecord,
-  targetParentRecordLink: Link,
+  targetParentRecordLink: StoreLink,
   variables: Variables,
-  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   mutableEncounteredIds: EncounteredIds,
 ): RecordHasBeenUpdated {
   const networkResponseKey = getNetworkResponseKey(astNode);
@@ -513,7 +525,7 @@ function normalizeLinkedField(
 
   if (Array.isArray(networkResponseData)) {
     // TODO check astNode.plural or the like
-    const dataIds: (Link | null)[] = [];
+    const dataIds: (StoreLink | null)[] = [];
     for (let i = 0; i < networkResponseData.length; i++) {
       const networkResponseObject = networkResponseData[i];
       if (networkResponseObject == null) {
@@ -527,7 +539,6 @@ function normalizeLinkedField(
         targetParentRecordLink,
         variables,
         i,
-        nestedRefetchQueries,
         mutableEncounteredIds,
       );
 
@@ -554,7 +565,6 @@ function normalizeLinkedField(
       targetParentRecordLink,
       variables,
       null,
-      nestedRefetchQueries,
       mutableEncounteredIds,
     );
 
@@ -586,9 +596,8 @@ function normalizeInlineFragment(
   astNode: NormalizationInlineFragment,
   networkResponseParentRecord: NetworkResponseObject,
   targetParentRecord: StoreRecord,
-  targetParentRecordLink: Link,
+  targetParentRecordLink: StoreLink,
   variables: Variables,
-  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   mutableEncounteredIds: EncounteredIds,
 ): RecordHasBeenUpdated {
   const typeToRefineTo = astNode.type;
@@ -600,7 +609,6 @@ function normalizeInlineFragment(
       targetParentRecord,
       targetParentRecordLink,
       variables,
-      nestedRefetchQueries,
       mutableEncounteredIds,
     );
     return hasBeenModified;
@@ -610,7 +618,7 @@ function normalizeInlineFragment(
 
 function dataIdsAreTheSame(
   existingValue: DataTypeValue,
-  newDataIds: (Link | null)[],
+  newDataIds: (StoreLink | null)[],
 ): boolean {
   if (Array.isArray(existingValue)) {
     if (newDataIds.length !== existingValue.length) {
@@ -635,10 +643,9 @@ function normalizeNetworkResponseObject(
   environment: IsographEnvironment,
   astNode: NormalizationLinkedField,
   networkResponseData: NetworkResponseObject,
-  targetParentRecordLink: Link,
+  targetParentRecordLink: StoreLink,
   variables: Variables,
   index: number | null,
-  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   mutableEncounteredIds: EncounteredIds,
 ): DataId /* The id of the modified or newly created item */ {
   const newStoreRecordId = getDataIdOfNetworkResponse(
@@ -668,7 +675,6 @@ function normalizeNetworkResponseObject(
     newStoreRecord,
     { __link: newStoreRecordId, __typename: __typename },
     variables,
-    nestedRefetchQueries,
     mutableEncounteredIds,
   );
 
@@ -724,8 +730,19 @@ export function getParentRecordKey(
 function getStoreKeyChunkForArgumentValue(
   argumentValue: ArgumentValue,
   variables: Variables,
-) {
+): VariableValue {
   switch (argumentValue.kind) {
+    case 'Object': {
+      return Object.fromEntries(
+        argumentValue.value.map(([argumentName, argumentValue]) => {
+          return [
+            argumentName,
+            //  substitute variables
+            getStoreKeyChunkForArgumentValue(argumentValue, variables),
+          ];
+        }),
+      );
+    }
     case 'Literal': {
       return argumentValue.value;
     }
@@ -749,8 +766,14 @@ function getStoreKeyChunkForArgumentValue(
 }
 
 function getStoreKeyChunkForArgument(argument: Argument, variables: Variables) {
-  const chunk = getStoreKeyChunkForArgumentValue(argument[1], variables);
-  return `${FIRST_SPLIT_KEY}${argument[0]}${SECOND_SPLIT_KEY}${chunk}`;
+  const [argumentName, argumentValue] = argument;
+  let chunk = getStoreKeyChunkForArgumentValue(argumentValue, variables);
+
+  if (typeof chunk === 'object') {
+    chunk = JSON.stringify(stableCopy(chunk));
+  }
+
+  return `${FIRST_SPLIT_KEY}${argumentName}${SECOND_SPLIT_KEY}${chunk}`;
 }
 
 function getNetworkResponseKey(
@@ -758,47 +781,64 @@ function getNetworkResponseKey(
 ): string {
   let networkResponseKey = astNode.fieldName;
   const fieldParameters = astNode.arguments;
+
   if (fieldParameters != null) {
-    for (const fieldParameter of fieldParameters) {
-      const [argumentName, argumentValue] = fieldParameter;
-      let argumentValueChunk;
-      switch (argumentValue.kind) {
-        case 'Literal': {
-          argumentValueChunk = 'l_' + argumentValue.value;
-          break;
-        }
-        case 'Variable': {
-          argumentValueChunk = 'v_' + argumentValue.name;
-          break;
-        }
-        case 'String': {
-          argumentValueChunk = 's_' + argumentValue.value;
-          break;
-        }
-        case 'Enum': {
-          argumentValueChunk = 'e_' + argumentValue.value;
-          break;
-        }
-        default: {
-          // Ensure we have covered all variants
-          let _: never = argumentValue;
-          _;
-          throw new Error('Unexpected case');
-        }
-      }
+    for (const [argumentName, argumentValue] of fieldParameters) {
+      let argumentValueChunk = getArgumentValueChunk(argumentValue);
       networkResponseKey += `${FIRST_SPLIT_KEY}${argumentName}${SECOND_SPLIT_KEY}${argumentValueChunk}`;
     }
   }
+
   return networkResponseKey;
 }
 
+function getArgumentValueChunk(argumentValue: ArgumentValue): string {
+  switch (argumentValue.kind) {
+    case 'Object': {
+      return (
+        'o_' +
+        argumentValue.value
+          .map(([argumentName, argumentValue]) => {
+            return (
+              argumentName +
+              THIRD_SPLIT_KEY +
+              getArgumentValueChunk(argumentValue)
+            );
+          })
+          .join('_') +
+        '_c'
+      );
+    }
+    case 'Literal': {
+      return 'l_' + argumentValue.value;
+    }
+    case 'Variable': {
+      return 'v_' + argumentValue.name;
+    }
+    case 'String': {
+      // replace all non-word characters (alphanumeric & underscore) with underscores
+      return 's_' + argumentValue.value.replaceAll(/\W/g, '_');
+    }
+    case 'Enum': {
+      return 'e_' + argumentValue.value;
+    }
+    default: {
+      // Ensure we have covered all variants
+      let _: never = argumentValue;
+      _;
+      throw new Error('Unexpected case');
+    }
+  }
+}
+
 // an alias might be pullRequests____first___first____after___cursor
 export const FIRST_SPLIT_KEY = '____';
 export const SECOND_SPLIT_KEY = '___';
+export const THIRD_SPLIT_KEY = '__';
 
 // Returns a key to look up an item in the store
 function getDataIdOfNetworkResponse(
-  parentRecordLink: Link,
+  parentRecordLink: StoreLink,
   dataToNormalize: NetworkResponseObject,
   astNode: NormalizationLinkedField,
   variables: Variables,

package/src/core/check.ts

@@ -1,38 +1,43 @@
 import { getParentRecordKey } from './cache';
-import { NormalizationAst } from './entrypoint';
+import { NormalizationAstNodes } from './entrypoint';
 import { Variables } from './FragmentReference';
 import {
   getLink,
   IsographEnvironment,
-  Link,
+  StoreLink,
   StoreRecord,
 } from './IsographEnvironment';
 import { logMessage } from './logging';
 
-export type ShouldFetch = 'Yes' | 'No' | 'IfNecessary';
+export type ShouldFetch = RequiredShouldFetch | 'IfNecessary';
+export type RequiredShouldFetch = 'Yes' | 'No';
 
 export const DEFAULT_SHOULD_FETCH_VALUE: ShouldFetch = 'IfNecessary';
 
-export type FetchOptions = {
+export type FetchOptions<TReadOutData> = {
   shouldFetch?: ShouldFetch;
-  onComplete?: () => void;
+  onComplete?: (data: TReadOutData) => void;
   onError?: () => void;
 };
 
+export type RequiredFetchOptions<TReadOutData> = {
+  shouldFetch: RequiredShouldFetch;
+} & FetchOptions<TReadOutData>;
+
 export type CheckResult =
   | {
       kind: 'EnoughData';
     }
   | {
       kind: 'MissingData';
-      record: Link;
+      record: StoreLink;
     };
 
 export function check(
   environment: IsographEnvironment,
-  normalizationAst: NormalizationAst,
+  normalizationAst: NormalizationAstNodes,
   variables: Variables,
-  root: Link,
+  root: StoreLink,
 ): CheckResult {
   const recordsById = (environment.store[root.__typename] ??= {});
   const newStoreRecord = (recordsById[root.__link] ??= {});
@@ -44,19 +49,19 @@ export function check(
     newStoreRecord,
     root,
   );
-  logMessage(environment, {
+  logMessage(environment, () => ({
     kind: 'EnvironmentCheck',
     result: checkResult,
-  });
+  }));
   return checkResult;
 }
 
 function checkFromRecord(
   environment: IsographEnvironment,
-  normalizationAst: NormalizationAst,
+  normalizationAst: NormalizationAstNodes,
   variables: Variables,
   record: StoreRecord,
-  recordLink: Link,
+  recordLink: StoreLink,
 ): CheckResult {
   normalizationAstLoop: for (const normalizationAstNode of normalizationAst) {
     switch (normalizationAstNode.kind) {