@isograph/react 0.0.0-main-945e49cc → 0.0.0-main-dc9ca2f6

package/dist/IsographEnvironment.d.ts

@@ -1,6 +1,7 @@
 import { ReactNode } from 'react';
 import * as React from 'react';
 import { ParentCache } from '@isograph/isograph-react-disposable-state';
+import { NormalizationAst } from './index';
 export declare const IsographEnvironmentContext: React.Context<IsographEnvironment | null>;
 type ComponentName = string;
 type StringifiedArgs = string;
@@ -15,6 +16,10 @@ export type Subscriptions = Set<() => void>;
 type SuspenseCache = {
     [index: string]: ParentCache<any>;
 };
+export type RetainedQuery = {
+    normalizationAst: NormalizationAst;
+    variables: {};
+};
 export type IsographEnvironment = {
     store: IsographStore;
     networkFunction: IsographNetworkFunction;
@@ -22,6 +27,9 @@ export type IsographEnvironment = {
     componentCache: ComponentCache;
     subscriptions: Subscriptions;
     suspenseCache: SuspenseCache;
+    retainedQueries: Set<RetainedQuery>;
+    gcBuffer: Array<RetainedQuery>;
+    gcBufferSize: number;
 };
 export type MissingFieldHandler = (storeRecord: StoreRecord, root: DataId, fieldName: string, arguments_: {
     [index: string]: any;
@@ -53,4 +61,8 @@ export declare function createIsographEnvironment(store: IsographStore, networkF
 export declare function createIsographStore(): {
     __ROOT: {};
 };
+export declare function garbageCollectEnvironment(environment: IsographEnvironment): void;
+type DidUnretainSomeQuery = boolean;
+export declare function unretainQuery(environment: IsographEnvironment, retainedQuery: RetainedQuery): DidUnretainSomeQuery;
+export declare function retainQuery(environment: IsographEnvironment, queryToRetain: RetainedQuery): void;
 export {};

package/dist/IsographEnvironment.js

@@ -23,9 +23,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIsographStore = exports.createIsographEnvironment = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.ROOT_ID = exports.IsographEnvironmentContext = void 0;
+exports.retainQuery = exports.unretainQuery = exports.garbageCollectEnvironment = exports.createIsographStore = exports.createIsographEnvironment = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.ROOT_ID = exports.IsographEnvironmentContext = void 0;
 const react_1 = require("react");
 const React = __importStar(require("react"));
+const cache_1 = require("./cache");
 exports.IsographEnvironmentContext = (0, react_1.createContext)(null);
 exports.ROOT_ID = '__ROOT';
 function IsographEnvironmentProvider({ environment, children, }) {
@@ -41,6 +42,7 @@ function useIsographEnvironment() {
     return context;
 }
 exports.useIsographEnvironment = useIsographEnvironment;
+const DEFAULT_GC_BUFFER_SIZE = 10;
 function createIsographEnvironment(store, networkFunction, missingFieldHandler) {
     return {
         store,
@@ -49,6 +51,9 @@ function createIsographEnvironment(store, networkFunction, missingFieldHandler)
         componentCache: {},
         subscriptions: new Set(),
         suspenseCache: {},
+        retainedQueries: new Set(),
+        gcBuffer: [],
+        gcBufferSize: DEFAULT_GC_BUFFER_SIZE,
     };
 }
 exports.createIsographEnvironment = createIsographEnvironment;
@@ -58,3 +63,82 @@ function createIsographStore() {
     };
 }
 exports.createIsographStore = createIsographStore;
+function garbageCollectEnvironment(environment) {
+    const retainedIds = new Set([exports.ROOT_ID]);
+    for (const query of environment.retainedQueries) {
+        recordReachableIds(environment.store, query, retainedIds);
+    }
+    for (const query of environment.gcBuffer) {
+        recordReachableIds(environment.store, query, retainedIds);
+    }
+    for (const dataId in environment.store) {
+        if (!retainedIds.has(dataId)) {
+            delete environment.store[dataId];
+        }
+    }
+}
+exports.garbageCollectEnvironment = garbageCollectEnvironment;
+function recordReachableIds(store, retainedQuery, mutableRetainedIds) {
+    recordReachableIdsFromRecord(store, store[exports.ROOT_ID], mutableRetainedIds, retainedQuery.normalizationAst, retainedQuery.variables);
+}
+function getLinkedId(data) {
+    // @ts-expect-error
+    if (data.__link != null) {
+        // @ts-expect-error
+        return data.__link;
+    }
+    else {
+        throw new Error('Record in an invalid state');
+    }
+}
+function recordReachableIdsFromRecord(store, currentRecord, mutableRetainedIds, selections, variables) {
+    for (const selection of selections) {
+        switch (selection.kind) {
+            case 'Linked':
+                const linkKey = (0, cache_1.getParentRecordKey)(selection, variables !== null && variables !== void 0 ? variables : {});
+                const linkedFieldOrFields = currentRecord[linkKey];
+                const ids = [];
+                if (Array.isArray(linkedFieldOrFields)) {
+                    for (const link of linkedFieldOrFields) {
+                        if (link != null) {
+                            const id = getLinkedId(link);
+                            ids.push(id);
+                        }
+                    }
+                }
+                else {
+                    if (linkedFieldOrFields != null) {
+                        const id = getLinkedId(linkedFieldOrFields);
+                        ids.push(id);
+                    }
+                }
+                for (const nextRecordId of ids) {
+                    const nextRecord = store[nextRecordId];
+                    if (nextRecord != null) {
+                        mutableRetainedIds.add(nextRecordId);
+                        recordReachableIdsFromRecord(store, nextRecord, mutableRetainedIds, selection.selections, variables);
+                    }
+                }
+                continue;
+            case 'Scalar':
+                continue;
+        }
+    }
+}
+function unretainQuery(environment, retainedQuery) {
+    environment.retainedQueries.delete(retainedQuery);
+    environment.gcBuffer.push(retainedQuery);
+    if (environment.gcBuffer.length > environment.gcBufferSize) {
+        environment.gcBuffer.shift();
+        return true;
+    }
+    return false;
+}
+exports.unretainQuery = unretainQuery;
+function retainQuery(environment, queryToRetain) {
+    environment.retainedQueries.add(queryToRetain);
+    // TODO can we remove this query from the buffer somehow?
+    // We are relying on === equality, but we really should be comparing
+    // id + variables
+}
+exports.retainQuery = retainQuery;

package/dist/cache.js

@@ -49,34 +49,60 @@ function makeNetworkRequest(environment, artifact, variables) {
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('make network request', artifact, variables);
     }
+    let status = {
+        kind: 'UndisposedIncomplete',
+    };
+    // This should be an observable, not a promise
     const promise = environment
         .networkFunction(artifact.queryText, variables)
         .then((networkResponse) => {
         if (typeof window !== 'undefined' && window.__LOG) {
             console.log('network response', artifact, artifact);
         }
-        normalizeData(environment, artifact.normalizationAst, networkResponse.data, variables, artifact.nestedRefetchQueries);
-        return networkResponse.data;
+        if (status.kind === 'UndisposedIncomplete') {
+            normalizeData(environment, artifact.normalizationAst, networkResponse.data, variables, artifact.nestedRefetchQueries);
+            const retainedQuery = {
+                normalizationAst: artifact.normalizationAst,
+                variables,
+            };
+            status = {
+                kind: 'UndisposedComplete',
+                retainedQuery,
+            };
+            (0, IsographEnvironment_1.retainQuery)(environment, retainedQuery);
+        }
+        // TODO return null
+        return networkResponse;
     });
     const wrapper = (0, PromiseWrapper_1.wrapPromise)(promise);
     const response = [
         wrapper,
         () => {
-            // delete from cache
+            if (status.kind === 'UndisposedComplete') {
+                const didUnretainSomeQuery = (0, IsographEnvironment_1.unretainQuery)(environment, status.retainedQuery);
+                if (didUnretainSomeQuery) {
+                    (0, IsographEnvironment_1.garbageCollectEnvironment)(environment);
+                }
+            }
+            status = {
+                kind: 'Disposed',
+            };
         },
     ];
     return response;
 }
 exports.makeNetworkRequest = makeNetworkRequest;
 function normalizeData(environment, normalizationAst, networkResponse, variables, nestedRefetchQueries) {
+    const encounteredIds = new Set();
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('about to normalize', normalizationAst, networkResponse, variables);
     }
-    normalizeDataIntoRecord(environment, normalizationAst, networkResponse, environment.store.__ROOT, IsographEnvironment_1.ROOT_ID, variables, nestedRefetchQueries);
+    normalizeDataIntoRecord(environment, normalizationAst, networkResponse, environment.store.__ROOT, IsographEnvironment_1.ROOT_ID, variables, nestedRefetchQueries, encounteredIds);
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('after normalization', { store: environment.store });
     }
     callSubscriptions(environment);
+    return encounteredIds;
 }
 function subscribe(environment, callback) {
     environment.subscriptions.add(callback);
@@ -98,7 +124,8 @@ function callSubscriptions(environment) {
 /**
  * Mutate targetParentRecord according to the normalizationAst and networkResponseParentRecord.
  */
-function normalizeDataIntoRecord(environment, normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
+function normalizeDataIntoRecord(environment, normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds) {
+    mutableEncounteredIds.add(targetParentRecordId);
     for (const normalizationNode of normalizationAst) {
         switch (normalizationNode.kind) {
             case 'Scalar': {
@@ -106,7 +133,7 @@ function normalizeDataIntoRecord(environment, normalizationAst, networkResponseP
                 break;
             }
             case 'Linked': {
-                normalizeLinkedField(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries);
+                normalizeLinkedField(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds);
                 break;
             }
         }
@@ -127,7 +154,7 @@ function normalizeScalarField(astNode, networkResponseParentRecord, targetStoreR
 /**
  * Mutate targetParentRecord with a given linked field ast node.
  */
-function normalizeLinkedField(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
+function normalizeLinkedField(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds) {
     const networkResponseKey = getNetworkResponseKey(astNode);
     const networkResponseData = networkResponseParentRecord[networkResponseKey];
     const parentRecordKey = getParentRecordKey(astNode, variables);
@@ -143,24 +170,24 @@ function normalizeLinkedField(environment, astNode, networkResponseParentRecord,
         const dataIds = [];
         for (let i = 0; i < networkResponseData.length; i++) {
             const networkResponseObject = networkResponseData[i];
-            const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseObject, targetParentRecordId, variables, i, nestedRefetchQueries);
+            const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseObject, targetParentRecordId, variables, i, nestedRefetchQueries, mutableEncounteredIds);
             dataIds.push({ __link: newStoreRecordId });
         }
         targetParentRecord[parentRecordKey] = dataIds;
     }
     else {
-        const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, null, nestedRefetchQueries);
+        const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, null, nestedRefetchQueries, mutableEncounteredIds);
         targetParentRecord[parentRecordKey] = {
             __link: newStoreRecordId,
         };
     }
 }
-function normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, index, nestedRefetchQueries) {
+function normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, index, nestedRefetchQueries, mutableEncounteredIds) {
     var _a;
     const newStoreRecordId = getDataIdOfNetworkResponse(targetParentRecordId, networkResponseData, astNode, variables, index);
     const newStoreRecord = (_a = environment.store[newStoreRecordId]) !== null && _a !== void 0 ? _a : {};
     environment.store[newStoreRecordId] = newStoreRecord;
-    normalizeDataIntoRecord(environment, astNode.selections, networkResponseData, newStoreRecord, newStoreRecordId, variables, nestedRefetchQueries);
+    normalizeDataIntoRecord(environment, astNode.selections, networkResponseData, newStoreRecord, newStoreRecordId, variables, nestedRefetchQueries, mutableEncounteredIds);
     return newStoreRecordId;
 }
 function isScalarOrEmptyArray(data) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-945e49cc",
+  "version": "0.0.0-main-dc9ca2f6",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -16,8 +16,8 @@
     "prepack": "yarn run test && yarn run compile"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-945e49cc",
-    "@isograph/react-disposable-state": "0.0.0-main-945e49cc",
+    "@isograph/disposable-types": "0.0.0-main-dc9ca2f6",
+    "@isograph/react-disposable-state": "0.0.0-main-dc9ca2f6",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/IsographEnvironment.tsx

@@ -1,6 +1,8 @@
 import { ReactNode, createContext, useContext } from 'react';
 import * as React from 'react';
 import { ParentCache } from '@isograph/isograph-react-disposable-state';
+import { NormalizationAst } from './index';
+import { getParentRecordKey } from './cache';
 
 export const IsographEnvironmentContext =
   createContext<IsographEnvironment | null>(null);
@@ -16,6 +18,11 @@ type ComponentCache = {
 export type Subscriptions = Set<() => void>;
 type SuspenseCache = { [index: string]: ParentCache<any> };
 
+export type RetainedQuery = {
+  normalizationAst: NormalizationAst;
+  variables: {};
+};
+
 export type IsographEnvironment = {
   store: IsographStore;
   networkFunction: IsographNetworkFunction;
@@ -23,6 +30,9 @@ export type IsographEnvironment = {
   componentCache: ComponentCache;
   subscriptions: Subscriptions;
   suspenseCache: SuspenseCache;
+  retainedQueries: Set<RetainedQuery>;
+  gcBuffer: Array<RetainedQuery>;
+  gcBufferSize: number;
 };
 
 export type MissingFieldHandler = (
@@ -98,6 +108,7 @@ export function useIsographEnvironment(): IsographEnvironment {
   return context;
 }
 
+const DEFAULT_GC_BUFFER_SIZE = 10;
 export function createIsographEnvironment(
   store: IsographStore,
   networkFunction: IsographNetworkFunction,
@@ -110,6 +121,9 @@ export function createIsographEnvironment(
     componentCache: {},
     subscriptions: new Set(),
     suspenseCache: {},
+    retainedQueries: new Set(),
+    gcBuffer: [],
+    gcBufferSize: DEFAULT_GC_BUFFER_SIZE,
   };
 }
 
@@ -118,3 +132,119 @@ export function createIsographStore() {
     [ROOT_ID]: {},
   };
 }
+
+export function garbageCollectEnvironment(environment: IsographEnvironment) {
+  const retainedIds = new Set<DataId>([ROOT_ID]);
+
+  for (const query of environment.retainedQueries) {
+    recordReachableIds(environment.store, query, retainedIds);
+  }
+  for (const query of environment.gcBuffer) {
+    recordReachableIds(environment.store, query, retainedIds);
+  }
+
+  for (const dataId in environment.store) {
+    if (!retainedIds.has(dataId)) {
+      delete environment.store[dataId];
+    }
+  }
+}
+
+function recordReachableIds(
+  store: IsographStore,
+  retainedQuery: RetainedQuery,
+  mutableRetainedIds: Set<DataId>,
+) {
+  recordReachableIdsFromRecord(
+    store,
+    store[ROOT_ID],
+    mutableRetainedIds,
+    retainedQuery.normalizationAst,
+    retainedQuery.variables,
+  );
+}
+
+function getLinkedId(data: Exclude<DataTypeValue, null | void>): string {
+  // @ts-expect-error
+  if (data.__link != null) {
+    // @ts-expect-error
+    return data.__link;
+  } else {
+    throw new Error('Record in an invalid state');
+  }
+}
+
+function recordReachableIdsFromRecord(
+  store: IsographStore,
+  currentRecord: StoreRecord,
+  mutableRetainedIds: Set<DataId>,
+  selections: NormalizationAst,
+  variables: { [index: string]: string } | null,
+) {
+  for (const selection of selections) {
+    switch (selection.kind) {
+      case 'Linked':
+        const linkKey = getParentRecordKey(selection, variables ?? {});
+        const linkedFieldOrFields = currentRecord[linkKey];
+
+        const ids = [];
+        if (Array.isArray(linkedFieldOrFields)) {
+          for (const link of linkedFieldOrFields) {
+            if (link != null) {
+              const id = getLinkedId(link);
+              ids.push(id);
+            }
+          }
+        } else {
+          if (linkedFieldOrFields != null) {
+            const id = getLinkedId(linkedFieldOrFields);
+            ids.push(id);
+          }
+        }
+
+        for (const nextRecordId of ids) {
+          const nextRecord = store[nextRecordId];
+          if (nextRecord != null) {
+            mutableRetainedIds.add(nextRecordId);
+            recordReachableIdsFromRecord(
+              store,
+              nextRecord,
+              mutableRetainedIds,
+              selection.selections,
+              variables,
+            );
+          }
+        }
+
+        continue;
+      case 'Scalar':
+        continue;
+    }
+  }
+}
+
+type DidUnretainSomeQuery = boolean;
+export function unretainQuery(
+  environment: IsographEnvironment,
+  retainedQuery: RetainedQuery,
+): DidUnretainSomeQuery {
+  environment.retainedQueries.delete(retainedQuery);
+  environment.gcBuffer.push(retainedQuery);
+
+  if (environment.gcBuffer.length > environment.gcBufferSize) {
+    environment.gcBuffer.shift();
+    return true;
+  }
+
+  return false;
+}
+
+export function retainQuery(
+  environment: IsographEnvironment,
+  queryToRetain: RetainedQuery,
+) {
+  environment.retainedQueries.add(queryToRetain);
+  // TODO can we remove this query from the buffer somehow?
+  // We are relying on === equality, but we really should be comparing
+  // id + variables
+}

package/src/cache.tsx

@@ -21,6 +21,10 @@ import {
   StoreRecord,
   Link,
   type IsographEnvironment,
+  garbageCollectEnvironment,
+  RetainedQuery,
+  unretainQuery,
+  retainQuery,
 } from './IsographEnvironment';
 
 declare global {
@@ -83,6 +87,18 @@ export function getOrCreateCacheForArtifact<T>(
   return getOrCreateCache<PromiseWrapper<T>>(environment, cacheKey, factory);
 }
 
+type NetworkRequestStatus =
+  | {
+      kind: 'UndisposedIncomplete';
+    }
+  | {
+      kind: 'Disposed';
+    }
+  | {
+      kind: 'UndisposedComplete';
+      retainedQuery: RetainedQuery;
+    };
+
 export function makeNetworkRequest<T>(
   environment: IsographEnvironment,
   artifact: IsoResolver,
@@ -91,20 +107,37 @@ export function makeNetworkRequest<T>(
   if (typeof window !== 'undefined' && window.__LOG) {
     console.log('make network request', artifact, variables);
   }
+  let status: NetworkRequestStatus = {
+    kind: 'UndisposedIncomplete',
+  };
+  // This should be an observable, not a promise
   const promise = environment
     .networkFunction(artifact.queryText, variables)
     .then((networkResponse) => {
       if (typeof window !== 'undefined' && window.__LOG) {
         console.log('network response', artifact, artifact);
       }
-      normalizeData(
-        environment,
-        artifact.normalizationAst,
-        networkResponse.data,
-        variables,
-        artifact.nestedRefetchQueries,
-      );
-      return networkResponse.data;
+
+      if (status.kind === 'UndisposedIncomplete') {
+        normalizeData(
+          environment,
+          artifact.normalizationAst,
+          networkResponse.data,
+          variables,
+          artifact.nestedRefetchQueries,
+        );
+        const retainedQuery = {
+          normalizationAst: artifact.normalizationAst,
+          variables,
+        };
+        status = {
+          kind: 'UndisposedComplete',
+          retainedQuery,
+        };
+        retainQuery(environment, retainedQuery);
+      }
+      // TODO return null
+      return networkResponse;
     });
 
   const wrapper = wrapPromise(promise);
@@ -112,7 +145,18 @@ export function makeNetworkRequest<T>(
   const response: ItemCleanupPair<PromiseWrapper<T>> = [
     wrapper,
     () => {
-      // delete from cache
+      if (status.kind === 'UndisposedComplete') {
+        const didUnretainSomeQuery = unretainQuery(
+          environment,
+          status.retainedQuery,
+        );
+        if (didUnretainSomeQuery) {
+          garbageCollectEnvironment(environment);
+        }
+      }
+      status = {
+        kind: 'Disposed',
+      };
     },
   ];
   return response;
@@ -138,7 +182,9 @@ function normalizeData(
   networkResponse: NetworkResponseObject,
   variables: Object,
   nestedRefetchQueries: RefetchQueryArtifactWrapper[],
-) {
+): Set<DataId> {
+  const encounteredIds = new Set<DataId>();
+
   if (typeof window !== 'undefined' && window.__LOG) {
     console.log(
       'about to normalize',
@@ -155,11 +201,13 @@ function normalizeData(
     ROOT_ID,
     variables as any,
     nestedRefetchQueries,
+    encounteredIds,
   );
   if (typeof window !== 'undefined' && window.__LOG) {
     console.log('after normalization', { store: environment.store });
   }
   callSubscriptions(environment);
+  return encounteredIds;
 }
 
 export function subscribe(
@@ -194,7 +242,9 @@ function normalizeDataIntoRecord(
   targetParentRecordId: DataId,
   variables: { [index: string]: string },
   nestedRefetchQueries: RefetchQueryArtifactWrapper[],
+  mutableEncounteredIds: Set<DataId>,
 ) {
+  mutableEncounteredIds.add(targetParentRecordId);
   for (const normalizationNode of normalizationAst) {
     switch (normalizationNode.kind) {
       case 'Scalar': {
@@ -215,6 +265,7 @@ function normalizeDataIntoRecord(
           targetParentRecordId,
           variables,
           nestedRefetchQueries,
+          mutableEncounteredIds,
         );
         break;
       }
@@ -253,6 +304,7 @@ function normalizeLinkedField(
   targetParentRecordId: DataId,
   variables: { [index: string]: string },
   nestedRefetchQueries: RefetchQueryArtifactWrapper[],
+  mutableEncounteredIds: Set<DataId>,
 ) {
   const networkResponseKey = getNetworkResponseKey(astNode);
   const networkResponseData = networkResponseParentRecord[networkResponseKey];
@@ -282,7 +334,9 @@ function normalizeLinkedField(
         variables,
         i,
         nestedRefetchQueries,
+        mutableEncounteredIds,
       );
+
       dataIds.push({ __link: newStoreRecordId });
     }
     targetParentRecord[parentRecordKey] = dataIds;
@@ -295,6 +349,7 @@ function normalizeLinkedField(
       variables,
       null,
       nestedRefetchQueries,
+      mutableEncounteredIds,
     );
     targetParentRecord[parentRecordKey] = {
       __link: newStoreRecordId,
@@ -310,6 +365,7 @@ function normalizeNetworkResponseObject(
   variables: { [index: string]: string },
   index: number | null,
   nestedRefetchQueries: RefetchQueryArtifactWrapper[],
+  mutableEncounteredIds: Set<DataId>,
 ): DataId /* The id of the modified or newly created item */ {
   const newStoreRecordId = getDataIdOfNetworkResponse(
     targetParentRecordId,
@@ -330,6 +386,7 @@ function normalizeNetworkResponseObject(
     newStoreRecordId,
     variables,
     nestedRefetchQueries,
+    mutableEncounteredIds,
   );
 
   return newStoreRecordId;

package/src/index.tsx

@@ -120,7 +120,6 @@ export type ReaderMutationField = {
 export type NormalizationAstNode =
   | NormalizationScalarField
   | NormalizationLinkedField;
-// @ts-ignore
 export type NormalizationAst = NormalizationAstNode[];
 
 export type NormalizationScalarField = {