@isograph/react 0.2.0 → 0.3.0

package/src/core/check.ts

@@ -0,0 +1,207 @@
+import { getParentRecordKey } from './cache';
+import { NormalizationAst } from './entrypoint';
+import { Variables } from './FragmentReference';
+import {
+  getLink,
+  IsographEnvironment,
+  Link,
+  StoreRecord,
+} from './IsographEnvironment';
+import { logMessage } from './logging';
+
+export type ShouldFetch = 'Yes' | 'No' | 'IfNecessary';
+
+export const DEFAULT_SHOULD_FETCH_VALUE: ShouldFetch = 'IfNecessary';
+
+export type FetchOptions = {
+  shouldFetch?: ShouldFetch;
+  onComplete?: () => void;
+  onError?: () => void;
+};
+
+export type CheckResult =
+  | {
+      kind: 'EnoughData';
+    }
+  | {
+      kind: 'MissingData';
+      record: Link;
+    };
+
+export function check(
+  environment: IsographEnvironment,
+  normalizationAst: NormalizationAst,
+  variables: Variables,
+  root: Link,
+): CheckResult {
+  const recordsById = (environment.store[root.__typename] ??= {});
+  const newStoreRecord = (recordsById[root.__link] ??= {});
+
+  const checkResult = checkFromRecord(
+    environment,
+    normalizationAst,
+    variables,
+    newStoreRecord,
+    root,
+  );
+  logMessage(environment, {
+    kind: 'EnvironmentCheck',
+    result: checkResult,
+  });
+  return checkResult;
+}
+
+function checkFromRecord(
+  environment: IsographEnvironment,
+  normalizationAst: NormalizationAst,
+  variables: Variables,
+  record: StoreRecord,
+  recordLink: Link,
+): CheckResult {
+  normalizationAstLoop: for (const normalizationAstNode of normalizationAst) {
+    switch (normalizationAstNode.kind) {
+      case 'Scalar': {
+        const parentRecordKey = getParentRecordKey(
+          normalizationAstNode,
+          variables,
+        );
+        const scalarValue = record[parentRecordKey];
+
+        // null means the value is known to be missing, so it must
+        // be exactly undefined
+        if (scalarValue === undefined) {
+          return {
+            kind: 'MissingData',
+            record: recordLink,
+          };
+        }
+        continue normalizationAstLoop;
+      }
+      case 'Linked': {
+        const parentRecordKey = getParentRecordKey(
+          normalizationAstNode,
+          variables,
+        );
+
+        const linkedValue = record[parentRecordKey];
+
+        if (linkedValue === undefined) {
+          return {
+            kind: 'MissingData',
+            record: recordLink,
+          };
+        } else if (linkedValue === null) {
+          continue;
+        } else if (Array.isArray(linkedValue)) {
+          arrayItemsLoop: for (const item of linkedValue) {
+            const link = getLink(item);
+            if (link === null) {
+              throw new Error(
+                'Unexpected non-link in the Isograph store. ' +
+                  'This is indicative of a bug in Isograph.',
+              );
+            }
+
+            const linkedRecord =
+              environment.store[link.__typename]?.[link.__link];
+
+            if (linkedRecord === undefined) {
+              return {
+                kind: 'MissingData',
+                record: link,
+              };
+            } else if (linkedRecord === null) {
+              continue arrayItemsLoop;
+            } else {
+              // TODO in __DEV__ assert linkedRecord is an object
+              const result = checkFromRecord(
+                environment,
+                normalizationAstNode.selections,
+                variables,
+                linkedRecord,
+                link,
+              );
+
+              if (result.kind === 'MissingData') {
+                return result;
+              }
+            }
+          }
+        } else {
+          const link = getLink(linkedValue);
+          if (link === null) {
+            throw new Error(
+              'Unexpected non-link in the Isograph store. ' +
+                'This is indicative of a bug in Isograph.',
+            );
+          }
+
+          const linkedRecord =
+            environment.store[link.__typename]?.[link.__link];
+
+          if (linkedRecord === undefined) {
+            return {
+              kind: 'MissingData',
+              record: link,
+            };
+          } else if (linkedRecord === null) {
+            continue normalizationAstLoop;
+          } else {
+            // TODO in __DEV__ assert linkedRecord is an object
+            const result = checkFromRecord(
+              environment,
+              normalizationAstNode.selections,
+              variables,
+              linkedRecord,
+              link,
+            );
+
+            if (result.kind === 'MissingData') {
+              return result;
+            }
+          }
+        }
+
+        continue normalizationAstLoop;
+      }
+      case 'InlineFragment': {
+        const existingRecordTypename = record['__typename'];
+
+        if (
+          existingRecordTypename == null ||
+          existingRecordTypename !== normalizationAstNode.type
+        ) {
+          return {
+            kind: 'MissingData',
+            record: recordLink,
+          };
+        }
+
+        const result = checkFromRecord(
+          environment,
+          normalizationAstNode.selections,
+          variables,
+          record,
+          recordLink,
+        );
+
+        if (result.kind === 'MissingData') {
+          return result;
+        }
+
+        continue normalizationAstLoop;
+      }
+      default: {
+        let _: never = normalizationAstNode;
+        _;
+        throw new Error(
+          'Unexpected case. This is indicative of a bug in Isograph.',
+        );
+      }
+    }
+  }
+
+  return {
+    kind: 'EnoughData',
+  };
+}

package/src/core/componentCache.ts

@@ -4,6 +4,7 @@ import { FragmentReference } from './FragmentReference';
 import { useReadAndSubscribe } from '../react/useReadAndSubscribe';
 import { NetworkRequestReaderOptions } from './read';
 import { readPromise } from './PromiseWrapper';
+import { logMessage } from './logging';
 
 export function getOrCreateCachedComponent(
   environment: IsographEnvironment,
@@ -16,9 +17,9 @@ export function getOrCreateCachedComponent(
   // time.
   const cachedComponentsById = environment.componentCache;
 
-  cachedComponentsById[fragmentReference.root] =
-    cachedComponentsById[fragmentReference.root] ?? {};
-  const componentsByName = cachedComponentsById[fragmentReference.root];
+  const recordLink = fragmentReference.root.__link;
+
+  const componentsByName = (cachedComponentsById[recordLink] ??= {});
 
   componentsByName[componentName] = componentsByName[componentName] ?? {};
   const byArgs = componentsByName[componentName];
@@ -30,27 +31,27 @@ export function getOrCreateCachedComponent(
     byArgs[stringifiedArgs] ??
     (() => {
       function Component(additionalRuntimeProps: { [key: string]: any }) {
+        const readerWithRefetchQueries = readPromise(
+          fragmentReference.readerWithRefetchQueries,
+        );
+
         const data = useReadAndSubscribe(
           fragmentReference,
           networkRequestOptions,
+          readerWithRefetchQueries.readerArtifact.readerAst,
         );
 
-        // @ts-expect-error
-        if (typeof window !== 'undefined' && window.__LOG) {
-          console.log(
-            'Component re-rendered: ' +
-              componentName +
-              ' ' +
-              fragmentReference.root,
-          );
-        }
-
-        const readerWithRefetchQueries = readPromise(
-          fragmentReference.readerWithRefetchQueries,
-        );
+        logMessage(environment, {
+          kind: 'ComponentRerendered',
+          componentName,
+          rootLink: fragmentReference.root,
+        });
 
         return readerWithRefetchQueries.readerArtifact.resolver(
-          data,
+          {
+            data,
+            parameters: fragmentReference.variables,
+          },
           additionalRuntimeProps,
         );
       }

package/src/core/entrypoint.ts

@@ -1,8 +1,9 @@
+import type { TypeName } from './IsographEnvironment';
 import { TopLevelReaderArtifact } from './reader';
 import { Arguments } from './util';
 
 export type ReaderWithRefetchQueries<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 > = {
   readonly kind: 'ReaderWithRefetchQueries';
@@ -15,22 +16,27 @@ export type ReaderWithRefetchQueries<
   readonly nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[];
 };
 
+export type NetworkRequestInfo = {
+  readonly kind: 'NetworkRequestInfo';
+  readonly queryText: string;
+  readonly normalizationAst: NormalizationAst;
+};
 // This type should be treated as an opaque type.
 export type IsographEntrypoint<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 > = {
   readonly kind: 'Entrypoint';
-  readonly queryText: string;
-  readonly normalizationAst: NormalizationAst;
+  readonly networkRequestInfo: NetworkRequestInfo;
   readonly readerWithRefetchQueries: ReaderWithRefetchQueries<
     TReadFromStore,
     TClientFieldValue
   >;
+  readonly concreteType: TypeName;
 };
 
 export type IsographEntrypointLoader<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 > = {
   readonly kind: 'EntrypointLoader';
@@ -57,6 +63,7 @@ export type NormalizationLinkedField = {
   readonly fieldName: string;
   readonly arguments: Arguments | null;
   readonly selections: NormalizationAst;
+  readonly concreteType: TypeName | null;
 };
 
 export type NormalizationInlineFragment = {
@@ -68,8 +75,8 @@ export type NormalizationInlineFragment = {
 // This is more like an entrypoint, but one specifically for a refetch query/mutation
 export type RefetchQueryNormalizationArtifact = {
   readonly kind: 'RefetchQuery';
-  readonly queryText: string;
-  readonly normalizationAst: NormalizationAst;
+  readonly networkRequestInfo: NetworkRequestInfo;
+  readonly concreteType: TypeName;
 };
 
 // TODO rename
@@ -79,7 +86,7 @@ export type RefetchQueryNormalizationArtifactWrapper = {
 };
 
 export function assertIsEntrypoint<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 >(
   value:

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

@@ -0,0 +1,116 @@
+import { CleanupFn } from '@isograph/disposable-types';
+import {
+  IsographEnvironment,
+  IsographStore,
+  StoreRecord,
+  type Link,
+} from './IsographEnvironment';
+import {
+  IsographEntrypoint,
+  NormalizationAst,
+  RefetchQueryNormalizationArtifact,
+} from './entrypoint';
+import { FragmentReference, Variables } from './FragmentReference';
+import { NetworkResponseObject, type EncounteredIds } from './cache';
+import { Arguments } from './util';
+import { ReadDataResult } from './read';
+import { CheckResult } from './check';
+
+export type LogMessage =
+  | {
+      kind: 'GettingSuspenseCacheItem';
+      index: string;
+      availableCacheItems: ReadonlyArray<string>;
+      found: boolean;
+    }
+  | {
+      kind: 'AboutToNormalize';
+      normalizationAst: NormalizationAst;
+      networkResponse: NetworkResponseObject;
+      variables: Variables;
+    }
+  | {
+      kind: 'AfterNormalization';
+      store: IsographStore;
+      encounteredIds: EncounteredIds;
+    }
+  | {
+      kind: 'DeepEqualityCheck';
+      fragmentReference: FragmentReference<any, any>;
+      old: object;
+      new: object;
+      deeplyEqual: boolean;
+    }
+  | {
+      kind: 'ComponentRerendered';
+      componentName: string;
+      rootLink: Link;
+    }
+  | {
+      kind: 'MakeNetworkRequest';
+      artifact:
+        | RefetchQueryNormalizationArtifact
+        | IsographEntrypoint<any, any>;
+      variables: Variables;
+      networkRequestId: string;
+    }
+  | {
+      kind: 'ReceivedNetworkResponse';
+      // TODO should be object
+      networkResponse: any;
+      networkRequestId: string;
+    }
+  | {
+      kind: 'ReceivedNetworkError';
+      error: any;
+      networkRequestId: string;
+    }
+  | {
+      kind: 'MissingFieldHandlerCalled';
+      root: Link;
+      storeRecord: StoreRecord;
+      fieldName: string;
+      arguments: Arguments | null;
+      variables: Variables;
+    }
+  | {
+      kind: 'DoneReading';
+      response: ReadDataResult<any>;
+    }
+  | {
+      kind: 'NonEntrypointReceived';
+      entrypoint: any;
+    }
+  | {
+      kind: 'EnvironmentCheck';
+      result: CheckResult;
+    };
+
+export type LogFunction = (logMessage: LogMessage) => void;
+
+// wrapped so that items in the loggers set are unique.
+export type WrappedLogFunction = {
+  log: LogFunction;
+};
+
+export function logMessage(
+  environment: IsographEnvironment,
+  message: LogMessage,
+) {
+  for (const logger of environment.loggers) {
+    try {
+      logger.log(message);
+    } catch {}
+  }
+}
+
+export function registerLogger(
+  environment: IsographEnvironment,
+  log: LogFunction,
+): CleanupFn {
+  const wrapped = { log };
+  environment.loggers.add(wrapped);
+  return () => {
+    environment.loggers.delete(wrapped);
+  };
+}