@isograph/react 0.0.0-main-dc9ca2f6 → 0.0.0-main-905800be

package/dist/reader.js

@@ -0,0 +1,3 @@
+"use strict";
+// TODO this should probably be at least three distinct types, for @component,
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-dc9ca2f6",
+  "version": "0.0.0-main-905800be",
   "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-dc9ca2f6",
-    "@isograph/react-disposable-state": "0.0.0-main-dc9ca2f6",
+    "@isograph/disposable-types": "0.0.0-main-905800be",
+    "@isograph/react-disposable-state": "0.0.0-main-905800be",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/IsographEnvironment.tsx

@@ -1,11 +1,5 @@
-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);
+import { RetainedQuery } from './garbageCollection';
 
 type ComponentName = string;
 type StringifiedArgs = string;
@@ -18,11 +12,6 @@ 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;
@@ -51,6 +40,7 @@ export type IsographNetworkFunction = (
 export type Link = {
   __link: DataId;
 };
+
 export type DataTypeValue =
   // N.B. undefined is here to support optional id's, but
   // undefined should not *actually* be present in the store.
@@ -81,33 +71,6 @@ export type IsographStore = {
   __ROOT: StoreRecord;
 };
 
-export type IsographEnvironmentProviderProps = {
-  environment: IsographEnvironment;
-  children: ReactNode;
-};
-
-export function IsographEnvironmentProvider({
-  environment,
-  children,
-}: IsographEnvironmentProviderProps) {
-  return (
-    <IsographEnvironmentContext.Provider value={environment}>
-      {children}
-    </IsographEnvironmentContext.Provider>
-  );
-}
-
-export function useIsographEnvironment(): IsographEnvironment {
-  const context = useContext(IsographEnvironmentContext);
-  if (context == null) {
-    throw new Error(
-      'Unexpected null environment context. Make sure to render ' +
-        'this component within an IsographEnvironmentProvider component',
-    );
-  }
-  return context;
-}
-
 const DEFAULT_GC_BUFFER_SIZE = 10;
 export function createIsographEnvironment(
   store: IsographStore,
@@ -133,118 +96,20 @@ export function createIsographStore() {
   };
 }
 
-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;
+export function defaultMissingFieldHandler(
+  _storeRecord: StoreRecord,
+  _root: DataId,
+  fieldName: string,
+  arguments_: { [index: string]: any } | null,
+  variables: { [index: string]: any } | null,
+): Link | undefined {
+  if (fieldName === 'node' || fieldName === 'user') {
+    const variable = arguments_?.['id'];
+    const value = variables?.[variable];
+
+    // TODO can we handle explicit nulls here too? Probably, after wrapping in objects
+    if (value != null) {
+      return { __link: value };
     }
   }
 }
-
-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/IsographEnvironmentProvider.tsx

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import { ReactNode, createContext, useContext } from 'react';
+import { type IsographEnvironment } from './IsographEnvironment';
+
+export const IsographEnvironmentContext =
+  createContext<IsographEnvironment | null>(null);
+
+export type IsographEnvironmentProviderProps = {
+  environment: IsographEnvironment;
+  children: ReactNode;
+};
+
+export function IsographEnvironmentProvider({
+  environment,
+  children,
+}: IsographEnvironmentProviderProps) {
+  return (
+    <IsographEnvironmentContext.Provider value={environment}>
+      {children}
+    </IsographEnvironmentContext.Provider>
+  );
+}
+
+export function useIsographEnvironment(): IsographEnvironment {
+  const context = useContext(IsographEnvironmentContext);
+  if (context == null) {
+    throw new Error(
+      'Unexpected null environment context. Make sure to render ' +
+        'this component within an IsographEnvironmentProvider component',
+    );
+  }
+  return context;
+}

package/src/cache.tsx

@@ -21,11 +21,13 @@ import {
   StoreRecord,
   Link,
   type IsographEnvironment,
-  garbageCollectEnvironment,
+} from './IsographEnvironment';
+import {
   RetainedQuery,
-  unretainQuery,
+  garbageCollectEnvironment,
   retainQuery,
-} from './IsographEnvironment';
+  unretainQuery,
+} from './garbageCollection';
 
 declare global {
   interface Window {

package/src/entrypoint.ts

@@ -0,0 +1,59 @@
+import { Arguments } from './index';
+import { ReaderArtifact } from './reader';
+
+// This type should be treated as an opaque type.
+export type IsographEntrypoint<
+  TReadFromStore extends Object,
+  TResolverResult,
+> = {
+  kind: 'Entrypoint';
+  queryText: string;
+  normalizationAst: NormalizationAst;
+  readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
+  nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+};
+
+export type NormalizationAstNode =
+  | NormalizationScalarField
+  | NormalizationLinkedField;
+export type NormalizationAst = NormalizationAstNode[];
+
+export type NormalizationScalarField = {
+  kind: 'Scalar';
+  fieldName: string;
+  arguments: Arguments | null;
+};
+
+export type NormalizationLinkedField = {
+  kind: 'Linked';
+  fieldName: string;
+  arguments: Arguments | null;
+  selections: NormalizationAst;
+};
+
+// This is more like an entrypoint, but one specifically for a refetch query/mutation
+export type RefetchQueryArtifact = {
+  kind: 'RefetchQuery';
+  queryText: string;
+  normalizationAst: NormalizationAst;
+};
+
+// TODO rename
+export type RefetchQueryArtifactWrapper = {
+  artifact: RefetchQueryArtifact;
+  allowedVariables: string[];
+};
+
+export function assertIsEntrypoint<
+  TReadFromStore extends Object,
+  TResolverResult,
+>(
+  value:
+    | IsographEntrypoint<TReadFromStore, TResolverResult>
+    | ((_: any) => any)
+    // Temporarily, allow any here. Once we automatically provide
+    // types to entrypoints, we probably don't need this.
+    | any,
+): asserts value is IsographEntrypoint<TReadFromStore, TResolverResult> {
+  if (typeof value === 'function') throw new Error('Not a string');
+}

package/src/garbageCollection.ts

@@ -0,0 +1,120 @@
+import {
+  DataId,
+  IsographEnvironment,
+  IsographStore,
+  ROOT_ID,
+  StoreRecord,
+} from './IsographEnvironment';
+import { NormalizationAst, assertLink } from './index';
+import { getParentRecordKey } from './cache';
+
+export type RetainedQuery = {
+  normalizationAst: NormalizationAst;
+  variables: {};
+};
+
+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
+}
+
+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 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 maybeLink of linkedFieldOrFields) {
+            const link = assertLink(maybeLink);
+            if (link != null) {
+              ids.push(link.__link);
+            }
+          }
+        } else {
+          const link = assertLink(linkedFieldOrFields);
+          if (link != null) {
+            ids.push(link.__link);
+          }
+        }
+
+        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;
+    }
+  }
+}

package/src/index.tsx

@@ -13,141 +13,70 @@ import {
   IsographEnvironment,
   Link,
   ROOT_ID,
-  StoreRecord,
-  useIsographEnvironment,
+  defaultMissingFieldHandler,
 } from './IsographEnvironment';
 import { useEffect, useState } from 'react';
+import { useIsographEnvironment } from './IsographEnvironmentProvider';
+import { ReaderArtifact, ReaderAst } from './reader';
+import {
+  IsographEntrypoint,
+  RefetchQueryArtifactWrapper,
+  assertIsEntrypoint,
+} from './entrypoint';
 
+export {
+  retainQuery,
+  unretainQuery,
+  type RetainedQuery,
+  garbageCollectEnvironment,
+} from './garbageCollection';
 export { type PromiseWrapper } from './PromiseWrapper';
 export { makeNetworkRequest, subscribe } from './cache';
 export {
-  IsographEnvironmentContext,
   ROOT_ID,
   type DataId,
   type DataTypeValue,
   type IsographEnvironment,
-  IsographEnvironmentProvider,
-  type IsographEnvironmentProviderProps,
   type IsographNetworkFunction,
   type IsographStore,
   type Link,
   type StoreRecord,
-  useIsographEnvironment,
   createIsographEnvironment,
   createIsographStore,
+  defaultMissingFieldHandler,
 } from './IsographEnvironment';
+export {
+  IsographEnvironmentProvider,
+  useIsographEnvironment,
+  type IsographEnvironmentProviderProps,
+} from './IsographEnvironmentProvider';
 export { useImperativeReference } from './useImperativeReference';
 export { EntrypointReader } from './EntrypointReader';
-
-// This type should be treated as an opaque type.
-export type IsographEntrypoint<
-  TReadFromStore extends Object,
-  TResolverResult,
-> = {
-  kind: 'Entrypoint';
-  queryText: string;
-  normalizationAst: NormalizationAst;
-  readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
-  nestedRefetchQueries: RefetchQueryArtifactWrapper[];
-};
-
-// TODO this should probably be at least three distinct types, for @component,
-// non-@component and refetch resolvers
-export type ReaderArtifact<TReadFromStore extends Object, TResolverResult> = {
-  kind: 'ReaderArtifact';
-  readerAst: ReaderAst<TReadFromStore>;
-  resolver: (data: TReadFromStore, runtimeProps: any) => TResolverResult;
-  variant: ReaderResolverVariant;
-};
-
-export type ReaderAstNode =
-  | ReaderScalarField
-  | ReaderLinkedField
-  | ReaderResolverField
-  | ReaderRefetchField
-  | ReaderMutationField;
-
-// @ts-ignore
-export type ReaderAst<TReadFromStore> = ReaderAstNode[];
+export {
+  type ReaderArtifact,
+  ReaderAst,
+  ReaderAstNode,
+  ReaderLinkedField,
+  ReaderMutationField,
+  ReaderRefetchField,
+  ReaderResolverField,
+  ReaderResolverVariant,
+  ReaderScalarField,
+} from './reader';
+export {
+  NormalizationAst,
+  NormalizationAstNode,
+  NormalizationLinkedField,
+  NormalizationScalarField,
+  IsographEntrypoint,
+  assertIsEntrypoint,
+  RefetchQueryArtifact,
+  RefetchQueryArtifactWrapper,
+} from './entrypoint';
 
 export type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> =
   T extends (arg1: any, arg2: infer P) => any ? P : never;
 
-export type ReaderScalarField = {
-  kind: 'Scalar';
-  fieldName: string;
-  alias: string | null;
-  arguments: Arguments | null;
-};
-export type ReaderLinkedField = {
-  kind: 'Linked';
-  fieldName: string;
-  alias: string | null;
-  selections: ReaderAst<unknown>;
-  arguments: Arguments | null;
-};
-
-export type ReaderResolverVariant =
-  | { kind: 'Eager' }
-  // componentName is the component's cacheKey for getRefReaderByName
-  // and is the type + field concatenated
-  | { kind: 'Component'; componentName: string };
-
-export type ReaderResolverField = {
-  kind: 'Resolver';
-  alias: string;
-  readerArtifact: ReaderArtifact<any, any>;
-  arguments: Arguments | null;
-  usedRefetchQueries: number[];
-};
-
-export type ReaderRefetchField = {
-  kind: 'RefetchField';
-  alias: string;
-  // TODO this bad modeling. A refetch field cannot have variant: "Component" (I think)
-  readerArtifact: ReaderArtifact<any, any>;
-  refetchQuery: number;
-};
-
-export type ReaderMutationField = {
-  kind: 'MutationField';
-  alias: string;
-  // TODO this bad modeling. A mutation field cannot have variant: "Component" (I think)
-  readerArtifact: ReaderArtifact<any, any>;
-  refetchQuery: number;
-};
-
-export type NormalizationAstNode =
-  | NormalizationScalarField
-  | NormalizationLinkedField;
-export type NormalizationAst = NormalizationAstNode[];
-
-export type NormalizationScalarField = {
-  kind: 'Scalar';
-  fieldName: string;
-  arguments: Arguments | null;
-};
-
-export type NormalizationLinkedField = {
-  kind: 'Linked';
-  fieldName: string;
-  arguments: Arguments | null;
-  selections: NormalizationAst;
-};
-
-// This is more like an entrypoint, but one specifically for a refetch query/mutation
-export type RefetchQueryArtifact = {
-  kind: 'RefetchQuery';
-  queryText: string;
-  normalizationAst: NormalizationAst;
-};
-
-// TODO rename
-export type RefetchQueryArtifactWrapper = {
-  artifact: RefetchQueryArtifact;
-  allowedVariables: string[];
-};
-
 export type Arguments = Argument[];
 export type Argument = [ArgumentName, ArgumentValue];
 export type ArgumentName = string;
@@ -176,17 +105,6 @@ export type FragmentReference<
   nestedRefetchQueries: RefetchQueryArtifactWrapper[];
 };
 
-function assertIsEntrypoint<TReadFromStore extends Object, TResolverResult>(
-  value:
-    | IsographEntrypoint<TReadFromStore, TResolverResult>
-    | ((_: any) => any)
-    // Temporarily, allow any here. Once we automatically provide
-    // types to entrypoints, we probably don't need this.
-    | any,
-): asserts value is IsographEntrypoint<TReadFromStore, TResolverResult> {
-  if (typeof value === 'function') throw new Error('Not a string');
-}
-
 export type ExtractReadFromStore<Type> =
   Type extends IsographEntrypoint<infer X, any> ? X : never;
 export type ExtractResolverResult<Type> =
@@ -569,34 +487,16 @@ function readData<TReadFromStore>(
   return { kind: 'Success', data: target as any };
 }
 
-export function defaultMissingFieldHandler(
-  _storeRecord: StoreRecord,
-  _root: DataId,
-  fieldName: string,
-  arguments_: { [index: string]: any } | null,
-  variables: { [index: string]: any } | null,
-): Link | undefined {
-  if (fieldName === 'node' || fieldName === 'user') {
-    const variable = arguments_?.['id'];
-    const value = variables?.[variable];
-
-    // TODO can we handle explicit nulls here too? Probably, after wrapping in objects
-    if (value != null) {
-      return { __link: value };
-    }
-  }
-}
-
-function assertLink(link: DataTypeValue): Link | undefined | null {
+export function assertLink(link: DataTypeValue): Link | null {
   if (Array.isArray(link)) {
     throw new Error('Unexpected array');
   }
+  if (link == null) {
+    return null;
+  }
   if (typeof link === 'object') {
     return link;
   }
-  if (link === undefined) {
-    return undefined;
-  }
   throw new Error('Invalid link');
 }