@isograph/react 0.4.2 → 0.5.0

package/src/core/entrypoint.ts

@@ -1,5 +1,7 @@
+import type { Contravariant, PhantomData } from './brand';
+import type { NetworkResponseObject } from './cache';
 import type { UnknownTReadFromStore } from './FragmentReference';
-import type { TypeName } from './IsographEnvironment';
+import type { ComponentOrFieldName, TypeName } from './IsographEnvironment';
 import { TopLevelReaderArtifact } from './reader';
 import { Arguments } from './util';
 
@@ -22,6 +24,10 @@ export type ReaderWithRefetchQueriesLoader<
   TClientFieldValue,
 > = {
   readonly kind: 'ReaderWithRefetchQueriesLoader';
+  readonly fieldName: ComponentOrFieldName;
+  readonly readerArtifactKind:
+    | 'EagerReaderArtifact'
+    | 'ComponentReaderArtifact';
   readonly loader: () => Promise<
     ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
   >;
@@ -55,6 +61,7 @@ export type IsographEntrypoint<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 > = {
   readonly kind: 'Entrypoint';
   readonly networkRequestInfo: NetworkRequestInfo<TNormalizationAst>;
@@ -62,16 +69,29 @@ export type IsographEntrypoint<
     | ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
     | ReaderWithRefetchQueriesLoader<TReadFromStore, TClientFieldValue>;
   readonly concreteType: TypeName;
+  /**
+   * This field exists solely for typechecking, and will not exist at runtime.
+   */
+  readonly '~TRawResponseType'?: PhantomData<Contravariant<TRawResponseType>>;
 };
 
 export type IsographEntrypointLoader<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
+  TRawResponseType extends NetworkResponseObject,
 > = {
   readonly kind: 'EntrypointLoader';
   readonly typeAndField: string;
+  readonly readerArtifactKind:
+    | 'EagerReaderArtifact'
+    | 'ComponentReaderArtifact';
   readonly loader: () => Promise<
-    IsographEntrypoint<TReadFromStore, TClientFieldValue, NormalizationAst>
+    IsographEntrypoint<
+      TReadFromStore,
+      TClientFieldValue,
+      NormalizationAst,
+      TRawResponseType
+    >
   >;
 };
 
@@ -129,9 +149,15 @@ export function assertIsEntrypoint<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 >(
   value:
-    | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>
+    | IsographEntrypoint<
+        TReadFromStore,
+        TClientFieldValue,
+        TNormalizationAst,
+        TRawResponseType
+      >
     | ((_: any) => any)
     // Temporarily, allow any here. Once we automatically provide
     // types to entrypoints, we probably don't need this.
@@ -139,13 +165,16 @@ export function assertIsEntrypoint<
 ): asserts value is IsographEntrypoint<
   TReadFromStore,
   TClientFieldValue,
-  TNormalizationAst
+  TNormalizationAst,
+  TRawResponseType
 > {
   if (typeof value === 'function') throw new Error('Not a string');
 }
 
 export type ExtractReadFromStore<Type> =
-  Type extends IsographEntrypoint<infer X, any, any> ? X : never;
+  Type extends IsographEntrypoint<infer X, any, any, any> ? X : never;
+export type ExtractRawResponseType<Type> =
+  Type extends IsographEntrypoint<any, any, any, infer X> ? X : never;
 export type ExtractResolverResult<Type> =
-  Type extends IsographEntrypoint<any, infer X, any> ? X : never;
+  Type extends IsographEntrypoint<any, infer X, any, any> ? X : never;
 export type ExtractProps<Type> = Type extends React.FC<infer X> ? X : never;

package/src/core/garbageCollection.ts

@@ -1,22 +1,41 @@
 import { getParentRecordKey } from './cache';
-import { NormalizationAstNodes } from './entrypoint';
+import { NormalizationAstNodes, type NormalizationAst } from './entrypoint';
 import { Variables } from './FragmentReference';
 import {
   assertLink,
   DataId,
   IsographEnvironment,
-  IsographStore,
   StoreRecord,
+  type StoreLayerData,
   type StoreLink,
   type TypeName,
 } from './IsographEnvironment';
+import type { BaseStoreLayer } from './optimisticProxy';
+import {
+  NOT_SET,
+  type PromiseWrapper,
+  type PromiseWrapperOk,
+} from './PromiseWrapper';
 
 export type RetainedQuery = {
-  readonly normalizationAst: NormalizationAstNodes;
+  readonly normalizationAst: PromiseWrapper<NormalizationAst>;
   readonly variables: {};
   readonly root: StoreLink;
 };
 
+export interface RetainedQueryWithNormalizationAst extends RetainedQuery {
+  readonly normalizationAst: PromiseWrapperOk<NormalizationAst>;
+}
+
+function isRetainedQueryWithNormalizationAst(
+  query: RetainedQuery,
+): query is RetainedQueryWithNormalizationAst {
+  return (
+    query.normalizationAst.result !== NOT_SET &&
+    query.normalizationAst.result.kind === 'Ok'
+  );
+}
+
 export type DidUnretainSomeQuery = boolean;
 export function unretainQuery(
   environment: IsographEnvironment,
@@ -44,23 +63,46 @@ export function retainQuery(
 }
 
 export function garbageCollectEnvironment(environment: IsographEnvironment) {
-  const retainedIds: RetainedIds = {};
+  if (environment.store.kind !== 'BaseStoreLayer') {
+    return;
+  }
 
+  const retainedQueries: RetainedQueryWithNormalizationAst[] = [];
   for (const query of environment.retainedQueries) {
-    recordReachableIds(environment.store, query, retainedIds);
+    if (!isRetainedQueryWithNormalizationAst(query)) {
+      return;
+    }
+    retainedQueries.push(query);
   }
+
   for (const query of environment.gcBuffer) {
-    recordReachableIds(environment.store, query, retainedIds);
+    if (!isRetainedQueryWithNormalizationAst(query)) {
+      return;
+    }
+    retainedQueries.push(query);
   }
 
-  for (const typeName in environment.store) {
-    const dataById = environment.store[typeName];
+  garbageCollectBaseStoreLayer(retainedQueries, environment.store);
+}
+
+export function garbageCollectBaseStoreLayer(
+  retainedQueries: RetainedQueryWithNormalizationAst[],
+  baseStoreLayer: BaseStoreLayer,
+) {
+  const retainedIds: RetainedIds = {};
+
+  for (const query of retainedQueries) {
+    recordReachableIds(baseStoreLayer.data, query, retainedIds);
+  }
+
+  for (const typeName in baseStoreLayer.data) {
+    const dataById = baseStoreLayer.data[typeName];
     if (dataById == null) continue;
     const retainedTypeIds = retainedIds[typeName];
 
     // delete all objects
     if (retainedTypeIds == undefined || retainedTypeIds.size == 0) {
-      delete environment.store[typeName];
+      delete baseStoreLayer.data[typeName];
       continue;
     }
 
@@ -71,7 +113,7 @@ export function garbageCollectEnvironment(environment: IsographEnvironment) {
     }
 
     if (Object.keys(dataById).length === 0) {
-      delete environment.store[typeName];
+      delete baseStoreLayer.data[typeName];
     }
   }
 }
@@ -81,12 +123,12 @@ interface RetainedIds {
 }
 
 function recordReachableIds(
-  store: IsographStore,
-  retainedQuery: RetainedQuery,
+  dataLayer: StoreLayerData,
+  retainedQuery: RetainedQueryWithNormalizationAst,
   mutableRetainedIds: RetainedIds,
 ) {
   const record =
-    store[retainedQuery.root.__typename]?.[retainedQuery.root.__link];
+    dataLayer[retainedQuery.root.__typename]?.[retainedQuery.root.__link];
 
   const retainedRecordsIds = (mutableRetainedIds[
     retainedQuery.root.__typename
@@ -95,17 +137,17 @@ function recordReachableIds(
 
   if (record) {
     recordReachableIdsFromRecord(
-      store,
+      dataLayer,
       record,
       mutableRetainedIds,
-      retainedQuery.normalizationAst,
+      retainedQuery.normalizationAst.result.value.selections,
       retainedQuery.variables,
     );
   }
 }
 
 function recordReachableIdsFromRecord(
-  store: IsographStore,
+  dataLayer: StoreLayerData,
   currentRecord: StoreRecord,
   mutableRetainedIds: RetainedIds,
   selections: NormalizationAstNodes,
@@ -134,7 +176,7 @@ function recordReachableIdsFromRecord(
 
         let typeStore =
           selection.concreteType !== null
-            ? store[selection.concreteType]
+            ? dataLayer[selection.concreteType]
             : null;
 
         if (typeStore == null && selection.concreteType !== null) {
@@ -144,7 +186,7 @@ function recordReachableIdsFromRecord(
         for (const nextRecordLink of links) {
           let __typename = nextRecordLink.__typename;
 
-          const resolvedTypeStore = typeStore ?? store[__typename];
+          const resolvedTypeStore = typeStore ?? dataLayer[__typename];
 
           if (resolvedTypeStore == null) {
             continue;
@@ -156,7 +198,7 @@ function recordReachableIdsFromRecord(
               new Set());
             retainedRecordsIds.add(nextRecordLink.__link);
             recordReachableIdsFromRecord(
-              store,
+              dataLayer,
               nextRecord,
               mutableRetainedIds,
               selection.selections,

package/src/core/logging.ts

@@ -9,13 +9,25 @@ import {
 import { FragmentReference, Variables } from './FragmentReference';
 import {
   IsographEnvironment,
-  IsographStore,
   StoreRecord,
   type StoreLink,
 } from './IsographEnvironment';
 import { ReadDataResult } from './read';
 import { Arguments } from './util';
+import type { StoreLayer } from './optimisticProxy';
 
+/**
+ * Note: these types are unstable. We will add and remove items from this enum
+ * and add and remove fields. Please do not rely on the specifics here (for now).
+ *
+ * Goals include:
+ * - convenient debugging for Isograph developers
+ * - eventual support for the Isograph devtools
+ *
+ * In some cases (e.g. in `AfterNormalization`), we include large objects and thus
+ * prevent them from getting garbage collected (if the log message is printed).
+ * Especially in cases like that, we intend to remove those!
+ */
 export type LogMessage =
   | {
       kind: 'AboutToNormalize';
@@ -25,7 +37,7 @@ export type LogMessage =
     }
   | {
       kind: 'AfterNormalization';
-      store: IsographStore;
+      store: StoreLayer;
       encounteredIds: EncounteredIds;
     }
   | {
@@ -44,7 +56,7 @@ export type LogMessage =
       kind: 'MakeNetworkRequest';
       artifact:
         | RefetchQueryNormalizationArtifact
-        | IsographEntrypoint<any, any, any>;
+        | IsographEntrypoint<any, any, any, any>;
       variables: Variables;
       networkRequestId: string;
     }