@isograph/react 0.0.0-main-f524690b → 0.0.0-main-38d73d29

package/dist/IsographEnvironment.d.ts

@@ -0,0 +1,56 @@
+import { ReactNode } from 'react';
+import * as React from 'react';
+import { ParentCache } from '@isograph/isograph-react-disposable-state';
+export declare const IsographEnvironmentContext: React.Context<IsographEnvironment | null>;
+type ComponentName = string;
+type StringifiedArgs = string;
+type ComponentCache = {
+    [key: DataId]: {
+        [key: ComponentName]: {
+            [key: StringifiedArgs]: React.FC<any>;
+        };
+    };
+};
+export type Subscriptions = Set<() => void>;
+type SuspenseCache = {
+    [index: string]: ParentCache<any>;
+};
+export type IsographEnvironment = {
+    store: IsographStore;
+    networkFunction: IsographNetworkFunction;
+    missingFieldHandler: MissingFieldHandler | null;
+    componentCache: ComponentCache;
+    subscriptions: Subscriptions;
+    suspenseCache: SuspenseCache;
+};
+export type MissingFieldHandler = (storeRecord: StoreRecord, root: DataId, fieldName: string, arguments_: {
+    [index: string]: any;
+} | null, variables: {
+    [index: string]: any;
+} | null) => Link | undefined;
+export type IsographNetworkFunction = (queryText: string, variables: object) => Promise<any>;
+export type Link = {
+    __link: DataId;
+};
+export type DataTypeValue = undefined | number | boolean | string | null | Link | DataTypeValue[];
+export type StoreRecord = {
+    [index: DataId | string]: DataTypeValue;
+    id?: DataId;
+};
+export type DataId = string;
+export declare const ROOT_ID: DataId & '__ROOT';
+export type IsographStore = {
+    [index: DataId]: StoreRecord | null;
+    __ROOT: StoreRecord;
+};
+export type IsographEnvironmentProviderProps = {
+    environment: IsographEnvironment;
+    children: ReactNode;
+};
+export declare function IsographEnvironmentProvider({ environment, children, }: IsographEnvironmentProviderProps): React.JSX.Element;
+export declare function useIsographEnvironment(): IsographEnvironment;
+export declare function createIsographEnvironment(store: IsographStore, networkFunction: IsographNetworkFunction, missingFieldHandler?: MissingFieldHandler): IsographEnvironment;
+export declare function createIsographStore(): {
+    __ROOT: {};
+};
+export {};

package/dist/IsographEnvironment.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIsographStore = exports.createIsographEnvironment = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.ROOT_ID = exports.IsographEnvironmentContext = void 0;
+const react_1 = require("react");
+const React = __importStar(require("react"));
+const cache_1 = require("./cache");
+exports.IsographEnvironmentContext = (0, react_1.createContext)(null);
+exports.ROOT_ID = '__ROOT';
+function IsographEnvironmentProvider({ environment, children, }) {
+    const [, setState] = React.useState();
+    React.useEffect(() => {
+        return (0, cache_1.subscribe)(environment, () => setState({}));
+    }, []);
+    return (React.createElement(exports.IsographEnvironmentContext.Provider, { value: environment }, children));
+}
+exports.IsographEnvironmentProvider = IsographEnvironmentProvider;
+function useIsographEnvironment() {
+    const context = (0, react_1.useContext)(exports.IsographEnvironmentContext);
+    if (context == null) {
+        throw new Error('Unexpected null environment context. Make sure to render ' +
+            'this component within an IsographEnvironmentProvider component');
+    }
+    return context;
+}
+exports.useIsographEnvironment = useIsographEnvironment;
+function createIsographEnvironment(store, networkFunction, missingFieldHandler) {
+    return {
+        store,
+        networkFunction,
+        missingFieldHandler: missingFieldHandler !== null && missingFieldHandler !== void 0 ? missingFieldHandler : null,
+        componentCache: {},
+        subscriptions: new Set(),
+        suspenseCache: {},
+    };
+}
+exports.createIsographEnvironment = createIsographEnvironment;
+function createIsographStore() {
+    return {
+        [exports.ROOT_ID]: {},
+    };
+}
+exports.createIsographStore = createIsographStore;

package/dist/cache.d.ts

@@ -1,6 +1,7 @@
 import { ItemCleanupPair, ParentCache } from '@isograph/react-disposable-state';
 import { PromiseWrapper } from './PromiseWrapper';
 import { IsographEntrypoint, NormalizationLinkedField, NormalizationScalarField, ReaderLinkedField, ReaderScalarField } from './index';
+import { type IsographEnvironment } from './IsographEnvironment';
 declare global {
     interface Window {
         __LOG: boolean;
@@ -13,27 +14,10 @@ declare global {
  */
 export declare function stableCopy<T>(value: T): T;
 type IsoResolver = IsographEntrypoint<any, any, any>;
-export declare function getOrCreateCacheForArtifact<T>(artifact: IsographEntrypoint<any, any, T>, variables: object): ParentCache<PromiseWrapper<T>>;
-declare let network: ((queryText: string, variables: object) => Promise<any>) | null;
-export declare function setNetwork(newNetwork: typeof network): void;
-export declare function makeNetworkRequest<T>(artifact: IsoResolver, variables: object): ItemCleanupPair<PromiseWrapper<T>>;
-export type Link = {
-    __link: DataId;
-};
-export type DataTypeValue = undefined | number | boolean | string | null | Link | DataTypeValue[];
-export type StoreRecord = {
-    [index: DataId | string]: DataTypeValue;
-    id?: DataId;
-};
-export type DataId = string;
-export declare const ROOT_ID: DataId & '__ROOT';
-export declare function getStore(): {
-    [index: string]: StoreRecord | null;
-    __ROOT: StoreRecord;
-};
-export declare function clearStore(): void;
-export declare function subscribe(callback: () => void): () => void;
-export declare function onNextChange(): Promise<void>;
+export declare function getOrCreateCacheForArtifact<T>(environment: IsographEnvironment, artifact: IsographEntrypoint<any, any, T>, variables: object): ParentCache<PromiseWrapper<T>>;
+export declare function makeNetworkRequest<T>(environment: IsographEnvironment, artifact: IsoResolver, variables: object): ItemCleanupPair<PromiseWrapper<T>>;
+export declare function subscribe(environment: IsographEnvironment, callback: () => void): () => void;
+export declare function onNextChange(environment: IsographEnvironment): Promise<void>;
 export declare function getParentRecordKey(astNode: NormalizationLinkedField | NormalizationScalarField | ReaderLinkedField | ReaderScalarField, variables: {
     [index: string]: string;
 }): string;

package/dist/cache.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SECOND_SPLIT_KEY = exports.FIRST_SPLIT_KEY = exports.getParentRecordKey = exports.onNextChange = exports.subscribe = exports.clearStore = exports.getStore = exports.ROOT_ID = exports.makeNetworkRequest = exports.setNetwork = exports.getOrCreateCacheForArtifact = exports.stableCopy = void 0;
+exports.SECOND_SPLIT_KEY = exports.FIRST_SPLIT_KEY = exports.getParentRecordKey = exports.onNextChange = exports.subscribe = exports.makeNetworkRequest = exports.getOrCreateCacheForArtifact = exports.stableCopy = void 0;
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
 const PromiseWrapper_1 = require("./PromiseWrapper");
-const cache = {};
-function getOrCreateCache(index, factory) {
+const IsographEnvironment_1 = require("./IsographEnvironment");
+function getOrCreateCache(environment, index, factory) {
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('getting cache for', {
             index,
-            cache: Object.keys(cache),
-            found: !!cache[index],
+            cache: Object.keys(environment.suspenseCache),
+            found: !!environment.suspenseCache[index],
         });
     }
-    if (cache[index] == null) {
-        cache[index] = new react_disposable_state_1.ParentCache(factory);
+    if (environment.suspenseCache[index] == null) {
+        environment.suspenseCache[index] = new react_disposable_state_1.ParentCache(factory);
     }
-    return cache[index];
+    return environment.suspenseCache[index];
 }
 /**
  * Creates a copy of the provided value, ensuring any nested objects have their
@@ -39,30 +39,23 @@ function stableCopy(value) {
     return stable;
 }
 exports.stableCopy = stableCopy;
-function getOrCreateCacheForArtifact(artifact, variables) {
+function getOrCreateCacheForArtifact(environment, artifact, variables) {
     const cacheKey = artifact.queryText + JSON.stringify(stableCopy(variables));
-    const factory = () => makeNetworkRequest(artifact, variables);
-    return getOrCreateCache(cacheKey, factory);
+    const factory = () => makeNetworkRequest(environment, artifact, variables);
+    return getOrCreateCache(environment, cacheKey, factory);
 }
 exports.getOrCreateCacheForArtifact = getOrCreateCacheForArtifact;
-let network;
-// This is a hack until we store this in context somehow
-function setNetwork(newNetwork) {
-    network = newNetwork;
-}
-exports.setNetwork = setNetwork;
-function makeNetworkRequest(artifact, variables) {
+function makeNetworkRequest(environment, artifact, variables) {
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('make network request', artifact, variables);
     }
-    if (network == null) {
-        throw new Error('Network must be set before makeNetworkRequest is called');
-    }
-    const promise = network(artifact.queryText, variables).then((networkResponse) => {
+    const promise = environment
+        .networkFunction(artifact.queryText, variables)
+        .then((networkResponse) => {
         if (typeof window !== 'undefined' && window.__LOG) {
             console.log('network response', artifact);
         }
-        normalizeData(artifact.normalizationAst, networkResponse.data, variables, artifact.nestedRefetchQueries);
+        normalizeData(environment, artifact.normalizationAst, networkResponse.data, variables, artifact.nestedRefetchQueries);
         return networkResponse.data;
     });
     const wrapper = (0, PromiseWrapper_1.wrapPromise)(promise);
@@ -75,52 +68,37 @@ function makeNetworkRequest(artifact, variables) {
     return response;
 }
 exports.makeNetworkRequest = makeNetworkRequest;
-exports.ROOT_ID = '__ROOT';
-let store = {
-    __ROOT: {},
-};
-function getStore() {
-    return store;
-}
-exports.getStore = getStore;
-function clearStore() {
-    store = {
-        __ROOT: {},
-    };
-}
-exports.clearStore = clearStore;
-function normalizeData(normalizationAst, networkResponse, variables, nestedRefetchQueries) {
+function normalizeData(environment, normalizationAst, networkResponse, variables, nestedRefetchQueries) {
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('about to normalize', normalizationAst, networkResponse, variables);
     }
-    normalizeDataIntoRecord(normalizationAst, networkResponse, store.__ROOT, exports.ROOT_ID, variables, nestedRefetchQueries);
+    normalizeDataIntoRecord(environment, normalizationAst, networkResponse, environment.store.__ROOT, IsographEnvironment_1.ROOT_ID, variables, nestedRefetchQueries);
     if (typeof window !== 'undefined' && window.__LOG) {
-        console.log('after normalization', { store });
+        console.log('after normalization', { store: environment.store });
     }
-    callSubscriptions();
+    callSubscriptions(environment);
 }
-function subscribe(callback) {
-    subscriptions.add(callback);
-    return () => subscriptions.delete(callback);
+function subscribe(environment, callback) {
+    environment.subscriptions.add(callback);
+    return () => environment.subscriptions.delete(callback);
 }
 exports.subscribe = subscribe;
-function onNextChange() {
+function onNextChange(environment) {
     return new Promise((resolve) => {
-        const unsubscribe = subscribe(() => {
+        const unsubscribe = subscribe(environment, () => {
             unsubscribe();
             resolve();
         });
     });
 }
 exports.onNextChange = onNextChange;
-const subscriptions = new Set();
-function callSubscriptions() {
-    subscriptions.forEach((callback) => callback());
+function callSubscriptions(environment) {
+    environment.subscriptions.forEach((callback) => callback());
 }
 /**
  * Mutate targetParentRecord according to the normalizationAst and networkResponseParentRecord.
  */
-function normalizeDataIntoRecord(normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
+function normalizeDataIntoRecord(environment, normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
     for (const normalizationNode of normalizationAst) {
         switch (normalizationNode.kind) {
             case 'Scalar': {
@@ -128,7 +106,7 @@ function normalizeDataIntoRecord(normalizationAst, networkResponseParentRecord,
                 break;
             }
             case 'Linked': {
-                normalizeLinkedField(normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries);
+                normalizeLinkedField(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries);
                 break;
             }
         }
@@ -149,7 +127,7 @@ function normalizeScalarField(astNode, networkResponseParentRecord, targetStoreR
 /**
  * Mutate targetParentRecord with a given linked field ast node.
  */
-function normalizeLinkedField(astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
+function normalizeLinkedField(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
     const networkResponseKey = getNetworkResponseKey(astNode);
     const networkResponseData = networkResponseParentRecord[networkResponseKey];
     const parentRecordKey = getParentRecordKey(astNode, variables);
@@ -165,24 +143,24 @@ function normalizeLinkedField(astNode, networkResponseParentRecord, targetParent
         const dataIds = [];
         for (let i = 0; i < networkResponseData.length; i++) {
             const networkResponseObject = networkResponseData[i];
-            const newStoreRecordId = normalizeNetworkResponseObject(astNode, networkResponseObject, targetParentRecordId, variables, i, nestedRefetchQueries);
+            const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseObject, targetParentRecordId, variables, i, nestedRefetchQueries);
             dataIds.push({ __link: newStoreRecordId });
         }
         targetParentRecord[parentRecordKey] = dataIds;
     }
     else {
-        const newStoreRecordId = normalizeNetworkResponseObject(astNode, networkResponseData, targetParentRecordId, variables, null, nestedRefetchQueries);
+        const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, null, nestedRefetchQueries);
         targetParentRecord[parentRecordKey] = {
             __link: newStoreRecordId,
         };
     }
 }
-function normalizeNetworkResponseObject(astNode, networkResponseData, targetParentRecordId, variables, index, nestedRefetchQueries) {
+function normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, index, nestedRefetchQueries) {
     var _a;
     const newStoreRecordId = getDataIdOfNetworkResponse(targetParentRecordId, networkResponseData, astNode, variables, index);
-    const newStoreRecord = (_a = store[newStoreRecordId]) !== null && _a !== void 0 ? _a : {};
-    store[newStoreRecordId] = newStoreRecord;
-    normalizeDataIntoRecord(astNode.selections, networkResponseData, newStoreRecord, newStoreRecordId, variables, nestedRefetchQueries);
+    const newStoreRecord = (_a = environment.store[newStoreRecordId]) !== null && _a !== void 0 ? _a : {};
+    environment.store[newStoreRecordId] = newStoreRecord;
+    normalizeDataIntoRecord(environment, astNode.selections, networkResponseData, newStoreRecord, newStoreRecordId, variables, nestedRefetchQueries);
     return newStoreRecordId;
 }
 function isScalarOrEmptyArray(data) {

package/dist/componentCache.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import { ReaderArtifact, RefetchQueryArtifactWrapper } from './index';
-import { DataId } from './cache';
-export declare function getOrCreateCachedComponent(root: DataId, componentName: string, readerArtifact: ReaderArtifact<any, any, any>, variables: {
+import { IsographEnvironment, DataId } from './IsographEnvironment';
+export declare function getOrCreateCachedComponent(environment: IsographEnvironment, root: DataId, componentName: string, readerArtifact: ReaderArtifact<any, any, any>, variables: {
     [key: string]: string;
 }, resolverRefetchQueries: RefetchQueryArtifactWrapper[]): import("react").FC<any>;

package/dist/componentCache.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOrCreateCachedComponent = void 0;
 const index_1 = require("./index");
 const cache_1 = require("./cache");
-const cachedComponentsById = {};
-function getOrCreateCachedComponent(root, componentName, readerArtifact, variables, resolverRefetchQueries) {
+function getOrCreateCachedComponent(environment, root, componentName, readerArtifact, variables, resolverRefetchQueries) {
     var _a, _b, _c;
+    const cachedComponentsById = environment.componentCache;
     const stringifiedArgs = JSON.stringify((0, cache_1.stableCopy)(variables));
     cachedComponentsById[root] = (_a = cachedComponentsById[root]) !== null && _a !== void 0 ? _a : {};
     const componentsByName = cachedComponentsById[root];
@@ -14,7 +14,7 @@ function getOrCreateCachedComponent(root, componentName, readerArtifact, variabl
     byArgs[stringifiedArgs] =
         (_c = byArgs[stringifiedArgs]) !== null && _c !== void 0 ? _c : (() => {
             function Component(additionalRuntimeProps) {
-                const data = (0, index_1.readButDoNotEvaluate)({
+                const data = (0, index_1.readButDoNotEvaluate)(environment, {
                     kind: 'FragmentReference',
                     readerArtifact: readerArtifact,
                     root,

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { DataId, StoreRecord, Link } from './cache';
-export { setNetwork, makeNetworkRequest, subscribe, DataId, Link, StoreRecord, clearStore, } from './cache';
+import { DataId, IsographEnvironment, Link, StoreRecord } from './IsographEnvironment';
+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, } from './IsographEnvironment';
 export { iso } from './iso';
 export type IsographEntrypoint<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
     kind: 'Entrypoint';
@@ -102,14 +103,14 @@ type ExtractResolverResult<Type> = Type extends IsographEntrypoint<any, any, inf
 export declare function useLazyReference<TEntrypoint>(entrypoint: TEntrypoint | ((_: any) => any), variables: object): {
     queryReference: FragmentReference<ExtractTReadFromStore<TEntrypoint>, ExtractResolverProps<TEntrypoint>, ExtractResolverResult<TEntrypoint>>;
 };
-export declare function read<TReadFromStore extends Object, TResolverProps, TResolverResult>(fragmentReference: FragmentReference<TReadFromStore, TResolverProps, TResolverResult>): TResolverResult;
-export declare function readButDoNotEvaluate<TReadFromStore extends Object>(reference: FragmentReference<TReadFromStore, unknown, unknown>): TReadFromStore;
-export declare function defaultMissingFieldHandler(storeRecord: StoreRecord, root: DataId, fieldName: string, arguments_: {
+export declare function useRead<TReadFromStore extends Object, TResolverProps, TResolverResult>(fragmentReference: FragmentReference<TReadFromStore, TResolverProps, TResolverResult>): TResolverResult;
+export declare function read<TReadFromStore extends Object, TResolverProps, TResolverResult>(environment: IsographEnvironment, fragmentReference: FragmentReference<TReadFromStore, TResolverProps, TResolverResult>): TResolverResult;
+export declare function readButDoNotEvaluate<TReadFromStore extends Object>(environment: IsographEnvironment, reference: FragmentReference<TReadFromStore, unknown, unknown>): TReadFromStore;
+export declare function defaultMissingFieldHandler(_storeRecord: StoreRecord, _root: DataId, fieldName: string, arguments_: {
     [index: string]: any;
 } | null, variables: {
     [index: string]: any;
 } | null): Link | undefined;
-export declare function setMissingFieldHandler(handler: typeof defaultMissingFieldHandler): void;
 export type IsographComponentProps<TDataType, TOtherProps = Object> = {
     data: TDataType;
 } & TOtherProps;

package/dist/index.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setMissingFieldHandler = exports.defaultMissingFieldHandler = exports.readButDoNotEvaluate = exports.read = exports.useLazyReference = exports.iso = exports.clearStore = exports.subscribe = exports.makeNetworkRequest = exports.setNetwork = void 0;
+exports.defaultMissingFieldHandler = exports.readButDoNotEvaluate = exports.read = exports.useRead = exports.useLazyReference = exports.iso = exports.createIsographStore = exports.createIsographEnvironment = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.ROOT_ID = exports.IsographEnvironmentContext = exports.subscribe = exports.makeNetworkRequest = void 0;
 const cache_1 = require("./cache");
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
 const componentCache_1 = require("./componentCache");
+const IsographEnvironment_1 = require("./IsographEnvironment");
 var cache_2 = require("./cache");
-Object.defineProperty(exports, "setNetwork", { enumerable: true, get: function () { return cache_2.setNetwork; } });
 Object.defineProperty(exports, "makeNetworkRequest", { enumerable: true, get: function () { return cache_2.makeNetworkRequest; } });
 Object.defineProperty(exports, "subscribe", { enumerable: true, get: function () { return cache_2.subscribe; } });
-Object.defineProperty(exports, "clearStore", { enumerable: true, get: function () { return cache_2.clearStore; } });
+var IsographEnvironment_2 = require("./IsographEnvironment");
+Object.defineProperty(exports, "IsographEnvironmentContext", { enumerable: true, get: function () { return IsographEnvironment_2.IsographEnvironmentContext; } });
+Object.defineProperty(exports, "ROOT_ID", { enumerable: true, get: function () { return IsographEnvironment_2.ROOT_ID; } });
+Object.defineProperty(exports, "IsographEnvironmentProvider", { enumerable: true, get: function () { return IsographEnvironment_2.IsographEnvironmentProvider; } });
+Object.defineProperty(exports, "useIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironment_2.useIsographEnvironment; } });
+Object.defineProperty(exports, "createIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironment_2.createIsographEnvironment; } });
+Object.defineProperty(exports, "createIsographStore", { enumerable: true, get: function () { return IsographEnvironment_2.createIsographStore; } });
 var iso_1 = require("./iso");
 Object.defineProperty(exports, "iso", { enumerable: true, get: function () { return iso_1.iso; } });
 function assertIsEntrypoint(value) {
@@ -20,9 +26,10 @@ function assertIsEntrypoint(value) {
 // We cannot write TEntrypoint extends IsographEntrypoint<never, never, never>, or else
 // any actual Entrypoint we pass will not be valid.
 function useLazyReference(entrypoint, variables) {
+    const environment = (0, IsographEnvironment_1.useIsographEnvironment)();
     assertIsEntrypoint(entrypoint);
     // Typechecking fails here... TODO investigate
-    const cache = (0, cache_1.getOrCreateCacheForArtifact)(entrypoint, variables);
+    const cache = (0, cache_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables);
     // TODO add comment explaining why we never use this value
     // @ts-ignore
     const data = (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
@@ -30,20 +37,25 @@ function useLazyReference(entrypoint, variables) {
         queryReference: {
             kind: 'FragmentReference',
             readerArtifact: entrypoint.readerArtifact,
-            root: cache_1.ROOT_ID,
+            root: IsographEnvironment_1.ROOT_ID,
             variables,
             nestedRefetchQueries: entrypoint.nestedRefetchQueries,
         },
     };
 }
 exports.useLazyReference = useLazyReference;
-function read(fragmentReference) {
+function useRead(fragmentReference) {
+    const environment = (0, IsographEnvironment_1.useIsographEnvironment)();
+    return read(environment, fragmentReference);
+}
+exports.useRead = useRead;
+function read(environment, fragmentReference) {
     var _a, _b;
     const variant = fragmentReference.readerArtifact.variant;
     if (variant.kind === 'Eager') {
-        const data = readData(fragmentReference.readerArtifact.readerAst, fragmentReference.root, (_a = fragmentReference.variables) !== null && _a !== void 0 ? _a : {}, fragmentReference.nestedRefetchQueries);
+        const data = readData(environment, fragmentReference.readerArtifact.readerAst, fragmentReference.root, (_a = fragmentReference.variables) !== null && _a !== void 0 ? _a : {}, fragmentReference.nestedRefetchQueries);
         if (data.kind === 'MissingData') {
-            throw (0, cache_1.onNextChange)();
+            throw (0, cache_1.onNextChange)(environment);
         }
         else {
             return fragmentReference.readerArtifact.resolver(data.data);
@@ -51,29 +63,29 @@ function read(fragmentReference) {
     }
     else if (variant.kind === 'Component') {
         // @ts-ignore
-        return (0, componentCache_1.getOrCreateCachedComponent)(fragmentReference.root, variant.componentName, fragmentReference.readerArtifact, (_b = fragmentReference.variables) !== null && _b !== void 0 ? _b : {}, fragmentReference.nestedRefetchQueries);
+        return (0, componentCache_1.getOrCreateCachedComponent)(environment, fragmentReference.root, variant.componentName, fragmentReference.readerArtifact, (_b = fragmentReference.variables) !== null && _b !== void 0 ? _b : {}, fragmentReference.nestedRefetchQueries);
     }
     // Why can't Typescript realize that this is unreachable??
     throw new Error('This is unreachable');
 }
 exports.read = read;
-function readButDoNotEvaluate(reference) {
+function readButDoNotEvaluate(environment, reference) {
     var _a;
-    const response = readData(reference.readerArtifact.readerAst, reference.root, (_a = reference.variables) !== null && _a !== void 0 ? _a : {}, reference.nestedRefetchQueries);
+    const response = readData(environment, reference.readerArtifact.readerAst, reference.root, (_a = reference.variables) !== null && _a !== void 0 ? _a : {}, reference.nestedRefetchQueries);
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('done reading', { response });
     }
     if (response.kind === 'MissingData') {
-        throw (0, cache_1.onNextChange)();
+        throw (0, cache_1.onNextChange)(environment);
     }
     else {
         return response.data;
     }
 }
 exports.readButDoNotEvaluate = readButDoNotEvaluate;
-function readData(ast, root, variables, nestedRefetchQueries) {
-    var _a, _b, _c, _d;
-    let storeRecord = (0, cache_1.getStore)()[root];
+function readData(environment, ast, root, variables, nestedRefetchQueries) {
+    var _a, _b, _c, _d, _e;
+    let storeRecord = environment.store[root];
     if (storeRecord === undefined) {
         return { kind: 'MissingData', reason: 'No record for root ' + root };
     }
@@ -119,7 +131,7 @@ function readData(ast, root, variables, nestedRefetchQueries) {
                             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',
@@ -140,6 +152,7 @@ function readData(ast, root, variables, nestedRefetchQueries) {
                 let link = assertLink(value);
                 if (link === undefined) {
                     // TODO make this configurable, and also generated and derived from the schema
+                    const missingFieldHandler = (_c = environment.missingFieldHandler) !== null && _c !== void 0 ? _c : defaultMissingFieldHandler;
                     const altLink = missingFieldHandler(storeRecord, root, field.fieldName, field.arguments, variables);
                     if (altLink === undefined) {
                         return {
@@ -157,11 +170,11 @@ function readData(ast, root, variables, nestedRefetchQueries) {
                     }
                 }
                 else if (link === null) {
-                    target[(_c = field.alias) !== null && _c !== void 0 ? _c : field.fieldName] = null;
+                    target[(_d = field.alias) !== null && _d !== void 0 ? _d : field.fieldName] = null;
                     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',
@@ -169,11 +182,11 @@ function readData(ast, root, variables, nestedRefetchQueries) {
                         nestedReason: data,
                     };
                 }
-                target[(_d = field.alias) !== null && _d !== void 0 ? _d : field.fieldName] = data.data;
+                target[(_e = field.alias) !== null && _e !== void 0 ? _e : field.fieldName] = data.data;
                 break;
             }
             case 'RefetchField': {
-                const data = readData(field.readerArtifact.readerAst, root, variables, 
+                const data = readData(environment, field.readerArtifact.readerAst, root, variables, 
                 // Refetch fields just read the id, and don't need refetch query artifacts
                 []);
                 if (typeof window !== 'undefined' && window.__LOG) {
@@ -194,12 +207,12 @@ function readData(ast, root, variables, nestedRefetchQueries) {
                     const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
                     const refetchQueryArtifact = refetchQuery.artifact;
                     const allowedVariables = refetchQuery.allowedVariables;
-                    target[field.alias] = field.readerArtifact.resolver(refetchQueryArtifact, Object.assign(Object.assign({}, data.data), filterVariables(variables, allowedVariables)));
+                    target[field.alias] = field.readerArtifact.resolver(environment, refetchQueryArtifact, Object.assign(Object.assign({}, data.data), filterVariables(variables, allowedVariables)));
                 }
                 break;
             }
             case 'MutationField': {
-                const data = readData(field.readerArtifact.readerAst, root, variables, 
+                const data = readData(environment, field.readerArtifact.readerAst, root, variables, 
                 // Refetch fields just read the id, and don't need refetch query artifacts
                 []);
                 if (typeof window !== 'undefined' && window.__LOG) {
@@ -220,7 +233,7 @@ function readData(ast, root, variables, nestedRefetchQueries) {
                     const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
                     const refetchQueryArtifact = refetchQuery.artifact;
                     const allowedVariables = refetchQuery.allowedVariables;
-                    target[field.alias] = field.readerArtifact.resolver(refetchQueryArtifact, data.data, filterVariables(variables, allowedVariables));
+                    target[field.alias] = field.readerArtifact.resolver(environment, refetchQueryArtifact, data.data, filterVariables(variables, allowedVariables));
                 }
                 break;
             }
@@ -229,7 +242,7 @@ function readData(ast, root, variables, nestedRefetchQueries) {
                 const resolverRefetchQueries = usedRefetchQueries.map((index) => nestedRefetchQueries[index]);
                 const variant = field.readerArtifact.variant;
                 if (variant.kind === 'Eager') {
-                    const data = readData(field.readerArtifact.readerAst, root, variables, resolverRefetchQueries);
+                    const data = readData(environment, field.readerArtifact.readerAst, root, variables, resolverRefetchQueries);
                     if (data.kind === 'MissingData') {
                         return {
                             kind: 'MissingData',
@@ -242,7 +255,7 @@ function readData(ast, root, variables, nestedRefetchQueries) {
                     }
                 }
                 else if (variant.kind === 'Component') {
-                    target[field.alias] = (0, componentCache_1.getOrCreateCachedComponent)(root, variant.componentName, field.readerArtifact, variables, resolverRefetchQueries);
+                    target[field.alias] = (0, componentCache_1.getOrCreateCachedComponent)(environment, root, variant.componentName, field.readerArtifact, variables, resolverRefetchQueries);
                 }
                 break;
             }
@@ -250,16 +263,7 @@ function readData(ast, root, variables, nestedRefetchQueries) {
     }
     return { kind: 'Success', data: target };
 }
-let customMissingFieldHandler = null;
-function missingFieldHandler(storeRecord, root, fieldName, arguments_, variables) {
-    if (customMissingFieldHandler != null) {
-        return customMissingFieldHandler(storeRecord, root, fieldName, arguments_, variables);
-    }
-    else {
-        return defaultMissingFieldHandler(storeRecord, root, fieldName, arguments_, variables);
-    }
-}
-function defaultMissingFieldHandler(storeRecord, root, fieldName, arguments_, variables) {
+function defaultMissingFieldHandler(_storeRecord, _root, fieldName, arguments_, variables) {
     if (fieldName === 'node' || fieldName === 'user') {
         const variable = arguments_ === null || arguments_ === void 0 ? void 0 : arguments_['id'];
         const value = variables === null || variables === void 0 ? void 0 : variables[variable];
@@ -270,10 +274,6 @@ function defaultMissingFieldHandler(storeRecord, root, fieldName, arguments_, va
     }
 }
 exports.defaultMissingFieldHandler = defaultMissingFieldHandler;
-function setMissingFieldHandler(handler) {
-    customMissingFieldHandler = handler;
-}
-exports.setMissingFieldHandler = setMissingFieldHandler;
 function assertLink(link) {
     if (Array.isArray(link)) {
         throw new Error('Unexpected array');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-f524690b",
+  "version": "0.0.0-main-38d73d29",
   "description": "Use Isograph with React",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,8 +15,8 @@
     "prepack": "yarn run test && yarn run compile"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-f524690b",
-    "@isograph/react-disposable-state": "0.0.0-main-f524690b",
+    "@isograph/disposable-types": "0.0.0-main-38d73d29",
+    "@isograph/react-disposable-state": "0.0.0-main-38d73d29",
     "react": "^18.2.0"
   },
   "devDependencies": {