@isograph/react 0.0.0-main-c88a0561 → 0.0.0-main-f49c67bb

package/src/index.tsx

@@ -1,40 +1,61 @@
 import {
-  DataId,
-  StoreRecord,
-  DataTypeValue,
-  Link,
-  ROOT_ID,
   getOrCreateCacheForArtifact,
   onNextChange,
-  getStore,
   getParentRecordKey,
 } from './cache';
 import { useLazyDisposableState } from '@isograph/react-disposable-state';
 import { type PromiseWrapper } from './PromiseWrapper';
 import { getOrCreateCachedComponent } from './componentCache';
-
-export {
-  setNetwork,
-  makeNetworkRequest,
-  subscribe,
+import {
   DataId,
+  DataTypeValue,
+  IsographEnvironment,
   Link,
+  ROOT_ID,
   StoreRecord,
-  clearStore,
-} from './cache';
+  useIsographEnvironment,
+} from './context';
+
+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,
+} from './context';
 
 export { iso } from './iso';
 
 // This type should be treated as an opaque type.
-export type IsographEntrypoint<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
+export type IsographEntrypoint<
+  TReadFromStore extends Object,
+  TResolverProps,
+  TResolverResult,
+> = {
   kind: 'Entrypoint';
   queryText: string;
   normalizationAst: NormalizationAst;
-  readerArtifact: ReaderArtifact<TReadFromStore, TResolverProps, TResolverResult>;
+  readerArtifact: ReaderArtifact<
+    TReadFromStore,
+    TResolverProps,
+    TResolverResult
+  >;
   nestedRefetchQueries: RefetchQueryArtifactWrapper[];
 };
 
-export type ReaderArtifact<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
+export type ReaderArtifact<
+  TReadFromStore extends Object,
+  TResolverProps,
+  TResolverResult,
+> = {
   kind: 'ReaderArtifact';
   readerAst: ReaderAst<TReadFromStore>;
   resolver: (data: TResolverProps) => TResolverResult;
@@ -96,7 +117,9 @@ export type ReaderMutationField = {
   allowedVariables: string[];
 };
 
-export type NormalizationAstNode = NormalizationScalarField | NormalizationLinkedField;
+export type NormalizationAstNode =
+  | NormalizationScalarField
+  | NormalizationLinkedField;
 // @ts-ignore
 export type NormalizationAst = NormalizationAstNode[];
 
@@ -139,24 +162,48 @@ export type ArgumentValue =
       value: any;
     };
 
-export type FragmentReference<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
+export type FragmentReference<
+  TReadFromStore extends Object,
+  TResolverProps,
+  TResolverResult,
+> = {
   kind: 'FragmentReference';
-  readerArtifact: ReaderArtifact<TReadFromStore, TResolverProps, TResolverResult>;
+  readerArtifact: ReaderArtifact<
+    TReadFromStore,
+    TResolverProps,
+    TResolverResult
+  >;
   root: DataId;
   variables: { [index: string]: string } | null;
   // TODO: We should instead have ReaderAst<TResolverProps>
   nestedRefetchQueries: RefetchQueryArtifactWrapper[];
 };
 
-function assertIsEntrypoint<TReadFromStore extends Object, TResolverProps, TResolverResult>(
-  value: IsographEntrypoint<TReadFromStore, TResolverProps, TResolverResult> | typeof iso,
-): asserts value is IsographEntrypoint<TReadFromStore, TResolverProps, TResolverResult> {
+function assertIsEntrypoint<
+  TReadFromStore extends Object,
+  TResolverProps,
+  TResolverResult,
+>(
+  value:
+    | IsographEntrypoint<TReadFromStore, TResolverProps, 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,
+  TResolverProps,
+  TResolverResult
+> {
   if (typeof value === 'function') throw new Error('Not a string');
 }
 
-type ExtractTReadFromStore<Type> = Type extends IsographEntrypoint<infer X, any, any> ? X : never;
-type ExtractResolverProps<Type> = Type extends IsographEntrypoint<any, infer X, any> ? X : never;
-type ExtractResolverResult<Type> = Type extends IsographEntrypoint<any, any, infer X> ? X : never;
+type ExtractTReadFromStore<Type> =
+  Type extends IsographEntrypoint<infer X, any, any> ? X : never;
+type ExtractResolverProps<Type> =
+  Type extends IsographEntrypoint<any, infer X, any> ? X : never;
+type ExtractResolverResult<Type> =
+  Type extends IsographEntrypoint<any, any, infer X> ? X : never;
 // Note: we cannot write TEntrypoint extends IsographEntrypoint<any, any, any>, or else
 // if we do not explicitly pass a type, the read out type will be any.
 // We cannot write TEntrypoint extends IsographEntrypoint<never, never, never>, or else
@@ -176,16 +223,19 @@ export function useLazyReference<TEntrypoint>(
     ExtractResolverResult<TEntrypoint>
   >;
 } {
+  const environment = useIsographEnvironment();
   assertIsEntrypoint(entrypoint);
   // Typechecking fails here... TODO investigate
   const cache = getOrCreateCacheForArtifact<ExtractResolverResult<TEntrypoint>>(
+    environment,
     entrypoint,
     variables,
   );
 
   // TODO add comment explaining why we never use this value
   // @ts-ignore
-  const data = useLazyDisposableState<PromiseWrapper<TResolverResult>>(cache).state;
+  const data =
+    useLazyDisposableState<PromiseWrapper<TResolverResult>>(cache).state;
 
   return {
     queryReference: {
@@ -198,12 +248,37 @@ export function useLazyReference<TEntrypoint>(
   };
 }
 
-export function read<TReadFromStore extends Object, TResolverProps, TResolverResult>(
-  fragmentReference: FragmentReference<TReadFromStore, TResolverProps, TResolverResult>,
+export function useRead<
+  TReadFromStore extends Object,
+  TResolverProps,
+  TResolverResult,
+>(
+  fragmentReference: FragmentReference<
+    TReadFromStore,
+    TResolverProps,
+    TResolverResult
+  >,
+): TResolverResult {
+  const environment = useIsographEnvironment();
+  return read(environment, fragmentReference);
+}
+
+export function read<
+  TReadFromStore extends Object,
+  TResolverProps,
+  TResolverResult,
+>(
+  environment: IsographEnvironment,
+  fragmentReference: FragmentReference<
+    TReadFromStore,
+    TResolverProps,
+    TResolverResult
+  >,
 ): TResolverResult {
   const variant = fragmentReference.readerArtifact.variant;
   if (variant.kind === 'Eager') {
     const data = readData(
+      environment,
       fragmentReference.readerArtifact.readerAst,
       fragmentReference.root,
       fragmentReference.variables ?? {},
@@ -217,6 +292,7 @@ export function read<TReadFromStore extends Object, TResolverProps, TResolverRes
   } else if (variant.kind === 'Component') {
     // @ts-ignore
     return getOrCreateCachedComponent(
+      environment,
       fragmentReference.root,
       variant.componentName,
       fragmentReference.readerArtifact,
@@ -229,9 +305,11 @@ export function read<TReadFromStore extends Object, TResolverProps, TResolverRes
 }
 
 export function readButDoNotEvaluate<TReadFromStore extends Object>(
+  environment: IsographEnvironment,
   reference: FragmentReference<TReadFromStore, unknown, unknown>,
 ): TReadFromStore {
   const response = readData(
+    environment,
     reference.readerArtifact.readerAst,
     reference.root,
     reference.variables ?? {},
@@ -259,12 +337,13 @@ type ReadDataResult<TReadFromStore> =
     };
 
 function readData<TReadFromStore>(
+  environment: IsographEnvironment,
   ast: ReaderAst<TReadFromStore>,
   root: DataId,
   variables: { [index: string]: string },
   nestedRefetchQueries: RefetchQueryArtifactWrapper[],
 ): ReadDataResult<TReadFromStore> {
-  let storeRecord = getStore()[root];
+  let storeRecord = environment.store[root];
   if (storeRecord === undefined) {
     return { kind: 'MissingData', reason: 'No record for root ' + root };
   }
@@ -313,7 +392,13 @@ function readData<TReadFromStore>(
               results.push(null);
               continue;
             }
-            const result = readData(field.selections, link.__link, variables, nestedRefetchQueries);
+            const result = readData(
+              environment,
+              field.selections,
+              link.__link,
+              variables,
+              nestedRefetchQueries,
+            );
             if (result.kind === 'MissingData') {
               return {
                 kind: 'MissingData',
@@ -335,6 +420,8 @@ function readData<TReadFromStore>(
         let link = assertLink(value);
         if (link === undefined) {
           // TODO make this configurable, and also generated and derived from the schema
+          const missingFieldHandler =
+            environment.missingFieldHandler ?? defaultMissingFieldHandler;
           const altLink = missingFieldHandler(
             storeRecord,
             root,
@@ -361,7 +448,13 @@ function readData<TReadFromStore>(
           break;
         }
         const targetId = link.__link;
-        const data = readData(field.selections, targetId, variables, nestedRefetchQueries);
+        const data = readData(
+          environment,
+          field.selections,
+          targetId,
+          variables,
+          nestedRefetchQueries,
+        );
         if (data.kind === 'MissingData') {
           return {
             kind: 'MissingData',
@@ -374,6 +467,7 @@ function readData<TReadFromStore>(
       }
       case 'RefetchField': {
         const data = readData(
+          environment,
           field.readerArtifact.readerAst,
           root,
           variables,
@@ -398,17 +492,22 @@ function readData<TReadFromStore>(
           const refetchQueryArtifact = refetchQuery.artifact;
           const allowedVariables = refetchQuery.allowedVariables;
 
-          target[field.alias] = field.readerArtifact.resolver(refetchQueryArtifact, {
-            ...data.data,
-            // TODO continue from here
-            // variables need to be filtered for what we need just for the refetch query
-            ...filterVariables(variables, allowedVariables),
-          });
+          target[field.alias] = field.readerArtifact.resolver(
+            environment,
+            refetchQueryArtifact,
+            {
+              ...data.data,
+              // TODO continue from here
+              // variables need to be filtered for what we need just for the refetch query
+              ...filterVariables(variables, allowedVariables),
+            },
+          );
         }
         break;
       }
       case 'MutationField': {
         const data = readData(
+          environment,
           field.readerArtifact.readerAst,
           root,
           variables,
@@ -434,6 +533,7 @@ function readData<TReadFromStore>(
           const allowedVariables = refetchQuery.allowedVariables;
 
           target[field.alias] = field.readerArtifact.resolver(
+            environment,
             refetchQueryArtifact,
             data.data,
             filterVariables(variables, allowedVariables),
@@ -450,6 +550,7 @@ function readData<TReadFromStore>(
         const variant = field.readerArtifact.variant;
         if (variant.kind === 'Eager') {
           const data = readData(
+            environment,
             field.readerArtifact.readerAst,
             root,
             variables,
@@ -466,6 +567,7 @@ function readData<TReadFromStore>(
           }
         } else if (variant.kind === 'Component') {
           target[field.alias] = getOrCreateCachedComponent(
+            environment,
             root,
             variant.componentName,
             field.readerArtifact,
@@ -480,25 +582,9 @@ function readData<TReadFromStore>(
   return { kind: 'Success', data: target as any };
 }
 
-let customMissingFieldHandler: typeof defaultMissingFieldHandler | null = null;
-
-function missingFieldHandler(
-  storeRecord: StoreRecord,
-  root: DataId,
-  fieldName: string,
-  arguments_: { [index: string]: any } | null,
-  variables: { [index: string]: any } | null,
-): Link | undefined {
-  if (customMissingFieldHandler != null) {
-    return customMissingFieldHandler(storeRecord, root, fieldName, arguments_, variables);
-  } else {
-    return defaultMissingFieldHandler(storeRecord, root, fieldName, arguments_, variables);
-  }
-}
-
 export function defaultMissingFieldHandler(
-  storeRecord: StoreRecord,
-  root: DataId,
+  _storeRecord: StoreRecord,
+  _root: DataId,
   fieldName: string,
   arguments_: { [index: string]: any } | null,
   variables: { [index: string]: any } | null,
@@ -514,10 +600,6 @@ export function defaultMissingFieldHandler(
   }
 }
 
-export function setMissingFieldHandler(handler: typeof defaultMissingFieldHandler) {
-  customMissingFieldHandler = handler;
-}
-
 function assertLink(link: DataTypeValue): Link | undefined | null {
   if (Array.isArray(link)) {
     throw new Error('Unexpected array');