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

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 './context';
 declare global {
     interface Window {
         __LOG: boolean;
@@ -13,25 +14,8 @@ 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 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(callback: () => void): () => void;
 export declare function onNextChange(): Promise<void>;
 export declare function getParentRecordKey(astNode: NormalizationLinkedField | NormalizationScalarField | ReaderLinkedField | ReaderScalarField, variables: {

package/dist/cache.js

@@ -1,8 +1,9 @@
 "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 context_1 = require("./context");
 const cache = {};
 function getOrCreateCache(index, factory) {
     if (typeof window !== 'undefined' && window.__LOG) {
@@ -39,30 +40,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);
+    const factory = () => makeNetworkRequest(environment, artifact, variables);
     return getOrCreateCache(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,27 +69,13 @@ 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, context_1.ROOT_ID, variables, nestedRefetchQueries);
     if (typeof window !== 'undefined' && window.__LOG) {
-        console.log('after normalization', { store });
+        console.log('after normalization', { store: environment.store });
     }
     callSubscriptions();
 }
@@ -120,7 +100,7 @@ function callSubscriptions() {
 /**
  * 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 +108,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 +129,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 +145,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 { DataId, ReaderArtifact, RefetchQueryArtifactWrapper } from './index';
+import { IsographEnvironment } from '../dist';
+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

@@ -4,7 +4,7 @@ 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 stringifiedArgs = JSON.stringify((0, cache_1.stableCopy)(variables));
     cachedComponentsById[root] = (_a = cachedComponentsById[root]) !== null && _a !== void 0 ? _a : {};
@@ -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/context.d.ts

@@ -0,0 +1,34 @@
+import { ReactNode } from 'react';
+import * as React from 'react';
+export declare const IsographEnvironmentContext: React.Context<IsographEnvironment | null>;
+export type IsographEnvironment = {
+    store: IsographStore;
+    networkFunction: IsographNetworkFunction;
+    missingFieldHandler: MissingFieldHandler | null;
+};
+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;

package/dist/context.js

@@ -0,0 +1,48 @@
+"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.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)(() => 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;

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 './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';
 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,18 @@
 "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.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 context_1 = require("./context");
 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 context_2 = require("./context");
+Object.defineProperty(exports, "IsographEnvironmentContext", { enumerable: true, get: function () { return context_2.IsographEnvironmentContext; } });
+Object.defineProperty(exports, "ROOT_ID", { enumerable: true, get: function () { return context_2.ROOT_ID; } });
+Object.defineProperty(exports, "IsographEnvironmentProvider", { enumerable: true, get: function () { return context_2.IsographEnvironmentProvider; } });
+Object.defineProperty(exports, "useIsographEnvironment", { enumerable: true, get: function () { return context_2.useIsographEnvironment; } });
 var iso_1 = require("./iso");
 Object.defineProperty(exports, "iso", { enumerable: true, get: function () { return iso_1.iso; } });
 function assertIsEntrypoint(value) {
@@ -20,9 +24,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, context_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,18 +35,23 @@ function useLazyReference(entrypoint, variables) {
         queryReference: {
             kind: 'FragmentReference',
             readerArtifact: entrypoint.readerArtifact,
-            root: cache_1.ROOT_ID,
+            root: context_1.ROOT_ID,
             variables,
             nestedRefetchQueries: entrypoint.nestedRefetchQueries,
         },
     };
 }
 exports.useLazyReference = useLazyReference;
-function read(fragmentReference) {
+function useRead(fragmentReference) {
+    const environment = (0, context_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)();
         }
@@ -51,15 +61,15 @@ 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 });
     }
@@ -71,9 +81,9 @@ function readButDoNotEvaluate(reference) {
     }
 }
 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 +129,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 +150,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 +168,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 +180,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 +205,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 +231,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 +240,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 +253,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 +261,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 +272,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-f49c67bb",
   "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-f49c67bb",
+    "@isograph/react-disposable-state": "0.0.0-main-f49c67bb",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/{cache.ts → cache.tsx}

@@ -15,6 +15,13 @@ import {
   ReaderScalarField,
   RefetchQueryArtifactWrapper,
 } from './index';
+import {
+  DataId,
+  ROOT_ID,
+  StoreRecord,
+  Link,
+  type IsographEnvironment,
+} from './context';
 
 declare global {
   interface Window {
@@ -67,47 +74,39 @@ export function stableCopy<T>(value: T): T {
 type IsoResolver = IsographEntrypoint<any, any, any>;
 
 export function getOrCreateCacheForArtifact<T>(
+  environment: IsographEnvironment,
   artifact: IsographEntrypoint<any, any, T>,
   variables: object,
 ): ParentCache<PromiseWrapper<T>> {
   const cacheKey = artifact.queryText + JSON.stringify(stableCopy(variables));
   const factory: Factory<PromiseWrapper<T>> = () =>
-    makeNetworkRequest<T>(artifact, variables);
+    makeNetworkRequest<T>(environment, artifact, variables);
   return getOrCreateCache<PromiseWrapper<T>>(cacheKey, factory);
 }
 
-let network: ((queryText: string, variables: object) => Promise<any>) | null;
-
-// This is a hack until we store this in context somehow
-export function setNetwork(newNetwork: typeof network) {
-  network = newNetwork;
-}
-
 export function makeNetworkRequest<T>(
+  environment: IsographEnvironment,
   artifact: IsoResolver,
   variables: object,
 ): ItemCleanupPair<PromiseWrapper<T>> {
   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(
+        environment,
         artifact.normalizationAst,
         networkResponse.data,
         variables,
         artifact.nestedRefetchQueries,
       );
       return networkResponse.data;
-    },
-  );
+    });
 
   const wrapper = wrapPromise(promise);
 
@@ -120,48 +119,6 @@ export function makeNetworkRequest<T>(
   return response;
 }
 
-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.
-  | undefined
-  // Singular scalar fields:
-  | number
-  | boolean
-  | string
-  | null
-  // Singular linked fields:
-  | Link
-  // Plural scalar and linked fields:
-  | DataTypeValue[];
-
-export type StoreRecord = {
-  [index: DataId | string]: DataTypeValue;
-  // TODO __typename?: T, which is restricted to being a concrete string
-  // TODO this shouldn't always be named id
-  id?: DataId;
-};
-
-export type DataId = string;
-
-export const ROOT_ID: DataId & '__ROOT' = '__ROOT';
-let store: {
-  [index: DataId]: StoreRecord | null;
-  __ROOT: StoreRecord;
-} = {
-  __ROOT: {},
-};
-export function getStore() {
-  return store;
-}
-export function clearStore() {
-  store = {
-    __ROOT: {},
-  };
-}
-
 type NetworkResponseScalarValue = string | number | boolean;
 type NetworkResponseValue =
   | NetworkResponseScalarValue
@@ -177,6 +134,7 @@ type NetworkResponseObject = {
 };
 
 function normalizeData(
+  environment: IsographEnvironment,
   normalizationAst: NormalizationAst,
   networkResponse: NetworkResponseObject,
   variables: Object,
@@ -191,15 +149,16 @@ function normalizeData(
     );
   }
   normalizeDataIntoRecord(
+    environment,
     normalizationAst,
     networkResponse,
-    store.__ROOT,
+    environment.store.__ROOT,
     ROOT_ID,
     variables as any,
     nestedRefetchQueries,
   );
   if (typeof window !== 'undefined' && window.__LOG) {
-    console.log('after normalization', { store });
+    console.log('after normalization', { store: environment.store });
   }
   callSubscriptions();
 }
@@ -228,6 +187,7 @@ function callSubscriptions() {
  * Mutate targetParentRecord according to the normalizationAst and networkResponseParentRecord.
  */
 function normalizeDataIntoRecord(
+  environment: IsographEnvironment,
   normalizationAst: NormalizationAst,
   networkResponseParentRecord: NetworkResponseObject,
   targetParentRecord: StoreRecord,
@@ -248,6 +208,7 @@ function normalizeDataIntoRecord(
       }
       case 'Linked': {
         normalizeLinkedField(
+          environment,
           normalizationNode,
           networkResponseParentRecord,
           targetParentRecord,
@@ -285,6 +246,7 @@ function normalizeScalarField(
  * Mutate targetParentRecord with a given linked field ast node.
  */
 function normalizeLinkedField(
+  environment: IsographEnvironment,
   astNode: NormalizationLinkedField,
   networkResponseParentRecord: NetworkResponseObject,
   targetParentRecord: StoreRecord,
@@ -309,10 +271,11 @@ function normalizeLinkedField(
 
   if (Array.isArray(networkResponseData)) {
     // TODO check astNode.plural or the like
-    const dataIds = [];
+    const dataIds: Link[] = [];
     for (let i = 0; i < networkResponseData.length; i++) {
       const networkResponseObject = networkResponseData[i];
       const newStoreRecordId = normalizeNetworkResponseObject(
+        environment,
         astNode,
         networkResponseObject,
         targetParentRecordId,
@@ -325,6 +288,7 @@ function normalizeLinkedField(
     targetParentRecord[parentRecordKey] = dataIds;
   } else {
     const newStoreRecordId = normalizeNetworkResponseObject(
+      environment,
       astNode,
       networkResponseData,
       targetParentRecordId,
@@ -339,6 +303,7 @@ function normalizeLinkedField(
 }
 
 function normalizeNetworkResponseObject(
+  environment: IsographEnvironment,
   astNode: NormalizationLinkedField,
   networkResponseData: NetworkResponseObject,
   targetParentRecordId: string,
@@ -354,10 +319,11 @@ function normalizeNetworkResponseObject(
     index,
   );
 
-  const newStoreRecord = store[newStoreRecordId] ?? {};
-  store[newStoreRecordId] = newStoreRecord;
+  const newStoreRecord = environment.store[newStoreRecordId] ?? {};
+  environment.store[newStoreRecordId] = newStoreRecord;
 
   normalizeDataIntoRecord(
+    environment,
     astNode.selections,
     networkResponseData,
     newStoreRecord,

package/src/componentCache.ts

@@ -1,9 +1,11 @@
 import {
+  DataId,
   ReaderArtifact,
   RefetchQueryArtifactWrapper,
   readButDoNotEvaluate,
 } from './index';
-import { DataId, stableCopy } from './cache';
+import { stableCopy } from './cache';
+import { IsographEnvironment } from '../dist';
 
 type ComponentName = string;
 type StringifiedArgs = string;
@@ -13,6 +15,7 @@ const cachedComponentsById: {
   };
 } = {};
 export function getOrCreateCachedComponent(
+  environment: IsographEnvironment,
   root: DataId,
   componentName: string,
   readerArtifact: ReaderArtifact<any, any, any>,
@@ -28,7 +31,7 @@ export function getOrCreateCachedComponent(
     byArgs[stringifiedArgs] ??
     (() => {
       function Component(additionalRuntimeProps) {
-        const data = readButDoNotEvaluate({
+        const data = readButDoNotEvaluate(environment, {
           kind: 'FragmentReference',
           readerArtifact: readerArtifact,
           root,

package/src/context.tsx

@@ -0,0 +1,90 @@
+import { ReactNode, createContext, useContext } from 'react';
+import * as React from 'react';
+import { subscribe } from './cache';
+
+export const IsographEnvironmentContext =
+  createContext<IsographEnvironment | null>(null);
+
+export type IsographEnvironment = {
+  store: IsographStore;
+  networkFunction: IsographNetworkFunction;
+  missingFieldHandler: MissingFieldHandler | null;
+};
+
+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 =
+  // N.B. undefined is here to support optional id's, but
+  // undefined should not *actually* be present in the store.
+  | undefined
+  // Singular scalar fields:
+  | number
+  | boolean
+  | string
+  | null
+  // Singular linked fields:
+  | Link
+  // Plural scalar and linked fields:
+  | DataTypeValue[];
+
+export type StoreRecord = {
+  [index: DataId | string]: DataTypeValue;
+  // TODO __typename?: T, which is restricted to being a concrete string
+  // TODO this shouldn't always be named id
+  id?: DataId;
+};
+
+export type DataId = string;
+
+export const ROOT_ID: DataId & '__ROOT' = '__ROOT';
+
+export type IsographStore = {
+  [index: DataId]: StoreRecord | null;
+  __ROOT: StoreRecord;
+};
+
+export type IsographEnvironmentProviderProps = {
+  environment: IsographEnvironment;
+  children: ReactNode;
+};
+
+export function IsographEnvironmentProvider({
+  environment,
+  children,
+}: IsographEnvironmentProviderProps) {
+  const [, setState] = React.useState<object | void>();
+  React.useEffect(() => {
+    return subscribe(() => setState({}));
+  }, []);
+
+  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/index.tsx

@@ -1,27 +1,36 @@
 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';
 
@@ -177,7 +186,10 @@ function assertIsEntrypoint<
 >(
   value:
     | IsographEntrypoint<TReadFromStore, TResolverProps, TResolverResult>
-    | typeof iso,
+    | ((_: 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,
@@ -211,9 +223,11 @@ export function useLazyReference<TEntrypoint>(
     ExtractResolverResult<TEntrypoint>
   >;
 } {
+  const environment = useIsographEnvironment();
   assertIsEntrypoint(entrypoint);
   // Typechecking fails here... TODO investigate
   const cache = getOrCreateCacheForArtifact<ExtractResolverResult<TEntrypoint>>(
+    environment,
     entrypoint,
     variables,
   );
@@ -234,11 +248,27 @@ export function useLazyReference<TEntrypoint>(
   };
 }
 
+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,
@@ -248,6 +278,7 @@ export function read<
   const variant = fragmentReference.readerArtifact.variant;
   if (variant.kind === 'Eager') {
     const data = readData(
+      environment,
       fragmentReference.readerArtifact.readerAst,
       fragmentReference.root,
       fragmentReference.variables ?? {},
@@ -261,6 +292,7 @@ export function read<
   } else if (variant.kind === 'Component') {
     // @ts-ignore
     return getOrCreateCachedComponent(
+      environment,
       fragmentReference.root,
       variant.componentName,
       fragmentReference.readerArtifact,
@@ -273,9 +305,11 @@ export function read<
 }
 
 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 ?? {},
@@ -303,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 };
   }
@@ -358,6 +393,7 @@ function readData<TReadFromStore>(
               continue;
             }
             const result = readData(
+              environment,
               field.selections,
               link.__link,
               variables,
@@ -384,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,
@@ -411,6 +449,7 @@ function readData<TReadFromStore>(
         }
         const targetId = link.__link;
         const data = readData(
+          environment,
           field.selections,
           targetId,
           variables,
@@ -428,6 +467,7 @@ function readData<TReadFromStore>(
       }
       case 'RefetchField': {
         const data = readData(
+          environment,
           field.readerArtifact.readerAst,
           root,
           variables,
@@ -453,6 +493,7 @@ function readData<TReadFromStore>(
           const allowedVariables = refetchQuery.allowedVariables;
 
           target[field.alias] = field.readerArtifact.resolver(
+            environment,
             refetchQueryArtifact,
             {
               ...data.data,
@@ -466,6 +507,7 @@ function readData<TReadFromStore>(
       }
       case 'MutationField': {
         const data = readData(
+          environment,
           field.readerArtifact.readerAst,
           root,
           variables,
@@ -491,6 +533,7 @@ function readData<TReadFromStore>(
           const allowedVariables = refetchQuery.allowedVariables;
 
           target[field.alias] = field.readerArtifact.resolver(
+            environment,
             refetchQueryArtifact,
             data.data,
             filterVariables(variables, allowedVariables),
@@ -507,6 +550,7 @@ function readData<TReadFromStore>(
         const variant = field.readerArtifact.variant;
         if (variant.kind === 'Eager') {
           const data = readData(
+            environment,
             field.readerArtifact.readerAst,
             root,
             variables,
@@ -523,6 +567,7 @@ function readData<TReadFromStore>(
           }
         } else if (variant.kind === 'Component') {
           target[field.alias] = getOrCreateCachedComponent(
+            environment,
             root,
             variant.componentName,
             field.readerArtifact,
@@ -537,37 +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,
@@ -583,12 +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');