@isograph/react 0.3.1 → 0.4.1

package/dist/react/useImperativeReference.js

@@ -12,15 +12,15 @@ function useImperativeReference(entrypoint) {
     return {
         fragmentReference: state !== react_disposable_state_1.UNASSIGNED_STATE ? state : null,
         loadFragmentReference: (variables, fetchOptions) => {
-            const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.maybeMakeNetworkRequest)(environment, entrypoint, variables, fetchOptions);
+            const readerWithRefetchQueries = entrypoint.readerWithRefetchQueries.kind ===
+                'ReaderWithRefetchQueriesLoader'
+                ? (0, PromiseWrapper_1.wrapPromise)(entrypoint.readerWithRefetchQueries.loader())
+                : (0, PromiseWrapper_1.wrapResolvedValue)(entrypoint.readerWithRefetchQueries);
+            const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.maybeMakeNetworkRequest)(environment, entrypoint, variables, readerWithRefetchQueries, fetchOptions !== null && fetchOptions !== void 0 ? fetchOptions : null);
             setState([
                 {
                     kind: 'FragmentReference',
-                    readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)({
-                        kind: 'ReaderWithRefetchQueries',
-                        readerArtifact: entrypoint.readerWithRefetchQueries.readerArtifact,
-                        nestedRefetchQueries: entrypoint.readerWithRefetchQueries.nestedRefetchQueries,
-                    }),
+                    readerWithRefetchQueries,
                     root: { __link: IsographEnvironment_1.ROOT_ID, __typename: entrypoint.concreteType },
                     variables,
                     networkRequest,

package/dist/react/useResult.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useResult.d.ts","sourceRoot":"","sources":["../../src/react/useResult.ts"],"names":[],"mappings":"AACA,OAAO,EACL,iBAAiB,EACjB,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAEL,cAAc,EAEf,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAEL,2BAA2B,EAC5B,MAAM,cAAc,CAAC;AAKtB,wBAAgB,SAAS,CACvB,cAAc,SAAS,qBAAqB,EAC5C,iBAAiB,EAEjB,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,iBAAiB,CAAC,EACvE,4BAA4B,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,GAAG,IAAI,GACzE,iBAAiB,CA8CnB;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,EACzC,qBAAqB,EAAE,2BAA2B,QAWnD"}
+{"version":3,"file":"useResult.d.ts","sourceRoot":"","sources":["../../src/react/useResult.ts"],"names":[],"mappings":"AACA,OAAO,EACL,iBAAiB,EACjB,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAEL,cAAc,EAEf,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAEL,2BAA2B,EAC5B,MAAM,cAAc,CAAC;AAKtB,wBAAgB,SAAS,CACvB,cAAc,SAAS,qBAAqB,EAC5C,iBAAiB,EAEjB,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,iBAAiB,CAAC,EACvE,4BAA4B,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,GAAG,IAAI,GACzE,iBAAiB,CA+CnB;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,EACzC,qBAAqB,EAAE,2BAA2B,QAWnD"}

package/dist/react/useResult.js

@@ -22,7 +22,7 @@ function useResult(fragmentReference, partialNetworkRequestOptions) {
             const data = (0, useReadAndSubscribe_1.useReadAndSubscribe)(fragmentReference, networkRequestOptions, readerWithRefetchQueries.readerArtifact.readerAst);
             const param = Object.assign({ data: data, parameters: fragmentReference.variables }, (readerWithRefetchQueries.readerArtifact.hasUpdatable
                 ? {
-                    startUpdate: (0, startUpdate_1.getOrCreateCachedStartUpdate)(environment, fragmentReference, readerWithRefetchQueries.readerArtifact.fieldName),
+                    startUpdate: (0, startUpdate_1.getOrCreateCachedStartUpdate)(environment, fragmentReference, readerWithRefetchQueries.readerArtifact.fieldName, networkRequestOptions),
                 }
                 : undefined));
             return readerWithRefetchQueries.readerArtifact.resolver(param);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -8,16 +8,15 @@
   "author": "Isograph Labs",
   "license": "MIT",
   "scripts": {
-    "compile-typescript": "rm -rf dist/* && tsc -p tsconfig.pkg.json",
+    "compile-libs": "rimraf dist && tsc -p tsconfig.pkg.json",
     "compile-watch": "tsc -p tsconfig.pkg.json --watch",
     "test": "vitest run",
     "test-watch": "vitest watch",
     "coverage": "vitest run --coverage",
-    "prepack": "pnpm run test && pnpm run compile-typescript",
+    "prepack": "pnpm run test && pnpm run compile-libs",
     "tsc": "tsc",
     "tsc-force": "tsc --build --clean && tsc --build --force",
-    "iso": "cross-env ../../target/debug/isograph_cli --config ./isograph.config.json",
-    "iso-watch": "cross-env ../../target/debug/isograph_cli --config ./isograph.config.json --watch"
+    "iso": "cross-env ISO_PRINT_ABSOLUTE_FILEPATH=1 ../../target/debug/isograph_cli --config ./isograph.config.json"
   },
   "dependencies": {
     "@isograph/disposable-types": "*",

package/src/core/FragmentReference.ts

@@ -1,6 +1,6 @@
 import { ReaderWithRefetchQueries } from '../core/entrypoint';
 import { stableCopy } from './cache';
-import { type Link } from './IsographEnvironment';
+import { type StoreLink } from './IsographEnvironment';
 import { PromiseWrapper } from './PromiseWrapper';
 import type { StartUpdate } from './reader';
 
@@ -35,11 +35,14 @@ export type ExtractParameters<T> = T extends {
   ? P
   : Variables;
 
-export type ExtractStartUpdate<
-  T extends {
-    startUpdate?: StartUpdate<object>;
-  },
-> = T['startUpdate'];
+export type ExtractStartUpdate<T extends UnknownTReadFromStore> =
+  T['startUpdate'];
+
+export type ExtractUpdatableData<T extends UnknownTReadFromStore> =
+  ExtractUpdatableDataFromStartUpdate<ExtractStartUpdate<T>>;
+
+export type ExtractUpdatableDataFromStartUpdate<T> =
+  T extends StartUpdate<infer D> ? D : never;
 
 export type FragmentReference<
   TReadFromStore extends UnknownTReadFromStore,
@@ -49,7 +52,13 @@ export type FragmentReference<
   readonly readerWithRefetchQueries: PromiseWrapper<
     ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
   >;
-  readonly root: Link;
+  readonly root: StoreLink;
+  // TODO we potentially stably copy and stringify variables a lot!
+  // So, we should employ interior mutability: pretend that fragent reference
+  // is immutable, but actually store something like
+  // `Map<Variable, StablyCopiedStringifiedOutput>`
+  // and read or update that map when we would otherwise stably copy and
+  // stringify.
   readonly variables: ExtractParameters<TReadFromStore>;
   readonly networkRequest: PromiseWrapper<void, any>;
 };

package/src/core/IsographEnvironment.ts

@@ -1,5 +1,9 @@
 import { ParentCache } from '@isograph/react-disposable-state';
-import { IsographEntrypoint } from './entrypoint';
+import {
+  IsographEntrypoint,
+  IsographOperation,
+  IsographPersistedOperation,
+} from './entrypoint';
 import {
   FragmentReference,
   Variables,
@@ -11,6 +15,7 @@ import { LogFunction, WrappedLogFunction } from './logging';
 import { PromiseWrapper, wrapPromise } from './PromiseWrapper';
 import { WithEncounteredRecords } from './read';
 import type { ReaderAst, StartUpdate } from './reader';
+import type { Brand } from './brand';
 
 export type ComponentOrFieldName = string;
 export type StringifiedArgs = string;
@@ -26,7 +31,7 @@ export type FragmentSubscription<TReadFromStore extends UnknownTReadFromStore> =
       newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,
     ) => void;
     /** The value read out from the previous call to readButDoNotEvaluate */
-    readonly encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>;
+    encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>;
     readonly fragmentReference: FragmentReference<TReadFromStore, any>;
     readonly readerAst: ReaderAst<TReadFromStore>;
   };
@@ -34,7 +39,7 @@ export type FragmentSubscription<TReadFromStore extends UnknownTReadFromStore> =
 export type AnyChangesToRecordSubscription = {
   readonly kind: 'AnyChangesToRecord';
   readonly callback: () => void;
-  readonly recordLink: Link;
+  readonly recordLink: StoreLink;
 };
 
 export type AnyRecordSubscription = {
@@ -73,18 +78,23 @@ export type IsographEnvironment = {
 
 export type MissingFieldHandler = (
   storeRecord: StoreRecord,
-  root: Link,
+  root: StoreLink,
   fieldName: string,
   arguments_: { [index: string]: any } | null,
   variables: Variables | null,
-) => Link | undefined;
+) => StoreLink | undefined;
 
 export type IsographNetworkFunction = (
-  queryText: string,
+  operation: IsographOperation | IsographPersistedOperation,
   variables: Variables,
 ) => Promise<any>;
 
-export type Link = {
+export interface Link<T extends TypeName> extends StoreLink {
+  readonly __link: Brand<DataId, T>;
+  readonly __typename: T;
+}
+
+export type StoreLink = {
   readonly __link: DataId;
   readonly __typename: TypeName;
 };
@@ -99,7 +109,7 @@ export type DataTypeValue =
   | string
   | null
   // Singular linked fields:
-  | Link
+  | StoreLink
   // Plural scalar and linked fields:
   | DataTypeValue[];
 
@@ -158,7 +168,7 @@ export function createIsographStore(): IsographStore {
   };
 }
 
-export function assertLink(link: DataTypeValue): Link | null | undefined {
+export function assertLink(link: DataTypeValue): StoreLink | null | undefined {
   if (Array.isArray(link)) {
     throw new Error('Unexpected array');
   }
@@ -171,7 +181,7 @@ export function assertLink(link: DataTypeValue): Link | null | undefined {
   throw new Error('Invalid link');
 }
 
-export function getLink(maybeLink: DataTypeValue): Link | null {
+export function getLink(maybeLink: DataTypeValue): StoreLink | null {
   if (
     maybeLink != null &&
     typeof maybeLink === 'object' &&

package/src/core/PromiseWrapper.ts

@@ -1,6 +1,6 @@
 export type AnyError = any;
 
-export const NOT_SET: Symbol = Symbol('NOT_SET');
+export const NOT_SET = Symbol('NOT_SET');
 export type NotSet = typeof NOT_SET;
 
 export type Result<T, E> =
@@ -18,31 +18,32 @@ export type Result<T, E> =
  * Before the promise is resolved, value becomes non-null.
  */
 export type PromiseWrapper<T, E = any> = {
-  readonly promise: Promise<T>;
+  readonly promise: Promise<Exclude<T, NotSet>>;
   result: Result<Exclude<T, NotSet>, E> | NotSet;
 };
 
-export function wrapPromise<T>(promise: Promise<T>): PromiseWrapper<T, any> {
+export function wrapPromise<T>(
+  promise: Promise<Exclude<T, NotSet>>,
+): PromiseWrapper<T, unknown> {
   // TODO confirm suspense works if the promise is already resolved.
   const wrapper: PromiseWrapper<T, any> = { promise, result: NOT_SET };
   promise
     .then((v) => {
-      // v is assignable to Exclude<T, Symbol> | Symbol
-      wrapper.result = { kind: 'Ok', value: v as any };
+      wrapper.result = { kind: 'Ok', value: v };
     })
     .catch((e) => {
-      // e is assignable to Exclude<T, Symbol> | Symbol
-      wrapper.result = { kind: 'Err', error: e as any };
+      wrapper.result = { kind: 'Err', error: e };
     });
   return wrapper;
 }
 
-export function wrapResolvedValue<T>(value: T): PromiseWrapper<T, never> {
+export function wrapResolvedValue<T>(
+  value: Exclude<T, NotSet>,
+): PromiseWrapper<T, never> {
   return {
     promise: Promise.resolve(value),
     result: {
       kind: 'Ok',
-      // @ts-expect-error one should not call wrapResolvedValue with NOT_SET
       value,
     },
   };
@@ -51,8 +52,7 @@ export function wrapResolvedValue<T>(value: T): PromiseWrapper<T, never> {
 export function readPromise<T, E>(p: PromiseWrapper<T, E>): T {
   const { result } = p;
   if (result !== NOT_SET) {
-    // Safety: p.result is either NOT_SET or an actual value.
-    const resultKind = result as Result<T, any>;
+    const resultKind = result;
     if (resultKind.kind === 'Ok') {
       return resultKind.value;
     } else {
@@ -73,11 +73,8 @@ export type PromiseState<T, E> =
 export function getPromiseState<T, E>(
   p: PromiseWrapper<T, E>,
 ): PromiseState<T, E> {
-  const { result } = p;
-  if (result !== NOT_SET) {
-    // Safety: p.result is either NOT_SET or an actual value.
-    const resultKind = result as Result<T, any>;
-    return resultKind;
+  if (p.result !== NOT_SET) {
+    return p.result;
   }
   return {
     kind: 'Pending',

package/src/core/areEqualWithDeepComparison.ts

@@ -1,7 +1,7 @@
-import type { Link } from './IsographEnvironment';
+import type { StoreLink } from './IsographEnvironment';
 import type { ReaderAst, ReaderLinkedField, ReaderScalarField } from './reader';
 
-export function mergeUsingReaderAst(
+function mergeUsingReaderAst(
   field: ReaderScalarField | ReaderLinkedField,
   oldItem: unknown,
   newItem: unknown,
@@ -40,7 +40,7 @@ export function mergeUsingReaderAst(
   }
 }
 
-export function mergeArraysUsingReaderAst(
+function mergeArraysUsingReaderAst(
   field: ReaderScalarField | ReaderLinkedField,
   oldItems: ReadonlyArray<unknown>,
   newItems: Array<unknown>,
@@ -101,9 +101,9 @@ export function mergeObjectsUsingReaderAst(
       case 'Link': {
         const key = field.alias;
         // @ts-expect-error
-        const oldValue: Link = oldItemObject[key];
+        const oldValue: StoreLink = oldItemObject[key];
         // @ts-expect-error
-        const newValue: Link = newItemObject[key];
+        const newValue: StoreLink = newItemObject[key];
 
         if (
           oldValue.__link !== newValue.__link ||

package/src/core/brand.ts

@@ -0,0 +1,18 @@
+// Suppress the TypeScript compiler warning for this branded-type trick.
+// See discussion: https://github.com/microsoft/TypeScript/issues/202#issuecomment-436900738
+// Pattern: “Brand<BaseType, Brand>” leverages TypeScript conditional and `infer` types to create a pseudo-nominal type,
+// enabling BaseType to be treated as distinct only when tagged with Brand, even though Brand doesn't exist at runtime.
+//
+// Explanation:
+// - Brand extends `symbol | string` acts as a “brand” identifier.
+// - The type uses a conditional check `infer _ extends Brand ? BaseType : never` to strip out BaseType when the branding doesn't match.
+// - This yields a branded type system: `Brand<string, "UserId">` is not accidentally assignable to `Brand<string, "ProductId">`.
+//
+// Usage: Helps enforce semantic distinctions (e.g., distinguishing user IDs from product IDs) even when their runtime values are both strings.
+//
+// Caveat: This is purely a compile-time trick—Brand is erased in emitted JavaScript, so runtime checks must rely on other mechanisms.
+export type Brand<
+  BaseType,
+  Brand extends symbol | string,
+  // @ts-ignore
+> = infer _ extends Brand ? BaseType : never;

package/src/core/cache.ts

@@ -8,7 +8,6 @@ import {
   NormalizationInlineFragment,
   NormalizationLinkedField,
   NormalizationScalarField,
-  RefetchQueryNormalizationArtifactWrapper,
   type NormalizationAst,
   type NormalizationAstLoader,
   type NormalizationAstNodes,
@@ -27,15 +26,15 @@ import {
   DataTypeValue,
   FragmentSubscription,
   getLink,
-  Link,
   ROOT_ID,
+  StoreLink,
   StoreRecord,
   type IsographEnvironment,
   type TypeName,
 } from './IsographEnvironment';
 import { logMessage } from './logging';
 import { maybeMakeNetworkRequest } from './makeNetworkRequest';
-import { wrapResolvedValue } from './PromiseWrapper';
+import { wrapPromise, wrapResolvedValue } from './PromiseWrapper';
 import { readButDoNotEvaluate, WithEncounteredRecords } from './read';
 import { ReaderLinkedField, ReaderScalarField, type ReaderAst } from './reader';
 import { Argument, ArgumentValue } from './util';
@@ -93,15 +92,31 @@ export function getOrCreateCacheForArtifact<
   variables: ExtractParameters<TReadFromStore>,
   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<
@@ -109,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,
@@ -147,8 +157,7 @@ export function normalizeData(
   normalizationAst: NormalizationAstNodes,
   networkResponse: NetworkResponseObject,
   variables: Variables,
-  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
-  root: Link,
+  root: StoreLink,
 ): EncounteredIds {
   const encounteredIds: EncounteredIds = new Map();
 
@@ -169,7 +178,6 @@ export function normalizeData(
     newStoreRecord,
     root,
     variables,
-    nestedRefetchQueries,
     encounteredIds,
   );
 
@@ -197,7 +205,7 @@ export function subscribeToAnyChange(
 
 export function subscribeToAnyChangesToRecord(
   environment: IsographEnvironment,
-  recordLink: Link,
+  recordLink: StoreLink,
   callback: () => void,
 ): () => void {
   const subscription = {
@@ -232,7 +240,7 @@ export function subscribe<TReadFromStore extends UnknownTReadFromStore>(
 
 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 {
-  return (t) => {
-    try {
-      return f(t);
-    } catch {}
-  };
+function logAnyError(
+  environment: IsographEnvironment,
+  context: any,
+  f: () => void,
+) {
+  try {
+    f();
+  } catch (e) {
+    logMessage(environment, () => ({
+      kind: 'ErrorEncounteredInWithErrorHandling',
+      error: e,
+      context,
+    }));
+  }
 }
 
-function callSubscriptions(
+export function callSubscriptions(
   environment: IsographEnvironment,
   recordsEncounteredWhenNormalizing: EncounteredIds,
 ) {
-  environment.subscriptions.forEach(
-    withErrorHandling((subscription) => {
+  environment.subscriptions.forEach((subscription) =>
+    logAnyError(environment, { situation: 'calling subscriptions' }, () => {
       switch (subscription.kind) {
         case 'FragmentSubscription': {
           // TODO if there are multiple components subscribed to the same
@@ -313,13 +329,25 @@ function callSubscriptions(
             }));
 
             if (mergedItem !== subscription.encounteredDataAndRecords.item) {
-              subscription.callback(newEncounteredDataAndRecords);
+              logAnyError(
+                environment,
+                { situation: 'calling FragmentSubscription callback' },
+                () => {
+                  subscription.callback(newEncounteredDataAndRecords);
+                },
+              );
+              subscription.encounteredDataAndRecords =
+                newEncounteredDataAndRecords;
             }
           }
           return;
         }
         case 'AnyRecords': {
-          subscription.callback();
+          logAnyError(
+            environment,
+            { situation: 'calling AnyRecords callback' },
+            () => subscription.callback(),
+          );
           return;
         }
         case 'AnyChangesToRecord': {
@@ -328,7 +356,11 @@ function callSubscriptions(
               .get(subscription.recordLink.__typename)
               ?.has(subscription.recordLink.__link)
           ) {
-            subscription.callback();
+            logAnyError(
+              environment,
+              { situation: 'calling AnyChangesToRecord callback' },
+              () => subscription.callback(),
+            );
           }
           return;
         }
@@ -379,9 +411,8 @@ function normalizeDataIntoRecord(
   normalizationAst: NormalizationAstNodes,
   networkResponseParentRecord: NetworkResponseObject,
   targetParentRecord: StoreRecord,
-  targetParentRecordLink: Link,
+  targetParentRecordLink: StoreLink,
   variables: Variables,
-  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   mutableEncounteredIds: EncounteredIds,
 ): RecordHasBeenUpdated {
   let recordHasBeenUpdated = false;
@@ -406,7 +437,6 @@ function normalizeDataIntoRecord(
           targetParentRecord,
           targetParentRecordLink,
           variables,
-          nestedRefetchQueries,
           mutableEncounteredIds,
         );
         recordHasBeenUpdated =
@@ -421,7 +451,6 @@ function normalizeDataIntoRecord(
           targetParentRecord,
           targetParentRecordLink,
           variables,
-          nestedRefetchQueries,
           mutableEncounteredIds,
         );
         recordHasBeenUpdated =
@@ -437,7 +466,7 @@ function normalizeDataIntoRecord(
     }
   }
   if (recordHasBeenUpdated) {
-    let encounteredRecordsIds = insertIfNotExists(
+    let encounteredRecordsIds = insertEmptySetIfMissing(
       mutableEncounteredIds,
       targetParentRecordLink.__typename,
     );
@@ -447,7 +476,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 +516,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 +541,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 +555,6 @@ function normalizeLinkedField(
         targetParentRecordLink,
         variables,
         i,
-        nestedRefetchQueries,
         mutableEncounteredIds,
       );
 
@@ -554,7 +581,6 @@ function normalizeLinkedField(
       targetParentRecordLink,
       variables,
       null,
-      nestedRefetchQueries,
       mutableEncounteredIds,
     );
 
@@ -586,9 +612,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 +625,6 @@ function normalizeInlineFragment(
       targetParentRecord,
       targetParentRecordLink,
       variables,
-      nestedRefetchQueries,
       mutableEncounteredIds,
     );
     return hasBeenModified;
@@ -610,7 +634,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 +659,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 +691,6 @@ function normalizeNetworkResponseObject(
     newStoreRecord,
     { __link: newStoreRecordId, __typename: __typename },
     variables,
-    nestedRefetchQueries,
     mutableEncounteredIds,
   );
 
@@ -760,13 +782,14 @@ function getStoreKeyChunkForArgumentValue(
 }
 
 function getStoreKeyChunkForArgument(argument: Argument, variables: Variables) {
-  let chunk = getStoreKeyChunkForArgumentValue(argument[1], variables);
+  const [argumentName, argumentValue] = argument;
+  let chunk = getStoreKeyChunkForArgumentValue(argumentValue, variables);
 
   if (typeof chunk === 'object') {
     chunk = JSON.stringify(stableCopy(chunk));
   }
 
-  return `${FIRST_SPLIT_KEY}${argument[0]}${SECOND_SPLIT_KEY}${chunk}`;
+  return `${FIRST_SPLIT_KEY}${argumentName}${SECOND_SPLIT_KEY}${chunk}`;
 }
 
 function getNetworkResponseKey(
@@ -831,7 +854,7 @@ 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,