@isograph/react 0.0.0-main-3a36e9fb → 0.0.0-main-beecd3bf

package/src/core/garbageCollection.ts

@@ -3,9 +3,10 @@ import {
   DataId,
   IsographEnvironment,
   IsographStore,
-  ROOT_ID,
   StoreRecord,
   assertLink,
+  type Link,
+  type TypeName,
 } from './IsographEnvironment';
 import { getParentRecordKey } from './cache';
 import { NormalizationAst } from './entrypoint';
@@ -13,6 +14,7 @@ import { NormalizationAst } from './entrypoint';
 export type RetainedQuery = {
   readonly normalizationAst: NormalizationAst;
   readonly variables: {};
+  readonly root: Link;
 };
 
 type DidUnretainSomeQuery = boolean;
@@ -42,7 +44,7 @@ export function retainQuery(
 }
 
 export function garbageCollectEnvironment(environment: IsographEnvironment) {
-  const retainedIds = new Set<DataId>([ROOT_ID]);
+  const retainedIds: RetainedIds = {};
 
   for (const query of environment.retainedQueries) {
     recordReachableIds(environment.store, query, retainedIds);
@@ -51,31 +53,61 @@ export function garbageCollectEnvironment(environment: IsographEnvironment) {
     recordReachableIds(environment.store, query, retainedIds);
   }
 
-  for (const dataId in environment.store) {
-    if (!retainedIds.has(dataId)) {
-      delete environment.store[dataId];
+  for (const typeName in environment.store) {
+    const dataById = environment.store[typeName];
+    if (dataById == null) continue;
+    const retainedTypeIds = retainedIds[typeName];
+
+    // delete all objects
+    if (retainedTypeIds == undefined || retainedTypeIds.size == 0) {
+      delete environment.store[typeName];
+      continue;
+    }
+
+    for (const dataId in dataById) {
+      if (!retainedTypeIds.has(dataId)) {
+        delete dataById[dataId];
+      }
+    }
+
+    if (Object.keys(dataById).length === 0) {
+      delete environment.store[typeName];
     }
   }
 }
 
+interface RetainedIds {
+  [typeName: TypeName]: Set<DataId>;
+}
+
 function recordReachableIds(
   store: IsographStore,
   retainedQuery: RetainedQuery,
-  mutableRetainedIds: Set<DataId>,
+  mutableRetainedIds: RetainedIds,
 ) {
-  recordReachableIdsFromRecord(
-    store,
-    store[ROOT_ID],
-    mutableRetainedIds,
-    retainedQuery.normalizationAst,
-    retainedQuery.variables,
-  );
+  const record =
+    store[retainedQuery.root.__typename]?.[retainedQuery.root.__link];
+
+  const retainedRecordsIds = (mutableRetainedIds[
+    retainedQuery.root.__typename
+  ] ??= new Set());
+  retainedRecordsIds.add(retainedQuery.root.__link);
+
+  if (record) {
+    recordReachableIdsFromRecord(
+      store,
+      record,
+      mutableRetainedIds,
+      retainedQuery.normalizationAst,
+      retainedQuery.variables,
+    );
+  }
 }
 
 function recordReachableIdsFromRecord(
   store: IsographStore,
   currentRecord: StoreRecord,
-  mutableRetainedIds: Set<DataId>,
+  mutableRetainedIds: RetainedIds,
   selections: NormalizationAst,
   variables: Variables | null,
 ) {
@@ -85,25 +117,44 @@ function recordReachableIdsFromRecord(
         const linkKey = getParentRecordKey(selection, variables ?? {});
         const linkedFieldOrFields = currentRecord[linkKey];
 
-        const ids = [];
+        const links: Link[] = [];
         if (Array.isArray(linkedFieldOrFields)) {
           for (const maybeLink of linkedFieldOrFields) {
             const link = assertLink(maybeLink);
             if (link != null) {
-              ids.push(link.__link);
+              links.push(link);
             }
           }
         } else {
           const link = assertLink(linkedFieldOrFields);
           if (link != null) {
-            ids.push(link.__link);
+            links.push(link);
           }
         }
 
-        for (const nextRecordId of ids) {
-          const nextRecord = store[nextRecordId];
+        let typeStore =
+          selection.concreteType !== null
+            ? store[selection.concreteType]
+            : null;
+
+        if (typeStore == null && selection.concreteType !== null) {
+          continue;
+        }
+
+        for (const nextRecordLink of links) {
+          let __typename = nextRecordLink.__typename;
+
+          const resolvedTypeStore = typeStore ?? store[__typename];
+
+          if (resolvedTypeStore == null) {
+            continue;
+          }
+
+          const nextRecord = resolvedTypeStore[nextRecordLink.__link];
           if (nextRecord != null) {
-            mutableRetainedIds.add(nextRecordId);
+            const retainedRecordsIds = (mutableRetainedIds[__typename] ??=
+              new Set());
+            retainedRecordsIds.add(nextRecordLink.__link);
             recordReachableIdsFromRecord(
               store,
               nextRecord,

package/src/core/logging.ts

@@ -11,7 +11,7 @@ import {
   RefetchQueryNormalizationArtifact,
 } from './entrypoint';
 import { FragmentReference, Variables } from './FragmentReference';
-import { NetworkResponseObject } from './cache';
+import { NetworkResponseObject, type EncounteredIds } from './cache';
 import { Arguments } from './util';
 import { ReadDataResult } from './read';
 import { CheckResult } from './check';
@@ -32,7 +32,7 @@ export type LogMessage =
   | {
       kind: 'AfterNormalization';
       store: IsographStore;
-      encounteredIds: Set<string>;
+      encounteredIds: EncounteredIds;
     }
   | {
       kind: 'DeepEqualityCheck';

package/src/core/makeNetworkRequest.ts

@@ -10,7 +10,7 @@ import {
   retainQuery,
   unretainQuery,
 } from './garbageCollection';
-import { IsographEnvironment } from './IsographEnvironment';
+import { IsographEnvironment, ROOT_ID } from './IsographEnvironment';
 import {
   AnyError,
   PromiseWrapper,
@@ -41,6 +41,10 @@ export function maybeMakeNetworkRequest(
         environment,
         artifact.networkRequestInfo.normalizationAst,
         variables,
+        {
+          __link: ROOT_ID,
+          __typename: artifact.concreteType,
+        },
       );
       if (result.kind === 'EnoughData') {
         return [wrapResolvedValue(undefined), () => {}];
@@ -88,6 +92,7 @@ export function makeNetworkRequest(
       }
 
       if (status.kind === 'UndisposedIncomplete') {
+        const root = { __link: ROOT_ID, __typename: artifact.concreteType };
         normalizeData(
           environment,
           artifact.networkRequestInfo.normalizationAst,
@@ -96,10 +101,12 @@ export function makeNetworkRequest(
           artifact.kind === 'Entrypoint'
             ? artifact.readerWithRefetchQueries.nestedRefetchQueries
             : [],
+          root,
         );
         const retainedQuery = {
           normalizationAst: artifact.networkRequestInfo.normalizationAst,
           variables,
+          root,
         };
         status = {
           kind: 'UndisposedComplete',

package/src/core/read.ts

@@ -1,4 +1,9 @@
-import { getParentRecordKey, onNextChangeToRecord } from './cache';
+import {
+  getParentRecordKey,
+  insertIfNotExists,
+  onNextChangeToRecord,
+  type EncounteredIds,
+} from './cache';
 import { getOrCreateCachedComponent } from './componentCache';
 import {
   IsographEntrypoint,
@@ -12,8 +17,6 @@ import {
 } from './FragmentReference';
 import {
   assertLink,
-  DataId,
-  defaultMissingFieldHandler,
   getOrLoadIsographArtifact,
   IsographEnvironment,
   type Link,
@@ -33,7 +36,7 @@ import { CleanupFn } from '@isograph/disposable-types';
 import { DEFAULT_SHOULD_FETCH_VALUE, FetchOptions } from './check';
 
 export type WithEncounteredRecords<T> = {
-  readonly encounteredRecords: Set<DataId>;
+  readonly encounteredRecords: EncounteredIds;
   readonly item: ExtractData<T>;
 };
 
@@ -44,7 +47,7 @@ export function readButDoNotEvaluate<
   fragmentReference: FragmentReference<TReadFromStore, unknown>,
   networkRequestOptions: NetworkRequestReaderOptions,
 ): WithEncounteredRecords<TReadFromStore> {
-  const mutableEncounteredRecords = new Set<DataId>();
+  const mutableEncounteredRecords: EncounteredIds = new Map();
 
   const readerWithRefetchQueries = readPromise(
     fragmentReference.readerWithRefetchQueries,
@@ -99,7 +102,7 @@ export type ReadDataResult<TReadFromStore> =
   | {
       readonly kind: 'Success';
       readonly data: ExtractData<TReadFromStore>;
-      readonly encounteredRecords: Set<DataId>;
+      readonly encounteredRecords: EncounteredIds;
     }
   | {
       readonly kind: 'MissingData';
@@ -116,10 +119,14 @@ function readData<TReadFromStore>(
   nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   networkRequest: PromiseWrapper<void, any>,
   networkRequestOptions: NetworkRequestReaderOptions,
-  mutableEncounteredRecords: Set<DataId>,
+  mutableEncounteredRecords: EncounteredIds,
 ): ReadDataResult<TReadFromStore> {
-  mutableEncounteredRecords.add(root.__link);
-  let storeRecord = environment.store[root.__link];
+  const encounteredIds = insertIfNotExists(
+    mutableEncounteredRecords,
+    root.__typename,
+  );
+  encounteredIds.add(root.__link);
+  let storeRecord = environment.store[root.__typename]?.[root.__link];
   if (storeRecord === undefined) {
     return {
       kind: 'MissingData',
@@ -179,6 +186,7 @@ function readData<TReadFromStore>(
               results.push(null);
               continue;
             }
+
             const result = readData(
               environment,
               field.selections,
@@ -248,10 +256,9 @@ function readData<TReadFromStore>(
 
         if (link === undefined) {
           // TODO make this configurable, and also generated and derived from the schema
-          const missingFieldHandler =
-            environment.missingFieldHandler ?? defaultMissingFieldHandler;
+          const missingFieldHandler = environment.missingFieldHandler;
 
-          const altLink = missingFieldHandler(
+          const altLink = missingFieldHandler?.(
             storeRecord,
             root,
             field.fieldName,
@@ -464,7 +471,9 @@ function readData<TReadFromStore>(
 
             return [
               // Stable id
-              root.__link +
+              root.__typename +
+                ':' +
+                root.__link +
                 '/' +
                 field.name +
                 '/' +
@@ -496,7 +505,7 @@ function readData<TReadFromStore>(
                     } as const),
 
                     // TODO localVariables is not guaranteed to have an id field
-                    root: { __link: localVariables.id },
+                    root,
                     variables: localVariables,
                     networkRequest,
                   };
@@ -569,7 +578,7 @@ function readData<TReadFromStore>(
                       ),
 
                       // TODO localVariables is not guaranteed to have an id field
-                      root: { __link: localVariables.id },
+                      root,
                       variables: localVariables,
                       networkRequest,
                     };
@@ -693,7 +702,7 @@ export function getNetworkRequestOptionsWithDefaults(
 // TODO call stableStringifyArgs on the variable values, as well.
 // This doesn't matter for now, since we are just using primitive values
 // in the demo.
-function stableStringifyArgs(args: Object) {
+function stableStringifyArgs(args: object) {
   const keys = Object.keys(args);
   keys.sort();
   let s = '';

package/src/index.ts

@@ -24,7 +24,6 @@ export {
   type StoreRecord,
   createIsographEnvironment,
   createIsographStore,
-  defaultMissingFieldHandler,
 } from './core/IsographEnvironment';
 export {
   type EagerReaderArtifact,

package/src/react/useImperativeReference.ts

@@ -57,7 +57,7 @@ export function useImperativeReference<
             nestedRefetchQueries:
               entrypoint.readerWithRefetchQueries.nestedRefetchQueries,
           }),
-          root: { __link: ROOT_ID },
+          root: { __link: ROOT_ID, __typename: entrypoint.concreteType },
           variables,
           networkRequest,
         },

package/src/tests/__isograph/Query/meName/entrypoint.ts

@@ -41,6 +41,7 @@ const artifact: IsographEntrypoint<
     queryText,
     normalizationAst,
   },
+  concreteType: "Query",
   readerWithRefetchQueries: {
     kind: "ReaderWithRefetchQueries",
     nestedRefetchQueries,

package/src/tests/__isograph/Query/meNameSuccessor/entrypoint.ts

@@ -79,6 +79,7 @@ const artifact: IsographEntrypoint<
     queryText,
     normalizationAst,
   },
+  concreteType: "Query",
   readerWithRefetchQueries: {
     kind: "ReaderWithRefetchQueries",
     nestedRefetchQueries,

package/src/tests/__isograph/Query/nodeField/entrypoint.ts

@@ -46,6 +46,7 @@ const artifact: IsographEntrypoint<
     queryText,
     normalizationAst,
   },
+  concreteType: "Query",
   readerWithRefetchQueries: {
     kind: "ReaderWithRefetchQueries",
     nestedRefetchQueries,

package/src/tests/__isograph/Query/subquery/entrypoint.ts

@@ -0,0 +1,67 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
+import {Query__subquery__param} from './param_type';
+import {Query__subquery__output_type} from './output_type';
+import readerResolver from './resolver_reader';
+const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
+
+const queryText = 'query subquery ($id: ID!) {\
+  query {\
+    node____id___v_id: node(id: $id) {\
+      __typename,\
+      id,\
+    },\
+  },\
+}';
+
+const normalizationAst: NormalizationAst = [
+  {
+    kind: "Linked",
+    fieldName: "query",
+    arguments: null,
+    concreteType: "Query",
+    selections: [
+      {
+        kind: "Linked",
+        fieldName: "node",
+        arguments: [
+          [
+            "id",
+            { kind: "Variable", name: "id" },
+          ],
+        ],
+        concreteType: null,
+        selections: [
+          {
+            kind: "Scalar",
+            fieldName: "__typename",
+            arguments: null,
+          },
+          {
+            kind: "Scalar",
+            fieldName: "id",
+            arguments: null,
+          },
+        ],
+      },
+    ],
+  },
+];
+const artifact: IsographEntrypoint<
+  Query__subquery__param,
+  Query__subquery__output_type
+> = {
+  kind: "Entrypoint",
+  networkRequestInfo: {
+    kind: "NetworkRequestInfo",
+    queryText,
+    normalizationAst,
+  },
+  concreteType: "Query",
+  readerWithRefetchQueries: {
+    kind: "ReaderWithRefetchQueries",
+    nestedRefetchQueries,
+    readerArtifact: readerResolver,
+  },
+};
+
+export default artifact;

package/src/tests/__isograph/Query/subquery/output_type.ts

@@ -0,0 +1,3 @@
+import type React from 'react';
+import { subquery as resolver } from '../../../normalizeData.test';
+export type Query__subquery__output_type = ReturnType<typeof resolver>;

package/src/tests/__isograph/Query/subquery/param_type.ts

@@ -0,0 +1,12 @@
+import type { Query__subquery__parameters } from './parameters_type';
+
+export type Query__subquery__param = {
+  readonly data: {
+    readonly query: {
+      readonly node: ({
+        readonly id: string,
+      } | null),
+    },
+  },
+  readonly parameters: Query__subquery__parameters,
+};

package/src/tests/__isograph/Query/subquery/parameters_type.ts

@@ -0,0 +1,3 @@
+export type Query__subquery__parameters = {
+  readonly id: string,
+};

package/src/tests/__isograph/Query/subquery/resolver_reader.ts

@@ -0,0 +1,47 @@
+import type { EagerReaderArtifact, ReaderAst } from '@isograph/react';
+import { Query__subquery__param } from './param_type';
+import { Query__subquery__output_type } from './output_type';
+import { subquery as resolver } from '../../../normalizeData.test';
+
+const readerAst: ReaderAst<Query__subquery__param> = [
+  {
+    kind: "Linked",
+    fieldName: "query",
+    alias: null,
+    arguments: null,
+    condition: null,
+    selections: [
+      {
+        kind: "Linked",
+        fieldName: "node",
+        alias: null,
+        arguments: [
+          [
+            "id",
+            { kind: "Variable", name: "id" },
+          ],
+        ],
+        condition: null,
+        selections: [
+          {
+            kind: "Scalar",
+            fieldName: "id",
+            alias: null,
+            arguments: null,
+          },
+        ],
+      },
+    ],
+  },
+];
+
+const artifact: EagerReaderArtifact<
+  Query__subquery__param,
+  Query__subquery__output_type
+> = {
+  kind: "EagerReaderArtifact",
+  resolver,
+  readerAst,
+};
+
+export default artifact;

package/src/tests/__isograph/iso.ts

@@ -2,9 +2,11 @@ import type { IsographEntrypoint } from '@isograph/react';
 import { type Query__meNameSuccessor__param } from './Query/meNameSuccessor/param_type';
 import { type Query__meName__param } from './Query/meName/param_type';
 import { type Query__nodeField__param } from './Query/nodeField/param_type';
+import { type Query__subquery__param } from './Query/subquery/param_type';
 import entrypoint_Query__meNameSuccessor from '../__isograph/Query/meNameSuccessor/entrypoint';
 import entrypoint_Query__meName from '../__isograph/Query/meName/entrypoint';
 import entrypoint_Query__nodeField from '../__isograph/Query/nodeField/entrypoint';
+import entrypoint_Query__subquery from '../__isograph/Query/subquery/entrypoint';
 
 // This is the type given to regular client fields.
 // This means that the type of the exported iso literal is exactly
@@ -66,6 +68,10 @@ export function iso<T>(
   param: T & MatchesWhitespaceAndString<'field Query.nodeField', T>
 ): IdentityWithParam<Query__nodeField__param>;
 
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'field Query.subquery', T>
+): IdentityWithParam<Query__subquery__param>;
+
 export function iso<T>(
   param: T & MatchesWhitespaceAndString<'entrypoint Query.meNameSuccessor', T>
 ): typeof entrypoint_Query__meNameSuccessor;
@@ -78,6 +84,10 @@ export function iso<T>(
   param: T & MatchesWhitespaceAndString<'entrypoint Query.nodeField', T>
 ): typeof entrypoint_Query__nodeField;
 
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'entrypoint Query.subquery', T>
+): typeof entrypoint_Query__subquery;
+
 export function iso(_isographLiteralText: string):
   | IdentityWithParam<any>
   | IdentityWithParamComponent<any>