@isograph/react 0.0.0-main-90264a00 → 0.0.0-main-0e7d8883

package/dist/FragmentReference.d.ts

@@ -0,0 +1,13 @@
+import { DataId } from './IsographEnvironment';
+import { RefetchQueryArtifactWrapper } from './entrypoint';
+import { ReaderArtifact } from './reader';
+export type Variable = any;
+export type FragmentReference<TReadFromStore extends Object, TResolverResult> = {
+    kind: 'FragmentReference';
+    readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
+    root: DataId;
+    variables: {
+        [index: string]: Variable;
+    } | null;
+    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+};

package/dist/FragmentReference.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { DataId, DataTypeValue, IsographEnvironment, Link } from './IsographEnvironment';
-import { ReaderArtifact } from './reader';
-import { IsographEntrypoint, RefetchQueryArtifactWrapper } from './entrypoint';
+import { DataTypeValue, Link } from './IsographEnvironment';
+import { IsographEntrypoint } from './entrypoint';
+import { FragmentReference, Variable } from './FragmentReference';
 export { retainQuery, unretainQuery, type RetainedQuery, garbageCollectEnvironment, } from './garbageCollection';
 export { type PromiseWrapper } from './PromiseWrapper';
 export { makeNetworkRequest, subscribe } from './cache';
@@ -10,6 +10,9 @@ export { useImperativeReference } from './useImperativeReference';
 export { EntrypointReader } from './EntrypointReader';
 export { type ReaderArtifact, ReaderAst, ReaderAstNode, ReaderLinkedField, ReaderMutationField, ReaderRefetchField, ReaderResolverField, ReaderResolverVariant, ReaderScalarField, } from './reader';
 export { NormalizationAst, NormalizationAstNode, NormalizationLinkedField, NormalizationScalarField, IsographEntrypoint, assertIsEntrypoint, RefetchQueryArtifact, RefetchQueryArtifactWrapper, } from './entrypoint';
+export { read, readButDoNotEvaluate } from './read';
+export { useResult } from './useResult';
+export { type FragmentReference } from './FragmentReference';
 export type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> = T extends (arg1: any, arg2: infer P) => any ? P : never;
 export type Arguments = Argument[];
 export type Argument = [ArgumentName, ArgumentValue];
@@ -21,16 +24,6 @@ export type ArgumentValue = {
     kind: 'Literal';
     value: any;
 };
-type Variable = any;
-export type FragmentReference<TReadFromStore extends Object, TResolverResult> = {
-    kind: 'FragmentReference';
-    readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
-    root: DataId;
-    variables: {
-        [index: string]: Variable;
-    } | null;
-    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
-};
 export type ExtractReadFromStore<Type> = Type extends IsographEntrypoint<infer X, any> ? X : never;
 export type ExtractResolverResult<Type> = Type extends IsographEntrypoint<any, infer X> ? X : never;
 export declare function useLazyReference<TEntrypoint>(entrypoint: TEntrypoint | ((_: any) => any), variables: {
@@ -38,10 +31,4 @@ export declare function useLazyReference<TEntrypoint>(entrypoint: TEntrypoint |
 }): {
     queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, ExtractResolverResult<TEntrypoint>>;
 };
-export declare function useResult<TReadFromStore extends Object, TResolverResult>(fragmentReference: FragmentReference<TReadFromStore, TResolverResult>): TResolverResult;
-export declare function read<TReadFromStore extends Object, TResolverResult>(environment: IsographEnvironment, fragmentReference: FragmentReference<TReadFromStore, TResolverResult>): TResolverResult;
-export declare function readButDoNotEvaluate<TReadFromStore extends Object>(environment: IsographEnvironment, reference: FragmentReference<TReadFromStore, unknown>): TReadFromStore;
 export declare function assertLink(link: DataTypeValue): Link | null;
-export type IsographComponentProps<TDataType, TOtherProps = Object> = {
-    data: TDataType;
-} & TOtherProps;

package/dist/index.js

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertLink = exports.readButDoNotEvaluate = exports.read = exports.useResult = exports.useLazyReference = exports.assertIsEntrypoint = exports.EntrypointReader = exports.useImperativeReference = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = exports.subscribe = exports.makeNetworkRequest = exports.garbageCollectEnvironment = exports.unretainQuery = exports.retainQuery = void 0;
+exports.assertLink = exports.useLazyReference = exports.useResult = exports.readButDoNotEvaluate = exports.read = exports.assertIsEntrypoint = exports.EntrypointReader = exports.useImperativeReference = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = exports.subscribe = exports.makeNetworkRequest = exports.garbageCollectEnvironment = exports.unretainQuery = exports.retainQuery = 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");
-const react_1 = require("react");
 const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
 const entrypoint_1 = require("./entrypoint");
 var garbageCollection_1 = require("./garbageCollection");
@@ -29,6 +27,11 @@ var EntrypointReader_1 = require("./EntrypointReader");
 Object.defineProperty(exports, "EntrypointReader", { enumerable: true, get: function () { return EntrypointReader_1.EntrypointReader; } });
 var entrypoint_2 = require("./entrypoint");
 Object.defineProperty(exports, "assertIsEntrypoint", { enumerable: true, get: function () { return entrypoint_2.assertIsEntrypoint; } });
+var read_1 = require("./read");
+Object.defineProperty(exports, "read", { enumerable: true, get: function () { return read_1.read; } });
+Object.defineProperty(exports, "readButDoNotEvaluate", { enumerable: true, get: function () { return read_1.readButDoNotEvaluate; } });
+var useResult_1 = require("./useResult");
+Object.defineProperty(exports, "useResult", { enumerable: true, get: function () { return useResult_1.useResult; } });
 // 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
@@ -51,237 +54,6 @@ function useLazyReference(entrypoint, variables) {
     };
 }
 exports.useLazyReference = useLazyReference;
-function useResult(fragmentReference) {
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    const [, setState] = (0, react_1.useState)();
-    (0, react_1.useEffect)(() => {
-        return (0, cache_1.subscribe)(environment, () => {
-            return setState({});
-        });
-    }, []);
-    return read(environment, fragmentReference);
-}
-exports.useResult = useResult;
-function read(environment, fragmentReference) {
-    var _a, _b;
-    const variant = fragmentReference.readerArtifact.variant;
-    if (variant.kind === 'Eager') {
-        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)(environment);
-        }
-        else {
-            // @ts-expect-error This not properly typed yet
-            return fragmentReference.readerArtifact.resolver(data.data);
-        }
-    }
-    else if (variant.kind === 'Component') {
-        // @ts-ignore
-        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(environment, reference) {
-    var _a;
-    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)(environment);
-    }
-    else {
-        return response.data;
-    }
-}
-exports.readButDoNotEvaluate = readButDoNotEvaluate;
-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 };
-    }
-    if (storeRecord === null) {
-        return { kind: 'Success', data: null };
-    }
-    let target = {};
-    for (const field of ast) {
-        switch (field.kind) {
-            case 'Scalar': {
-                const storeRecordName = (0, cache_1.getParentRecordKey)(field, variables);
-                const value = storeRecord[storeRecordName];
-                // TODO consider making scalars into discriminated unions. This probably has
-                // to happen for when we handle errors.
-                if (value === undefined) {
-                    return {
-                        kind: 'MissingData',
-                        reason: 'No value for ' + storeRecordName + ' on root ' + root,
-                    };
-                }
-                target[(_a = field.alias) !== null && _a !== void 0 ? _a : field.fieldName] = value;
-                break;
-            }
-            case 'Linked': {
-                const storeRecordName = (0, cache_1.getParentRecordKey)(field, variables);
-                const value = storeRecord[storeRecordName];
-                if (Array.isArray(value)) {
-                    const results = [];
-                    for (const item of value) {
-                        const link = assertLink(item);
-                        if (link === undefined) {
-                            return {
-                                kind: 'MissingData',
-                                reason: 'No link for ' +
-                                    storeRecordName +
-                                    ' on root ' +
-                                    root +
-                                    '. Link is ' +
-                                    JSON.stringify(item),
-                            };
-                        }
-                        else if (link === null) {
-                            results.push(null);
-                            continue;
-                        }
-                        const result = readData(environment, field.selections, link.__link, variables, nestedRefetchQueries);
-                        if (result.kind === 'MissingData') {
-                            return {
-                                kind: 'MissingData',
-                                reason: 'Missing data for ' +
-                                    storeRecordName +
-                                    ' on root ' +
-                                    root +
-                                    '. Link is ' +
-                                    JSON.stringify(item),
-                                nestedReason: result,
-                            };
-                        }
-                        results.push(result.data);
-                    }
-                    target[(_b = field.alias) !== null && _b !== void 0 ? _b : field.fieldName] = results;
-                    break;
-                }
-                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 : IsographEnvironment_1.defaultMissingFieldHandler;
-                    const altLink = missingFieldHandler(storeRecord, root, field.fieldName, field.arguments, variables);
-                    if (altLink === undefined) {
-                        return {
-                            kind: 'MissingData',
-                            reason: 'No link for ' +
-                                storeRecordName +
-                                ' on root ' +
-                                root +
-                                '. Link is ' +
-                                JSON.stringify(value),
-                        };
-                    }
-                    else {
-                        link = altLink;
-                    }
-                }
-                else if (link === null) {
-                    target[(_d = field.alias) !== null && _d !== void 0 ? _d : field.fieldName] = null;
-                    break;
-                }
-                const targetId = link.__link;
-                const data = readData(environment, field.selections, targetId, variables, nestedRefetchQueries);
-                if (data.kind === 'MissingData') {
-                    return {
-                        kind: 'MissingData',
-                        reason: 'Missing data for ' + storeRecordName + ' on root ' + root,
-                        nestedReason: data,
-                    };
-                }
-                target[(_e = field.alias) !== null && _e !== void 0 ? _e : field.fieldName] = data.data;
-                break;
-            }
-            case 'RefetchField': {
-                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) {
-                    console.log('refetch field data', data, field);
-                }
-                if (data.kind === 'MissingData') {
-                    return {
-                        kind: 'MissingData',
-                        reason: 'Missing data for ' + field.alias + ' on root ' + root,
-                        nestedReason: data,
-                    };
-                }
-                else {
-                    const refetchQueryIndex = field.refetchQuery;
-                    if (refetchQueryIndex == null) {
-                        throw new Error('refetchQuery is null in RefetchField');
-                    }
-                    const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
-                    const refetchQueryArtifact = refetchQuery.artifact;
-                    const allowedVariables = refetchQuery.allowedVariables;
-                    target[field.alias] = field.readerArtifact.resolver(environment, 
-                    // resolvers for refetch fields take 3 args, and this is not reflected in types
-                    refetchQueryArtifact, Object.assign(Object.assign({}, data.data), filterVariables(variables, allowedVariables)));
-                }
-                break;
-            }
-            case 'MutationField': {
-                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) {
-                    console.log('refetch field data', data, field);
-                }
-                if (data.kind === 'MissingData') {
-                    return {
-                        kind: 'MissingData',
-                        reason: 'Missing data for ' + field.alias + ' on root ' + root,
-                        nestedReason: data,
-                    };
-                }
-                else {
-                    const refetchQueryIndex = field.refetchQuery;
-                    if (refetchQueryIndex == null) {
-                        throw new Error('refetchQuery is null in MutationField');
-                    }
-                    const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
-                    const refetchQueryArtifact = refetchQuery.artifact;
-                    const allowedVariables = refetchQuery.allowedVariables;
-                    target[field.alias] = field.readerArtifact.resolver(environment, refetchQueryArtifact, 
-                    // @ts-expect-error
-                    data.data, filterVariables(variables, allowedVariables));
-                }
-                break;
-            }
-            case 'Resolver': {
-                const usedRefetchQueries = field.usedRefetchQueries;
-                const resolverRefetchQueries = usedRefetchQueries.map((index) => nestedRefetchQueries[index]);
-                const variant = field.readerArtifact.variant;
-                if (variant.kind === 'Eager') {
-                    const data = readData(environment, field.readerArtifact.readerAst, root, variables, resolverRefetchQueries);
-                    if (data.kind === 'MissingData') {
-                        return {
-                            kind: 'MissingData',
-                            reason: 'Missing data for ' + field.alias + ' on root ' + root,
-                            nestedReason: data,
-                        };
-                    }
-                    else {
-                        // @ts-expect-error
-                        target[field.alias] = field.readerArtifact.resolver(data.data);
-                    }
-                }
-                else if (variant.kind === 'Component') {
-                    target[field.alias] = (0, componentCache_1.getOrCreateCachedComponent)(environment, root, variant.componentName, field.readerArtifact, variables, resolverRefetchQueries);
-                }
-                break;
-            }
-        }
-    }
-    return { kind: 'Success', data: target };
-}
 function assertLink(link) {
     if (Array.isArray(link)) {
         throw new Error('Unexpected array');
@@ -295,10 +67,3 @@ function assertLink(link) {
     throw new Error('Invalid link');
 }
 exports.assertLink = assertLink;
-function filterVariables(variables, allowedVariables) {
-    const result = {};
-    for (const key of allowedVariables) {
-        result[key] = variables[key];
-    }
-    return result;
-}

package/dist/read.d.ts

@@ -0,0 +1,4 @@
+import { FragmentReference } from './index';
+import { IsographEnvironment } from './IsographEnvironment';
+export declare function read<TReadFromStore extends Object, TResolverResult>(environment: IsographEnvironment, fragmentReference: FragmentReference<TReadFromStore, TResolverResult>): TResolverResult;
+export declare function readButDoNotEvaluate<TReadFromStore extends Object>(environment: IsographEnvironment, reference: FragmentReference<TReadFromStore, unknown>): TReadFromStore;

package/dist/read.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readButDoNotEvaluate = exports.read = void 0;
+const cache_1 = require("./cache");
+const componentCache_1 = require("./componentCache");
+const index_1 = require("./index");
+const IsographEnvironment_1 = require("./IsographEnvironment");
+function read(environment, fragmentReference) {
+    var _a, _b;
+    const variant = fragmentReference.readerArtifact.variant;
+    if (variant.kind === 'Eager') {
+        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)(environment);
+        }
+        else {
+            // @ts-expect-error This not properly typed yet
+            return fragmentReference.readerArtifact.resolver(data.data);
+        }
+    }
+    else if (variant.kind === 'Component') {
+        // @ts-ignore
+        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(environment, reference) {
+    var _a;
+    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)(environment);
+    }
+    else {
+        return response.data;
+    }
+}
+exports.readButDoNotEvaluate = readButDoNotEvaluate;
+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 };
+    }
+    if (storeRecord === null) {
+        return { kind: 'Success', data: null };
+    }
+    let target = {};
+    for (const field of ast) {
+        switch (field.kind) {
+            case 'Scalar': {
+                const storeRecordName = (0, cache_1.getParentRecordKey)(field, variables);
+                const value = storeRecord[storeRecordName];
+                // TODO consider making scalars into discriminated unions. This probably has
+                // to happen for when we handle errors.
+                if (value === undefined) {
+                    return {
+                        kind: 'MissingData',
+                        reason: 'No value for ' + storeRecordName + ' on root ' + root,
+                    };
+                }
+                target[(_a = field.alias) !== null && _a !== void 0 ? _a : field.fieldName] = value;
+                break;
+            }
+            case 'Linked': {
+                const storeRecordName = (0, cache_1.getParentRecordKey)(field, variables);
+                const value = storeRecord[storeRecordName];
+                if (Array.isArray(value)) {
+                    const results = [];
+                    for (const item of value) {
+                        const link = (0, index_1.assertLink)(item);
+                        if (link === undefined) {
+                            return {
+                                kind: 'MissingData',
+                                reason: 'No link for ' +
+                                    storeRecordName +
+                                    ' on root ' +
+                                    root +
+                                    '. Link is ' +
+                                    JSON.stringify(item),
+                            };
+                        }
+                        else if (link === null) {
+                            results.push(null);
+                            continue;
+                        }
+                        const result = readData(environment, field.selections, link.__link, variables, nestedRefetchQueries);
+                        if (result.kind === 'MissingData') {
+                            return {
+                                kind: 'MissingData',
+                                reason: 'Missing data for ' +
+                                    storeRecordName +
+                                    ' on root ' +
+                                    root +
+                                    '. Link is ' +
+                                    JSON.stringify(item),
+                                nestedReason: result,
+                            };
+                        }
+                        results.push(result.data);
+                    }
+                    target[(_b = field.alias) !== null && _b !== void 0 ? _b : field.fieldName] = results;
+                    break;
+                }
+                let link = (0, index_1.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 : IsographEnvironment_1.defaultMissingFieldHandler;
+                    const altLink = missingFieldHandler(storeRecord, root, field.fieldName, field.arguments, variables);
+                    if (altLink === undefined) {
+                        return {
+                            kind: 'MissingData',
+                            reason: 'No link for ' +
+                                storeRecordName +
+                                ' on root ' +
+                                root +
+                                '. Link is ' +
+                                JSON.stringify(value),
+                        };
+                    }
+                    else {
+                        link = altLink;
+                    }
+                }
+                else if (link === null) {
+                    target[(_d = field.alias) !== null && _d !== void 0 ? _d : field.fieldName] = null;
+                    break;
+                }
+                const targetId = link.__link;
+                const data = readData(environment, field.selections, targetId, variables, nestedRefetchQueries);
+                if (data.kind === 'MissingData') {
+                    return {
+                        kind: 'MissingData',
+                        reason: 'Missing data for ' + storeRecordName + ' on root ' + root,
+                        nestedReason: data,
+                    };
+                }
+                target[(_e = field.alias) !== null && _e !== void 0 ? _e : field.fieldName] = data.data;
+                break;
+            }
+            case 'RefetchField': {
+                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) {
+                    console.log('refetch field data', data, field);
+                }
+                if (data.kind === 'MissingData') {
+                    return {
+                        kind: 'MissingData',
+                        reason: 'Missing data for ' + field.alias + ' on root ' + root,
+                        nestedReason: data,
+                    };
+                }
+                else {
+                    const refetchQueryIndex = field.refetchQuery;
+                    if (refetchQueryIndex == null) {
+                        throw new Error('refetchQuery is null in RefetchField');
+                    }
+                    const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
+                    const refetchQueryArtifact = refetchQuery.artifact;
+                    const allowedVariables = refetchQuery.allowedVariables;
+                    target[field.alias] = field.readerArtifact.resolver(environment, 
+                    // resolvers for refetch fields take 3 args, and this is not reflected in types
+                    refetchQueryArtifact, Object.assign(Object.assign({}, data.data), filterVariables(variables, allowedVariables)));
+                }
+                break;
+            }
+            case 'MutationField': {
+                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) {
+                    console.log('refetch field data', data, field);
+                }
+                if (data.kind === 'MissingData') {
+                    return {
+                        kind: 'MissingData',
+                        reason: 'Missing data for ' + field.alias + ' on root ' + root,
+                        nestedReason: data,
+                    };
+                }
+                else {
+                    const refetchQueryIndex = field.refetchQuery;
+                    if (refetchQueryIndex == null) {
+                        throw new Error('refetchQuery is null in MutationField');
+                    }
+                    const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
+                    const refetchQueryArtifact = refetchQuery.artifact;
+                    const allowedVariables = refetchQuery.allowedVariables;
+                    target[field.alias] = field.readerArtifact.resolver(environment, refetchQueryArtifact, 
+                    // @ts-expect-error
+                    data.data, filterVariables(variables, allowedVariables));
+                }
+                break;
+            }
+            case 'Resolver': {
+                const usedRefetchQueries = field.usedRefetchQueries;
+                const resolverRefetchQueries = usedRefetchQueries.map((index) => nestedRefetchQueries[index]);
+                const variant = field.readerArtifact.variant;
+                if (variant.kind === 'Eager') {
+                    const data = readData(environment, field.readerArtifact.readerAst, root, variables, resolverRefetchQueries);
+                    if (data.kind === 'MissingData') {
+                        return {
+                            kind: 'MissingData',
+                            reason: 'Missing data for ' + field.alias + ' on root ' + root,
+                            nestedReason: data,
+                        };
+                    }
+                    else {
+                        // @ts-expect-error
+                        target[field.alias] = field.readerArtifact.resolver(data.data);
+                    }
+                }
+                else if (variant.kind === 'Component') {
+                    target[field.alias] = (0, componentCache_1.getOrCreateCachedComponent)(environment, root, variant.componentName, field.readerArtifact, variables, resolverRefetchQueries);
+                }
+                break;
+            }
+        }
+    }
+    return { kind: 'Success', data: target };
+}
+function filterVariables(variables, allowedVariables) {
+    const result = {};
+    for (const key of allowedVariables) {
+        result[key] = variables[key];
+    }
+    return result;
+}

package/dist/useResult.d.ts

@@ -0,0 +1,2 @@
+import { FragmentReference } from './index';
+export declare function useResult<TReadFromStore extends Object, TResolverResult>(fragmentReference: FragmentReference<TReadFromStore, TResolverResult>): TResolverResult;

package/dist/useResult.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useResult = void 0;
+const react_1 = require("react");
+const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
+const cache_1 = require("./cache");
+const read_1 = require("./read");
+function useResult(fragmentReference) {
+    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
+    const [, setState] = (0, react_1.useState)();
+    (0, react_1.useEffect)(() => {
+        return (0, cache_1.subscribe)(environment, () => {
+            return setState({});
+        });
+    }, []);
+    return (0, read_1.read)(environment, fragmentReference);
+}
+exports.useResult = useResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-90264a00",
+  "version": "0.0.0-main-0e7d8883",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -16,8 +16,8 @@
     "prepack": "yarn run test && yarn run compile"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-90264a00",
-    "@isograph/react-disposable-state": "0.0.0-main-90264a00",
+    "@isograph/disposable-types": "0.0.0-main-0e7d8883",
+    "@isograph/react-disposable-state": "0.0.0-main-0e7d8883",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/FragmentReference.ts

@@ -0,0 +1,18 @@
+import { DataId } from './IsographEnvironment';
+import { RefetchQueryArtifactWrapper } from './entrypoint';
+import { ReaderArtifact } from './reader';
+
+// TODO type this better
+export type Variable = any;
+
+export type FragmentReference<
+  TReadFromStore extends Object,
+  TResolverResult,
+> = {
+  kind: 'FragmentReference';
+  readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
+  root: DataId;
+  variables: { [index: string]: Variable } | null;
+  // TODO: We should instead have ReaderAst<TResolverProps>
+  nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+};