@isograph/react 0.5.2 → 0.5.4

package/src/core/cache.ts

@@ -13,7 +13,7 @@ import type {
 } from './FragmentReference';
 import {
   type DataId,
-  type DataTypeValue,
+  type DataTypeValueLinked,
   getLink,
   type IsographEnvironment,
   ROOT_ID,
@@ -46,18 +46,30 @@ export function getOrCreateItemInSuspenseCache<
   return environment.fragmentCache[index];
 }
 
-export type NetworkResponseScalarValue = string | number | boolean;
-export type NetworkResponseValue =
-  | NetworkResponseScalarValue
+export type NetworkResponsePlural<T> =
   | null
-  | NetworkResponseObject
-  | readonly (NetworkResponseObject | null)[]
-  | readonly (NetworkResponseScalarValue | null)[];
+  | T
+  | readonly T[]
+  | readonly (null | T)[];
+export type NetworkResponseScalarValue = string | number | boolean | unknown;
+
+export type NetworkResponseValue =
+  | NetworkResponsePlural<NetworkResponseScalarValue>
+  | NetworkResponsePlural<NetworkResponseObject>;
 
 export type NetworkResponseObject = {
   // N.B. undefined is here to support optional id's, but
   // undefined should not *actually* be present in the network response.
-  readonly [index: string]: undefined | NetworkResponseValue;
+  readonly [key: ScalarNetworkResponseKey]:
+    | undefined
+    | NetworkResponsePlural<NetworkResponseScalarValue>;
+  readonly [key: LinkedNetworkResponseKey]:
+    | undefined
+    | NetworkResponsePlural<NetworkResponseObject>;
+  readonly [key: NetworkResponseKey]:
+    | undefined
+    | NetworkResponsePlural<NetworkResponseScalarValue>
+    | NetworkResponsePlural<NetworkResponseObject>;
   readonly id?: DataId;
   readonly __typename?: TypeName;
 };
@@ -233,12 +245,8 @@ function normalizeScalarField(
     return existingValue === undefined || existingValue != null;
   }
 
-  if (isScalarOrEmptyArray(networkResponseData)) {
-    targetStoreRecord[parentRecordKey] = networkResponseData;
-    return existingValue !== networkResponseData;
-  } else {
-    throw new Error('Unexpected object array when normalizing scalar');
-  }
+  targetStoreRecord[parentRecordKey] = networkResponseData;
+  return existingValue !== networkResponseData;
 }
 
 /**
@@ -264,15 +272,6 @@ function normalizeLinkedField(
     return existingValue === undefined || existingValue != null;
   }
 
-  if (
-    isScalarOrEmptyArray(networkResponseData) &&
-    !isNullOrEmptyArray(networkResponseData)
-  ) {
-    throw new Error(
-      'Unexpected scalar network response when normalizing a linked field',
-    );
-  }
-
   if (isArray(networkResponseData)) {
     // TODO check astNode.plural or the like
     const dataIds: (StoreLink | null)[] = [];
@@ -371,7 +370,7 @@ function normalizeInlineFragment(
 }
 
 function dataIdsAreTheSame(
-  existingValue: DataTypeValue,
+  existingValue: DataTypeValueLinked,
   newDataIds: (StoreLink | null)[],
 ): boolean {
   if (isArray(existingValue)) {
@@ -437,36 +436,29 @@ function normalizeNetworkResponseObject(
   return newStoreRecordId;
 }
 
-function isScalarOrEmptyArray(
-  data: NetworkResponseValue,
-): data is
-  | NetworkResponseScalarValue
-  | readonly (NetworkResponseScalarValue | null)[] {
-  // N.B. empty arrays count as empty arrays of scalar fields.
-  if (isArray(data)) {
-    return data.every((x) => isScalarOrEmptyArray(x));
-  }
-  const isScalarValue =
-    data == null ||
-    typeof data === 'string' ||
-    typeof data === 'number' ||
-    typeof data === 'boolean';
-  return isScalarValue;
-}
-
-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));
-  }
+export type ParentRecordKey = string;
 
-  return data == null;
-}
+/**
+ * these don't actually start with the different prefixes, but they let
+ * us use multiple indexes, e.g.
+ * {
+ *   readonly [key: `NOT_AN_ACTUAL_TYPE_LinkedParentRecordKey_${string} `]: ...
+ *   readonly [key: `NOT_AN_ACTUAL_TYPE_ScalarParentRecordKey_${string} `]: ...
+ * }
+ */
+export type LinkedParentRecordKey =
+  `NOT_AN_ACTUAL_TYPE_LinkedParentRecordKey_${string}`;
+export type ScalarParentRecordKey =
+  `NOT_AN_ACTUAL_TYPE_ScalarParentRecordKey_${string}`;
 
+export function getParentRecordKey(
+  astNode: NormalizationLinkedField | ReaderLinkedField,
+  variables: Variables,
+): LinkedParentRecordKey;
+export function getParentRecordKey(
+  astNode: NormalizationScalarField | ReaderScalarField,
+  variables: Variables,
+): ScalarParentRecordKey;
 export function getParentRecordKey(
   astNode:
     | NormalizationLinkedField
@@ -474,7 +466,7 @@ export function getParentRecordKey(
     | ReaderLinkedField
     | ReaderScalarField,
   variables: Variables,
-): string {
+): ParentRecordKey {
   let parentRecordKey = astNode.fieldName;
   const fieldParameters = astNode.arguments;
   if (fieldParameters != null) {
@@ -528,9 +520,30 @@ function getStoreKeyChunkForArgument(argument: Argument, variables: Variables) {
   return `${FIRST_SPLIT_KEY}${argumentName}${SECOND_SPLIT_KEY}${chunk}`;
 }
 
+export type NetworkResponseKey = string;
+
+/**
+ * these don't actually start with the different prefixes, but they let
+ * us use multiple indexes, e.g.
+ * {
+ *   readonly [key: `NOT_AN_ACTUAL_TYPE_LinkedNetworkResponseKey_${string} `]: ...
+ *   readonly [key: `NOT_AN_ACTUAL_TYPE_ScalarNetworkResponseKey_${string} `]: ...
+ * }
+ */
+export type LinkedNetworkResponseKey =
+  `NOT_AN_ACTUAL_TYPE_LinkedNetworkResponseKey_${string}`;
+export type ScalarNetworkResponseKey =
+  `NOT_AN_ACTUAL_TYPE_ScalarNetworkResponseKey_${string}`;
+
+function getNetworkResponseKey(
+  astNode: NormalizationLinkedField,
+): LinkedNetworkResponseKey;
+function getNetworkResponseKey(
+  astNode: NormalizationScalarField,
+): ScalarNetworkResponseKey;
 function getNetworkResponseKey(
   astNode: NormalizationLinkedField | NormalizationScalarField,
-): string {
+): NetworkResponseKey {
   let networkResponseKey = astNode.fieldName;
   const fieldParameters = astNode.arguments;
 
@@ -590,9 +603,17 @@ function getDataIdOfNetworkResponse(
   variables: Variables,
   index: number | null,
 ): DataId {
+  const __typename =
+    astNode.concreteType ?? dataToNormalize[TYPENAME_FIELD_NAME];
+  if (__typename == null) {
+    throw new Error(
+      'Unexpected missing __typename in network response when normalizing a linked field. ' +
+        'This is indicative of a bug in Isograph.',
+    );
+  }
   // If we are dealing with nested Query, use __ROOT as id
   // TODO do not hard code this value here
-  if (astNode.concreteType === 'Query') {
+  if (__typename === 'Query') {
     return ROOT_ID;
   }
 

package/src/core/entrypoint.ts

@@ -22,6 +22,20 @@ export type ReaderWithRefetchQueries<
   readonly nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[];
 };
 
+export type RawReaderWithRefetchQueries<
+  TReadFromStore extends UnknownTReadFromStore,
+  TClientFieldValue,
+> = {
+  readonly kind: 'ReaderWithRefetchQueries';
+  readonly readerArtifact: () => TopLevelReaderArtifact<
+    TReadFromStore,
+    TClientFieldValue,
+    // TODO don't type this as any
+    any
+  >;
+  readonly nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[];
+};
+
 export type ReaderWithRefetchQueriesLoader<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
@@ -32,7 +46,7 @@ export type ReaderWithRefetchQueriesLoader<
     | 'EagerReaderArtifact'
     | 'ComponentReaderArtifact';
   readonly loader: () => Promise<
-    ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
+    RawReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
   >;
 };
 
@@ -69,7 +83,7 @@ export type IsographEntrypoint<
   readonly kind: 'Entrypoint';
   readonly networkRequestInfo: NetworkRequestInfo<TNormalizationAst>;
   readonly readerWithRefetchQueries:
-    | ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
+    | RawReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
     | ReaderWithRefetchQueriesLoader<TReadFromStore, TClientFieldValue>;
   readonly concreteType: TypeName;
   /**
@@ -124,12 +138,14 @@ export type NormalizationAstLoader = {
 
 export type NormalizationScalarField = {
   readonly kind: 'Scalar';
+  readonly isFallible: boolean;
   readonly fieldName: string;
   readonly arguments: Arguments | null;
 };
 
 export type NormalizationLinkedField = {
   readonly kind: 'Linked';
+  readonly isFallible: boolean;
   readonly fieldName: string;
   readonly arguments: Arguments | null;
   readonly selections: NormalizationAstNodes;

package/src/core/getOrCreateCacheForArtifact.ts

@@ -1,5 +1,5 @@
-import type { ItemCleanupPair } from '@isograph/isograph-disposable-types/dist';
-import type { ParentCache } from '@isograph/isograph-react-disposable-state/dist';
+import type { ItemCleanupPair } from '@isograph/disposable-types';
+import type { ParentCache } from '@isograph/react-disposable-state';
 import {
   type NetworkResponseObject,
   getOrCreateItemInSuspenseCache,

package/src/core/makeNetworkRequest.ts

@@ -395,20 +395,18 @@ function readDataForOnComplete<
       suspendIfInFlight: false,
       throwOnNetworkError: false,
     };
-    const resolvedReaderWithRefetchQueries =
-      readerWithRefetchQueries as ReaderWithRefetchQueries<
-        TReadFromStore,
-        TClientFieldValue
-      >;
+    if (readerWithRefetchQueries == null) {
+      throw new Error(
+        'Expected readerWithRefetchQueries to be not null. This is indicative of a bug in Isograph.',
+      );
+    }
 
     const fragment: FragmentReference<TReadFromStore, TClientFieldValue> = {
       kind: 'FragmentReference',
       // TODO this smells.
-      readerWithRefetchQueries: wrapResolvedValue(
-        resolvedReaderWithRefetchQueries,
-      ),
-      fieldName: resolvedReaderWithRefetchQueries.readerArtifact.fieldName,
-      readerArtifactKind: resolvedReaderWithRefetchQueries.readerArtifact.kind,
+      readerWithRefetchQueries: wrapResolvedValue(readerWithRefetchQueries),
+      fieldName: readerWithRefetchQueries.readerArtifact.fieldName,
+      readerArtifactKind: readerWithRefetchQueries.readerArtifact.kind,
       root,
       variables,
       networkRequest: fakeNetworkRequest,
@@ -418,7 +416,7 @@ function readDataForOnComplete<
       fragment,
       fakeNetworkRequestOptions,
     ).item;
-    const readerArtifact = resolvedReaderWithRefetchQueries.readerArtifact;
+    const readerArtifact = readerWithRefetchQueries.readerArtifact;
     switch (readerArtifact.kind) {
       case 'ComponentReaderArtifact': {
         // @ts-expect-error We should find a way to encode this in the type system:
@@ -432,7 +430,7 @@ function readDataForOnComplete<
               kind: 'ReaderWithRefetchQueries',
               readerArtifact: readerArtifact,
               nestedRefetchQueries:
-                resolvedReaderWithRefetchQueries.nestedRefetchQueries,
+                readerWithRefetchQueries.nestedRefetchQueries,
             }),
             fieldName: readerArtifact.fieldName,
             readerArtifactKind: readerArtifact.kind,

package/src/core/read.ts

@@ -18,12 +18,14 @@ import type {
   UnknownTReadFromStore,
   Variables,
 } from './FragmentReference';
-import type { IsographEnvironment } from './IsographEnvironment';
+import type {
+  DataTypeValueScalar,
+  IsographEnvironment,
+} from './IsographEnvironment';
 import {
   assertLink,
   getOrLoadIsographArtifact,
   getOrLoadReaderWithRefetchQueries,
-  type DataTypeValue,
   type StoreLink,
   type StoreRecord,
 } from './IsographEnvironment';
@@ -548,25 +550,25 @@ export function readResolverFieldData(
 
   const readerWithRefetchQueries = {
     kind: 'ReaderWithRefetchQueries',
-    readerArtifact: field.readerArtifact,
+    readerArtifact: field.readerArtifact(),
     nestedRefetchQueries: resolverRefetchQueries,
   } satisfies ReaderWithRefetchQueries<any, any>;
 
   const fragment = {
     kind: 'FragmentReference',
     readerWithRefetchQueries: wrapResolvedValue(readerWithRefetchQueries),
-    fieldName: field.readerArtifact.fieldName,
-    readerArtifactKind: field.readerArtifact.kind,
+    fieldName: readerWithRefetchQueries.readerArtifact.fieldName,
+    readerArtifactKind: readerWithRefetchQueries.readerArtifact.kind,
     root,
     variables: generateChildVariableMap(variables, field.arguments),
     networkRequest,
   } satisfies FragmentReference<any, any>;
 
-  switch (field.readerArtifact.kind) {
+  switch (readerWithRefetchQueries.readerArtifact.kind) {
     case 'EagerReaderArtifact': {
       const data = readData(
         environment,
-        field.readerArtifact.readerAst,
+        readerWithRefetchQueries.readerArtifact.readerAst,
         root,
         generateChildVariableMap(variables, field.arguments),
         resolverRefetchQueries,
@@ -585,7 +587,7 @@ export function readResolverFieldData(
       const firstParameter = {
         data: data.data,
         parameters: variables,
-        startUpdate: field.readerArtifact.hasUpdatable
+        startUpdate: readerWithRefetchQueries.readerArtifact.hasUpdatable
           ? getOrCreateCachedStartUpdate(
               environment,
               fragment,
@@ -595,7 +597,7 @@ export function readResolverFieldData(
       };
       return {
         kind: 'Success',
-        data: field.readerArtifact.resolver(firstParameter),
+        data: readerWithRefetchQueries.readerArtifact.resolver(firstParameter),
       };
     }
     case 'ComponentReaderArtifact': {
@@ -616,9 +618,7 @@ export function readScalarFieldData(
   storeRecord: StoreRecord,
   root: StoreLink,
   variables: Variables,
-): ReadDataResult<
-  string | number | boolean | StoreLink | readonly DataTypeValue[] | null
-> {
+): ReadDataResult<DataTypeValueScalar> {
   const storeRecordName = getParentRecordKey(field, variables);
   const value = storeRecord[storeRecordName];
   // TODO consider making scalars into discriminated unions. This probably has
@@ -651,7 +651,8 @@ export function readLinkedFieldData(
   let value = storeRecord[storeRecordName];
 
   if (field.condition != null) {
-    const data = readData(field.condition.readerAst, root);
+    const condition = field.condition();
+    const data = readData(condition.readerAst, root);
     if (data.kind === 'MissingData') {
       return {
         kind: 'MissingData',
@@ -664,7 +665,7 @@ export function readLinkedFieldData(
 
     const readerWithRefetchQueries = {
       kind: 'ReaderWithRefetchQueries',
-      readerArtifact: field.condition,
+      readerArtifact: condition,
       // TODO this is wrong
       // should map field.condition.usedRefetchQueries
       // but it doesn't exist
@@ -675,8 +676,8 @@ export function readLinkedFieldData(
       kind: 'FragmentReference',
       readerWithRefetchQueries: wrapResolvedValue(readerWithRefetchQueries),
       root,
-      fieldName: field.condition.fieldName,
-      readerArtifactKind: field.condition.kind,
+      fieldName: condition.fieldName,
+      readerArtifactKind: condition.kind,
       variables: generateChildVariableMap(
         variables,
         // TODO this is wrong
@@ -687,10 +688,10 @@ export function readLinkedFieldData(
       networkRequest,
     } satisfies FragmentReference<any, any>;
 
-    const condition = field.condition.resolver({
+    const link = condition.resolver({
       data: data.data,
       parameters: {},
-      ...(field.condition.hasUpdatable
+      ...(condition.hasUpdatable
         ? {
             startUpdate: getOrCreateCachedStartUpdate(
               environment,
@@ -700,7 +701,7 @@ export function readLinkedFieldData(
           }
         : undefined),
     });
-    value = condition;
+    value = link;
   }
 
   if (Array.isArray(value)) {
@@ -870,6 +871,7 @@ export function readClientPointerData(
     [
       {
         kind: 'Scalar',
+        isFallible: false,
         fieldName: 'id',
         alias: null,
         arguments: null,

package/src/core/reader.ts

@@ -88,6 +88,7 @@ export type ReaderAst<TReadFromStore> = ReadonlyArray<ReaderAstNode>;
 
 export type ReaderScalarField = {
   readonly kind: 'Scalar';
+  readonly isFallible: boolean;
   readonly fieldName: string;
   readonly alias: string | null;
   readonly arguments: Arguments | null;
@@ -101,14 +102,17 @@ export type ReaderLinkField = {
 
 export type ReaderLinkedField = {
   readonly kind: 'Linked';
+  readonly isFallible: boolean;
   readonly fieldName: string;
   readonly alias: string | null;
   readonly selections: ReaderAst<unknown>;
   readonly arguments: Arguments | null;
-  readonly condition: EagerReaderArtifact<
-    { data: any; parameters: any; startUpdate?: StartUpdate<any> },
-    StoreLink | null | (StoreLink | null)[] | StoreLink[]
-  > | null;
+  readonly condition:
+    | (() => EagerReaderArtifact<
+        { data: any; parameters: any; startUpdate?: StartUpdate<any> },
+        StoreLink | null | (StoreLink | null)[] | StoreLink[]
+      >)
+    | null;
   readonly isUpdatable: boolean;
   /**
    * If refetchQueryIndex != null, then the linked field is a client pointer.
@@ -124,7 +128,7 @@ export type ReaderNonLoadableResolverField = {
   readonly kind: 'Resolver';
   readonly alias: string;
   // TODO don't type this as any
-  readonly readerArtifact: TopLevelReaderArtifact<any, any, any>;
+  readonly readerArtifact: () => TopLevelReaderArtifact<any, any, any>;
   readonly arguments: Arguments | null;
   readonly usedRefetchQueries: number[];
 };

package/src/core/writeData.ts

@@ -1,15 +1,14 @@
-import type { ItemCleanupPair } from '@isograph/isograph-disposable-types/dist';
-import { callSubscriptions } from './subscribe';
+import type { ItemCleanupPair } from '@isograph/disposable-types';
 import {
-  type NetworkResponseObject,
   type EncounteredIds,
+  type NetworkResponseObject,
   normalizeData,
 } from './cache';
 import type { IsographEntrypoint, NormalizationAst } from './entrypoint';
 import type {
-  UnknownTReadFromStore,
   ExtractParameters,
   FragmentReference,
+  UnknownTReadFromStore,
 } from './FragmentReference';
 import {
   type IsographEnvironment,
@@ -19,6 +18,7 @@ import {
 import { logMessage } from './logging';
 import { retainQueryWithoutMakingNetworkRequest } from './makeNetworkRequest';
 import { addNetworkResponseStoreLayer } from './optimisticProxy';
+import { callSubscriptions } from './subscribe';
 
 export function writeData<
   TReadFromStore extends UnknownTReadFromStore,

package/src/index.ts

@@ -30,7 +30,8 @@ export { makeNetworkRequest } from './core/makeNetworkRequest';
 export {
   ROOT_ID,
   type DataId,
-  type DataTypeValue,
+  type DataTypeValueLinked,
+  type DataTypeValueScalar,
   type IsographEnvironment,
   type IsographNetworkFunction,
   type BaseStoreLayerData as IsographStore,

package/src/tests/__isograph/Economist/__link/output_type.ts

@@ -1,2 +1,3 @@
 import type { Link } from '@isograph/react';
-export type Economist____link__output_type = Link<"Economist">;
+export type Economist____link__output_type = 
+  | Link<"Economist">;

package/src/tests/__isograph/Node/asEconomist/resolver_reader.ts

@@ -3,6 +3,7 @@ import type { EagerReaderArtifact, ReaderAst, Link } from '@isograph/react';
 const readerAst: ReaderAst<{ data: any, parameters: Record<PropertyKey, never> }> = [
   {
     kind: "Scalar",
+    isFallible: false,
     fieldName: "__typename",
     alias: null,
     arguments: null,
@@ -14,15 +15,15 @@ const readerAst: ReaderAst<{ data: any, parameters: Record<PropertyKey, never> }
   },
 ];
 
-const artifact: EagerReaderArtifact<
+const artifact = (): EagerReaderArtifact<
   { data: any, parameters: Record<PropertyKey, never> },
   Link<"Economist"> | null
-> = {
+> => ({
   kind: "EagerReaderArtifact",
   fieldName: "asEconomist",
   resolver: ({ data }) => data.__typename === "Economist" ? data.__link : null,
   readerAst,
   hasUpdatable: false,
-};
+});
 
 export default artifact;

package/src/tests/__isograph/Query/linkedUpdate/normalization_ast.ts

@@ -4,6 +4,7 @@ const normalizationAst: NormalizationAst = {
   selections: [
     {
       kind: "Linked",
+      isFallible: true,
       fieldName: "node",
       arguments: [
         [
@@ -15,11 +16,13 @@ const normalizationAst: NormalizationAst = {
       selections: [
         {
           kind: "Scalar",
+          isFallible: false,
           fieldName: "__typename",
           arguments: null,
         },
         {
           kind: "Scalar",
+          isFallible: false,
           fieldName: "id",
           arguments: null,
         },
@@ -29,16 +32,19 @@ const normalizationAst: NormalizationAst = {
           selections: [
             {
               kind: "Scalar",
+              isFallible: false,
               fieldName: "__typename",
               arguments: null,
             },
             {
               kind: "Scalar",
+              isFallible: false,
               fieldName: "id",
               arguments: null,
             },
             {
               kind: "Scalar",
+              isFallible: false,
               fieldName: "name",
               arguments: null,
             },
@@ -48,6 +54,7 @@ const normalizationAst: NormalizationAst = {
     },
     {
       kind: "Linked",
+      isFallible: true,
       fieldName: "node",
       arguments: [
         [
@@ -59,11 +66,13 @@ const normalizationAst: NormalizationAst = {
       selections: [
         {
           kind: "Scalar",
+          isFallible: false,
           fieldName: "__typename",
           arguments: null,
         },
         {
           kind: "Scalar",
+          isFallible: false,
           fieldName: "id",
           arguments: null,
         },
@@ -73,16 +82,19 @@ const normalizationAst: NormalizationAst = {
           selections: [
             {
               kind: "Scalar",
+              isFallible: false,
               fieldName: "__typename",
               arguments: null,
             },
             {
               kind: "Scalar",
+              isFallible: false,
               fieldName: "id",
               arguments: null,
             },
             {
               kind: "Scalar",
+              isFallible: false,
               fieldName: "name",
               arguments: null,
             },