@isograph/react 0.0.0-main-0e6e4170 → 0.0.0-main-7faadacd

package/.turbo/turbo-compile-typescript.log

@@ -1,4 +1,4 @@
 
-> @isograph/react@0.0.0-main-0e6e4170 compile-typescript /Users/runner/work/isograph/isograph/libs/isograph-react
+> @isograph/react@0.0.0-main-7faadacd compile-typescript /Users/runner/work/isograph/isograph/libs/isograph-react
 > rm -rf dist/* && tsc -p tsconfig.pkg.json
 

package/dist/core/read.d.ts

@@ -1,24 +1,30 @@
 import { type EncounteredIds } from './cache';
-import { ExtractData, FragmentReference, type UnknownTReadFromStore } from './FragmentReference';
-import { IsographEnvironment, type Link } from './IsographEnvironment';
+import { RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
+import { ExtractData, FragmentReference, Variables, type UnknownTReadFromStore } from './FragmentReference';
+import { IsographEnvironment, type DataTypeValue, type Link, type StoreRecord } from './IsographEnvironment';
+import { PromiseWrapper } from './PromiseWrapper';
+import { ReaderAst, type ReaderImperativelyLoadedField, type ReaderLinkedField, type ReaderScalarField } from './reader';
 export type WithEncounteredRecords<T> = {
     readonly encounteredRecords: EncounteredIds;
     readonly item: ExtractData<T>;
 };
 export declare function readButDoNotEvaluate<TReadFromStore extends UnknownTReadFromStore>(environment: IsographEnvironment, fragmentReference: FragmentReference<TReadFromStore, unknown>, networkRequestOptions: NetworkRequestReaderOptions): WithEncounteredRecords<TReadFromStore>;
-export type ReadDataResult<TReadFromStore> = {
+export type ReadDataResultSuccess<Data> = {
     readonly kind: 'Success';
-    readonly data: ExtractData<TReadFromStore>;
-    readonly encounteredRecords: EncounteredIds;
-} | {
+    readonly data: Data;
+};
+export type ReadDataResult<Data> = ReadDataResultSuccess<Data> | {
     readonly kind: 'MissingData';
     readonly reason: string;
     readonly nestedReason?: ReadDataResult<unknown>;
     readonly recordLink: Link;
 };
+export declare function readScalarFieldData(field: ReaderScalarField, storeRecord: StoreRecord, root: Link, variables: Variables): ReadDataResult<string | number | boolean | Link | DataTypeValue[] | null>;
+export declare function readLinkedFieldData(environment: IsographEnvironment, field: ReaderLinkedField, storeRecord: StoreRecord, root: Link, variables: Variables, networkRequest: PromiseWrapper<void, any>, readData: <TReadFromStore>(ast: ReaderAst<TReadFromStore>, root: Link) => ReadDataResult<object>): ReadDataResult<unknown>;
 export type NetworkRequestReaderOptions = {
     suspendIfInFlight: boolean;
     throwOnNetworkError: boolean;
 };
 export declare function getNetworkRequestOptionsWithDefaults(networkRequestOptions?: Partial<NetworkRequestReaderOptions> | void): NetworkRequestReaderOptions;
+export declare function readImperativelyLoadedField(environment: IsographEnvironment, field: ReaderImperativelyLoadedField, root: Link, variables: Variables, nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[], networkRequest: PromiseWrapper<void, any>, networkRequestOptions: NetworkRequestReaderOptions, mutableEncounteredRecords: EncounteredIds): ReadDataResult<unknown>;
 //# sourceMappingURL=read.d.ts.map

package/dist/core/read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/core/read.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,SAAS,CAAC;AAQjB,OAAO,EACL,WAAW,EAEX,iBAAiB,EAEjB,KAAK,qBAAqB,EAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,mBAAmB,EACnB,KAAK,IAAI,EACV,MAAM,uBAAuB,CAAC;AAe/B,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAAI;IACtC,QAAQ,CAAC,kBAAkB,EAAE,cAAc,CAAC;IAC5C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;CAC/B,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,cAAc,SAAS,qBAAqB,EAE5C,WAAW,EAAE,mBAAmB,EAChC,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,OAAO,CAAC,EAC7D,qBAAqB,EAAE,2BAA2B,GACjD,sBAAsB,CAAC,cAAc,CAAC,CAiExC;AAED,MAAM,MAAM,cAAc,CAAC,cAAc,IACrC;IACE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC;IAC3C,QAAQ,CAAC,kBAAkB,EAAE,cAAc,CAAC;CAC7C,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;IAChD,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;CAC3B,CAAC;AAwoBN,MAAM,MAAM,2BAA2B,GAAG;IACxC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AAEF,wBAAgB,oCAAoC,CAClD,qBAAqB,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,GAAG,IAAI,GAClE,2BAA2B,CAK7B"}
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/core/read.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAEL,wCAAwC,EAEzC,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,SAAS,EACT,KAAK,qBAAqB,EAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,mBAAmB,EACnB,KAAK,aAAa,EAClB,KAAK,IAAI,EACT,KAAK,WAAW,EACjB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAEL,cAAc,EAKf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,SAAS,EACT,KAAK,6BAA6B,EAClC,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACvB,MAAM,UAAU,CAAC;AAIlB,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAAI;IACtC,QAAQ,CAAC,kBAAkB,EAAE,cAAc,CAAC;IAC5C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;CAC/B,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,cAAc,SAAS,qBAAqB,EAE5C,WAAW,EAAE,mBAAmB,EAChC,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,OAAO,CAAC,EAC7D,qBAAqB,EAAE,2BAA2B,GACjD,sBAAsB,CAAC,cAAc,CAAC,CAiExC;AAED,MAAM,MAAM,qBAAqB,CAAC,IAAI,IAAI;IACxC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,IAAI,IAC3B,qBAAqB,CAAC,IAAI,CAAC,GAC3B;IACE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;IAChD,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;CAC3B,CAAC;AAubN,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,iBAAiB,EACxB,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,SAAS,GACnB,cAAc,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,aAAa,EAAE,GAAG,IAAI,CAAC,CAa3E;AAED,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,mBAAmB,EAChC,KAAK,EAAE,iBAAiB,EACxB,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,EAEzC,QAAQ,EAAE,CAAC,cAAc,EACvB,GAAG,EAAE,SAAS,CAAC,cAAc,CAAC,EAC9B,IAAI,EAAE,IAAI,KACP,cAAc,CAAC,MAAM,CAAC,GAC1B,cAAc,CAAC,OAAO,CAAC,CA6JzB;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AAEF,wBAAgB,oCAAoC,CAClD,qBAAqB,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,GAAG,IAAI,GAClE,2BAA2B,CAK7B;AAiBD,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,mBAAmB,EAChC,KAAK,EAAE,6BAA6B,EACpC,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,SAAS,EACpB,oBAAoB,EAAE,wCAAwC,EAAE,EAChE,cAAc,EAAE,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,EACzC,qBAAqB,EAAE,2BAA2B,EAClD,yBAAyB,EAAE,cAAc,GACxC,cAAc,CAAC,OAAO,CAAC,CAuDzB"}

package/dist/core/read.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readButDoNotEvaluate = readButDoNotEvaluate;
+exports.readScalarFieldData = readScalarFieldData;
+exports.readLinkedFieldData = readLinkedFieldData;
 exports.getNetworkRequestOptionsWithDefaults = getNetworkRequestOptionsWithDefaults;
+exports.readImperativelyLoadedField = readImperativelyLoadedField;
 const cache_1 = require("./cache");
 const componentCache_1 = require("./componentCache");
 const IsographEnvironment_1 = require("./IsographEnvironment");
@@ -56,7 +59,7 @@ function readButDoNotEvaluate(environment, fragmentReference, networkRequestOpti
     }
 }
 function readData(environment, ast, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c;
     const encounteredIds = (0, cache_1.insertIfNotExists)(mutableEncounteredRecords, root.__typename);
     encounteredIds.add(root.__link);
     let storeRecord = (_a = environment.store[root.__typename]) === null || _a === void 0 ? void 0 : _a[root.__link];
@@ -71,25 +74,17 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, netwo
         return {
             kind: 'Success',
             data: null,
-            encounteredRecords: mutableEncounteredRecords,
         };
     }
     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.__link,
-                        recordLink: root,
-                    };
+                const data = readScalarFieldData(field, storeRecord, root, variables);
+                if (data.kind === 'MissingData') {
+                    return data;
                 }
-                target[(_b = field.alias) !== null && _b !== void 0 ? _b : field.fieldName] = value;
+                target[(_b = field.alias) !== null && _b !== void 0 ? _b : field.fieldName] = data.data;
                 break;
             }
             case 'Link': {
@@ -97,176 +92,19 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, netwo
                 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, IsographEnvironment_1.assertLink)(item);
-                        if (link === undefined) {
-                            return {
-                                kind: 'MissingData',
-                                reason: 'No link for ' +
-                                    storeRecordName +
-                                    ' on root ' +
-                                    root.__link +
-                                    '. Link is ' +
-                                    JSON.stringify(item),
-                                recordLink: root,
-                            };
-                        }
-                        else if (link === null) {
-                            results.push(null);
-                            continue;
-                        }
-                        const result = readData(environment, field.selections, link, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
-                        if (result.kind === 'MissingData') {
-                            return {
-                                kind: 'MissingData',
-                                reason: 'Missing data for ' +
-                                    storeRecordName +
-                                    ' on root ' +
-                                    root.__link +
-                                    '. Link is ' +
-                                    JSON.stringify(item),
-                                nestedReason: result,
-                                recordLink: result.recordLink,
-                            };
-                        }
-                        results.push(result.data);
-                    }
-                    target[(_c = field.alias) !== null && _c !== void 0 ? _c : field.fieldName] = results;
-                    break;
-                }
-                let link = (0, IsographEnvironment_1.assertLink)(value);
-                if (field.condition) {
-                    const data = readData(environment, field.condition.readerAst, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
-                    if (data.kind === 'MissingData') {
-                        return {
-                            kind: 'MissingData',
-                            reason: 'Missing data for ' +
-                                storeRecordName +
-                                ' on root ' +
-                                root.__link,
-                            nestedReason: data,
-                            recordLink: data.recordLink,
-                        };
-                    }
-                    const readerWithRefetchQueries = {
-                        kind: 'ReaderWithRefetchQueries',
-                        readerArtifact: field.condition,
-                        // TODO this is wrong
-                        // should map field.condition.usedRefetchQueries
-                        // but it doesn't exist
-                        nestedRefetchQueries: [],
-                    };
-                    const fragment = {
-                        kind: 'FragmentReference',
-                        readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)(readerWithRefetchQueries),
-                        root,
-                        variables: generateChildVariableMap(variables, 
-                        // TODO this is wrong
-                        // should use field.condition.variables
-                        // but it doesn't exist
-                        []),
-                        networkRequest,
-                    };
-                    const condition = field.condition.resolver(Object.assign({ data: data.data, parameters: {} }, (field.condition.hasUpdatable
-                        ? {
-                            startUpdate: (0, startUpdate_1.getOrCreateCachedStartUpdate)(environment, fragment, readerWithRefetchQueries.readerArtifact.fieldName),
-                        }
-                        : undefined)));
-                    if (condition === true) {
-                        link = root;
-                    }
-                    else if (condition === false) {
-                        link = null;
-                    }
-                    else {
-                        link = condition;
-                    }
-                }
-                if (link === undefined) {
-                    // TODO make this configurable, and also generated and derived from the schema
-                    const missingFieldHandler = environment.missingFieldHandler;
-                    const altLink = missingFieldHandler === null || missingFieldHandler === void 0 ? void 0 : missingFieldHandler(storeRecord, root, field.fieldName, field.arguments, variables);
-                    (0, logging_1.logMessage)(environment, {
-                        kind: 'MissingFieldHandlerCalled',
-                        root,
-                        storeRecord,
-                        fieldName: field.fieldName,
-                        arguments: field.arguments,
-                        variables,
-                    });
-                    if (altLink === undefined) {
-                        return {
-                            kind: 'MissingData',
-                            reason: 'No link for ' +
-                                storeRecordName +
-                                ' on root ' +
-                                root.__link +
-                                '. Link is ' +
-                                JSON.stringify(value),
-                            recordLink: root,
-                        };
-                    }
-                    else {
-                        link = altLink;
-                    }
-                }
-                else if (link === null) {
-                    target[(_d = field.alias) !== null && _d !== void 0 ? _d : field.fieldName] = null;
-                    break;
-                }
-                const targetId = link;
-                const data = readData(environment, field.selections, targetId, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
+                const data = readLinkedFieldData(environment, field, storeRecord, root, variables, networkRequest, (ast, root) => readData(environment, ast, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords));
                 if (data.kind === 'MissingData') {
-                    return {
-                        kind: 'MissingData',
-                        reason: 'Missing data for ' + storeRecordName + ' on root ' + root.__link,
-                        nestedReason: data,
-                        recordLink: data.recordLink,
-                    };
+                    return data;
                 }
-                target[(_e = field.alias) !== null && _e !== void 0 ? _e : field.fieldName] = data.data;
+                target[(_c = field.alias) !== null && _c !== void 0 ? _c : field.fieldName] = data.data;
                 break;
             }
             case 'ImperativelyLoadedField': {
-                // First, we read the data using the refetch reader AST (i.e. read out the
-                // id field).
-                const data = readData(environment, field.refetchReaderArtifact.readerAst, root, variables, 
-                // Refetch fields just read the id, and don't need refetch query artifacts
-                [], 
-                // This is probably indicative of the fact that we are doing redundant checks
-                // on the status of this network request...
-                networkRequest, networkRequestOptions, mutableEncounteredRecords);
+                const data = readImperativelyLoadedField(environment, field, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
                 if (data.kind === 'MissingData') {
-                    return {
-                        kind: 'MissingData',
-                        reason: 'Missing data for ' + field.alias + ' on root ' + root.__link,
-                        nestedReason: data,
-                        recordLink: data.recordLink,
-                    };
-                }
-                else {
-                    const refetchQueryIndex = field.refetchQuery;
-                    const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
-                    if (refetchQuery == null) {
-                        throw new Error('refetchQuery is null in RefetchField. This is indicative of a bug in Isograph.');
-                    }
-                    const refetchQueryArtifact = refetchQuery.artifact;
-                    const allowedVariables = refetchQuery.allowedVariables;
-                    // Second, we allow the user to call the resolver, which will ultimately
-                    // use the resolver reader AST to get the resolver parameters.
-                    target[field.alias] = (args) => [
-                        // Stable id
-                        root.__link + '__' + field.name,
-                        // Fetcher
-                        field.refetchReaderArtifact.resolver(environment, refetchQueryArtifact, data.data, filterVariables(Object.assign(Object.assign({}, args), variables), allowedVariables), root, 
-                        // TODO these params should be removed
-                        null, []),
-                    ];
+                    return data;
                 }
+                target[field.alias] = data.data;
                 break;
             }
             case 'Resolver': {
@@ -436,7 +274,6 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, netwo
     return {
         kind: 'Success',
         data: target,
-        encounteredRecords: mutableEncounteredRecords,
     };
 }
 function filterVariables(variables, allowedVariables) {
@@ -504,6 +341,155 @@ function writeQueryArgsToVariables(targetVariables, queryArgs, variables) {
         }
     }
 }
+function readScalarFieldData(field, storeRecord, root, variables) {
+    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.__link,
+            recordLink: root,
+        };
+    }
+    return { kind: 'Success', data: value };
+}
+function readLinkedFieldData(environment, field, storeRecord, root, variables, networkRequest, readData) {
+    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, IsographEnvironment_1.assertLink)(item);
+            if (link === undefined) {
+                return {
+                    kind: 'MissingData',
+                    reason: 'No link for ' +
+                        storeRecordName +
+                        ' on root ' +
+                        root.__link +
+                        '. Link is ' +
+                        JSON.stringify(item),
+                    recordLink: root,
+                };
+            }
+            else if (link === null) {
+                results.push(null);
+                continue;
+            }
+            const result = readData(field.selections, link);
+            if (result.kind === 'MissingData') {
+                return {
+                    kind: 'MissingData',
+                    reason: 'Missing data for ' +
+                        storeRecordName +
+                        ' on root ' +
+                        root.__link +
+                        '. Link is ' +
+                        JSON.stringify(item),
+                    nestedReason: result,
+                    recordLink: result.recordLink,
+                };
+            }
+            results.push(result.data);
+        }
+        return {
+            kind: 'Success',
+            data: results,
+        };
+    }
+    let link = (0, IsographEnvironment_1.assertLink)(value);
+    if (field.condition) {
+        const data = readData(field.condition.readerAst, root);
+        if (data.kind === 'MissingData') {
+            return {
+                kind: 'MissingData',
+                reason: 'Missing data for ' + storeRecordName + ' on root ' + root.__link,
+                nestedReason: data,
+                recordLink: data.recordLink,
+            };
+        }
+        const readerWithRefetchQueries = {
+            kind: 'ReaderWithRefetchQueries',
+            readerArtifact: field.condition,
+            // TODO this is wrong
+            // should map field.condition.usedRefetchQueries
+            // but it doesn't exist
+            nestedRefetchQueries: [],
+        };
+        const fragment = {
+            kind: 'FragmentReference',
+            readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)(readerWithRefetchQueries),
+            root,
+            variables: generateChildVariableMap(variables, 
+            // TODO this is wrong
+            // should use field.condition.variables
+            // but it doesn't exist
+            []),
+            networkRequest,
+        };
+        const condition = field.condition.resolver(Object.assign({ data: data.data, parameters: {} }, (field.condition.hasUpdatable
+            ? {
+                startUpdate: (0, startUpdate_1.getOrCreateCachedStartUpdate)(environment, fragment, readerWithRefetchQueries.readerArtifact.fieldName),
+            }
+            : undefined)));
+        if (condition === true) {
+            link = root;
+        }
+        else if (condition === false) {
+            link = null;
+        }
+        else {
+            link = condition;
+        }
+    }
+    if (link === undefined) {
+        // TODO make this configurable, and also generated and derived from the schema
+        const missingFieldHandler = environment.missingFieldHandler;
+        const altLink = missingFieldHandler === null || missingFieldHandler === void 0 ? void 0 : missingFieldHandler(storeRecord, root, field.fieldName, field.arguments, variables);
+        (0, logging_1.logMessage)(environment, {
+            kind: 'MissingFieldHandlerCalled',
+            root,
+            storeRecord,
+            fieldName: field.fieldName,
+            arguments: field.arguments,
+            variables,
+        });
+        if (altLink === undefined) {
+            return {
+                kind: 'MissingData',
+                reason: 'No link for ' +
+                    storeRecordName +
+                    ' on root ' +
+                    root.__link +
+                    '. Link is ' +
+                    JSON.stringify(value),
+                recordLink: root,
+            };
+        }
+        else {
+            link = altLink;
+        }
+    }
+    else if (link === null) {
+        return {
+            kind: 'Success',
+            data: null,
+        };
+    }
+    const targetId = link;
+    const data = readData(field.selections, targetId);
+    if (data.kind === 'MissingData') {
+        return {
+            kind: 'MissingData',
+            reason: 'Missing data for ' + storeRecordName + ' on root ' + root.__link,
+            nestedReason: data,
+            recordLink: data.recordLink,
+        };
+    }
+    return data;
+}
 function getNetworkRequestOptionsWithDefaults(networkRequestOptions) {
     var _a, _b;
     return {
@@ -525,3 +511,43 @@ function stableStringifyArgs(args) {
     }
     return s;
 }
+function readImperativelyLoadedField(environment, field, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords) {
+    // First, we read the data using the refetch reader AST (i.e. read out the
+    // id field).
+    const data = readData(environment, field.refetchReaderArtifact.readerAst, root, variables, 
+    // Refetch fields just read the id, and don't need refetch query artifacts
+    [], 
+    // This is probably indicative of the fact that we are doing redundant checks
+    // on the status of this network request...
+    networkRequest, networkRequestOptions, mutableEncounteredRecords);
+    if (data.kind === 'MissingData') {
+        return {
+            kind: 'MissingData',
+            reason: 'Missing data for ' + field.alias + ' on root ' + root.__link,
+            nestedReason: data,
+            recordLink: data.recordLink,
+        };
+    }
+    else {
+        const refetchQueryIndex = field.refetchQuery;
+        const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
+        if (refetchQuery == null) {
+            throw new Error('refetchQuery is null in RefetchField. This is indicative of a bug in Isograph.');
+        }
+        const refetchQueryArtifact = refetchQuery.artifact;
+        const allowedVariables = refetchQuery.allowedVariables;
+        // Second, we allow the user to call the resolver, which will ultimately
+        // use the resolver reader AST to get the resolver parameters.
+        return {
+            kind: 'Success',
+            data: (args) => [
+                // Stable id
+                root.__link + '__' + field.name,
+                // Fetcher
+                field.refetchReaderArtifact.resolver(environment, refetchQueryArtifact, data.data, filterVariables(Object.assign(Object.assign({}, args), variables), allowedVariables), root, 
+                // TODO these params should be removed
+                null, []),
+            ],
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-0e6e4170",
+  "version": "0.0.0-main-7faadacd",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -20,9 +20,9 @@
     "iso-watch": "cross-env ../../target/debug/isograph_cli --config ./isograph.config.json --watch"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-0e6e4170",
-    "@isograph/react-disposable-state": "0.0.0-main-0e6e4170",
-    "@isograph/reference-counted-pointer": "0.0.0-main-0e6e4170"
+    "@isograph/disposable-types": "0.0.0-main-7faadacd",
+    "@isograph/react-disposable-state": "0.0.0-main-7faadacd",
+    "@isograph/reference-counted-pointer": "0.0.0-main-7faadacd"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"

package/src/core/read.ts

@@ -14,7 +14,6 @@ import {
 } from './entrypoint';
 import {
   ExtractData,
-  ExtractParameters,
   FragmentReference,
   Variables,
   type UnknownTReadFromStore,
@@ -23,7 +22,9 @@ import {
   assertLink,
   getOrLoadIsographArtifact,
   IsographEnvironment,
+  type DataTypeValue,
   type Link,
+  type StoreRecord,
 } from './IsographEnvironment';
 import { logMessage } from './logging';
 import { maybeMakeNetworkRequest } from './makeNetworkRequest';
@@ -35,7 +36,12 @@ import {
   wrapPromise,
   wrapResolvedValue,
 } from './PromiseWrapper';
-import { ReaderAst } from './reader';
+import {
+  ReaderAst,
+  type ReaderImperativelyLoadedField,
+  type ReaderLinkedField,
+  type ReaderScalarField,
+} from './reader';
 import { getOrCreateCachedStartUpdate } from './startUpdate';
 import { Arguments } from './util';
 
@@ -117,12 +123,13 @@ export function readButDoNotEvaluate<
   }
 }
 
-export type ReadDataResult<TReadFromStore> =
-  | {
-      readonly kind: 'Success';
-      readonly data: ExtractData<TReadFromStore>;
-      readonly encounteredRecords: EncounteredIds;
-    }
+export type ReadDataResultSuccess<Data> = {
+  readonly kind: 'Success';
+  readonly data: Data;
+};
+
+export type ReadDataResult<Data> =
+  | ReadDataResultSuccess<Data>
   | {
       readonly kind: 'MissingData';
       readonly reason: string;
@@ -134,12 +141,12 @@ function readData<TReadFromStore>(
   environment: IsographEnvironment,
   ast: ReaderAst<TReadFromStore>,
   root: Link,
-  variables: ExtractParameters<TReadFromStore>,
+  variables: Variables,
   nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   networkRequest: PromiseWrapper<void, any>,
   networkRequestOptions: NetworkRequestReaderOptions,
   mutableEncounteredRecords: EncounteredIds,
-): ReadDataResult<TReadFromStore> {
+): ReadDataResult<ExtractData<TReadFromStore>> {
   const encounteredIds = insertIfNotExists(
     mutableEncounteredRecords,
     root.__typename,
@@ -158,7 +165,6 @@ function readData<TReadFromStore>(
     return {
       kind: 'Success',
       data: null as any,
-      encounteredRecords: mutableEncounteredRecords,
     };
   }
 
@@ -167,19 +173,12 @@ function readData<TReadFromStore>(
   for (const field of ast) {
     switch (field.kind) {
       case 'Scalar': {
-        const storeRecordName = 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.__link,
-            recordLink: root,
-          };
+        const data = readScalarFieldData(field, storeRecord, root, variables);
+
+        if (data.kind === 'MissingData') {
+          return data;
         }
-        target[field.alias ?? field.fieldName] = value;
+        target[field.alias ?? field.fieldName] = data.data;
         break;
       }
       case 'Link': {
@@ -187,246 +186,46 @@ function readData<TReadFromStore>(
         break;
       }
       case 'Linked': {
-        const storeRecordName = 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 +
-                  '. Link is ' +
-                  JSON.stringify(item),
-                recordLink: root,
-              };
-            } else if (link === null) {
-              results.push(null);
-              continue;
-            }
-
-            const result = readData(
+        const data = readLinkedFieldData(
+          environment,
+          field,
+          storeRecord,
+          root,
+          variables,
+          networkRequest,
+          (ast, root) =>
+            readData(
               environment,
-              field.selections,
-              link,
+              ast,
+              root,
               variables,
               nestedRefetchQueries,
               networkRequest,
               networkRequestOptions,
               mutableEncounteredRecords,
-            );
-            if (result.kind === 'MissingData') {
-              return {
-                kind: 'MissingData',
-                reason:
-                  'Missing data for ' +
-                  storeRecordName +
-                  ' on root ' +
-                  root.__link +
-                  '. Link is ' +
-                  JSON.stringify(item),
-                nestedReason: result,
-                recordLink: result.recordLink,
-              };
-            }
-            results.push(result.data);
-          }
-          target[field.alias ?? field.fieldName] = results;
-          break;
-        }
-        let link = assertLink(value);
-
-        if (field.condition) {
-          const data = readData(
-            environment,
-            field.condition.readerAst,
-            root,
-            variables,
-            nestedRefetchQueries,
-            networkRequest,
-            networkRequestOptions,
-            mutableEncounteredRecords,
-          );
-          if (data.kind === 'MissingData') {
-            return {
-              kind: 'MissingData',
-              reason:
-                'Missing data for ' +
-                storeRecordName +
-                ' on root ' +
-                root.__link,
-              nestedReason: data,
-              recordLink: data.recordLink,
-            };
-          }
-
-          const readerWithRefetchQueries = {
-            kind: 'ReaderWithRefetchQueries',
-            readerArtifact: field.condition,
-            // TODO this is wrong
-            // should map field.condition.usedRefetchQueries
-            // but it doesn't exist
-            nestedRefetchQueries: [],
-          } satisfies ReaderWithRefetchQueries<any, any>;
-
-          const fragment = {
-            kind: 'FragmentReference',
-            readerWithRefetchQueries: wrapResolvedValue(
-              readerWithRefetchQueries,
             ),
-            root,
-            variables: generateChildVariableMap(
-              variables,
-              // TODO this is wrong
-              // should use field.condition.variables
-              // but it doesn't exist
-              [],
-            ),
-            networkRequest,
-          } satisfies FragmentReference<any, any>;
-
-          const condition = field.condition.resolver({
-            data: data.data,
-            parameters: {},
-            ...(field.condition.hasUpdatable
-              ? {
-                  startUpdate: getOrCreateCachedStartUpdate(
-                    environment,
-                    fragment,
-                    readerWithRefetchQueries.readerArtifact.fieldName,
-                  ),
-                }
-              : undefined),
-          });
-          if (condition === true) {
-            link = root;
-          } else if (condition === false) {
-            link = null;
-          } else {
-            link = condition;
-          }
-        }
-
-        if (link === undefined) {
-          // TODO make this configurable, and also generated and derived from the schema
-          const missingFieldHandler = environment.missingFieldHandler;
-
-          const altLink = missingFieldHandler?.(
-            storeRecord,
-            root,
-            field.fieldName,
-            field.arguments,
-            variables,
-          );
-          logMessage(environment, {
-            kind: 'MissingFieldHandlerCalled',
-            root,
-            storeRecord,
-            fieldName: field.fieldName,
-            arguments: field.arguments,
-            variables,
-          });
-
-          if (altLink === undefined) {
-            return {
-              kind: 'MissingData',
-              reason:
-                'No link for ' +
-                storeRecordName +
-                ' on root ' +
-                root.__link +
-                '. Link is ' +
-                JSON.stringify(value),
-              recordLink: root,
-            };
-          } else {
-            link = altLink;
-          }
-        } else if (link === null) {
-          target[field.alias ?? field.fieldName] = null;
-          break;
-        }
-        const targetId = link;
-        const data = readData(
-          environment,
-          field.selections,
-          targetId,
-          variables,
-          nestedRefetchQueries,
-          networkRequest,
-          networkRequestOptions,
-          mutableEncounteredRecords,
         );
         if (data.kind === 'MissingData') {
-          return {
-            kind: 'MissingData',
-            reason:
-              'Missing data for ' + storeRecordName + ' on root ' + root.__link,
-            nestedReason: data,
-            recordLink: data.recordLink,
-          };
+          return data;
         }
         target[field.alias ?? field.fieldName] = data.data;
         break;
       }
       case 'ImperativelyLoadedField': {
-        // First, we read the data using the refetch reader AST (i.e. read out the
-        // id field).
-        const data = readData(
+        const data = readImperativelyLoadedField(
           environment,
-          field.refetchReaderArtifact.readerAst,
+          field,
           root,
           variables,
-          // Refetch fields just read the id, and don't need refetch query artifacts
-          [],
-          // This is probably indicative of the fact that we are doing redundant checks
-          // on the status of this network request...
+          nestedRefetchQueries,
           networkRequest,
           networkRequestOptions,
           mutableEncounteredRecords,
         );
         if (data.kind === 'MissingData') {
-          return {
-            kind: 'MissingData',
-            reason:
-              'Missing data for ' + field.alias + ' on root ' + root.__link,
-            nestedReason: data,
-            recordLink: data.recordLink,
-          };
-        } else {
-          const refetchQueryIndex = field.refetchQuery;
-          const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
-          if (refetchQuery == null) {
-            throw new Error(
-              'refetchQuery is null in RefetchField. This is indicative of a bug in Isograph.',
-            );
-          }
-          const refetchQueryArtifact = refetchQuery.artifact;
-          const allowedVariables = refetchQuery.allowedVariables;
-
-          // Second, we allow the user to call the resolver, which will ultimately
-          // use the resolver reader AST to get the resolver parameters.
-          target[field.alias] = (args: any) => [
-            // Stable id
-            root.__link + '__' + field.name,
-            // Fetcher
-            field.refetchReaderArtifact.resolver(
-              environment,
-              refetchQueryArtifact,
-              data.data,
-              filterVariables({ ...args, ...variables }, allowedVariables),
-              root,
-              // TODO these params should be removed
-              null,
-              [],
-            ),
-          ];
+          return data;
         }
+        target[field.alias] = data.data;
         break;
       }
       case 'Resolver': {
@@ -690,7 +489,6 @@ function readData<TReadFromStore>(
   return {
     kind: 'Success',
     data: target as any,
-    encounteredRecords: mutableEncounteredRecords,
   };
 }
 
@@ -776,6 +574,197 @@ function writeQueryArgsToVariables(
   }
 }
 
+export function readScalarFieldData(
+  field: ReaderScalarField,
+  storeRecord: StoreRecord,
+  root: Link,
+  variables: Variables,
+): ReadDataResult<string | number | boolean | Link | DataTypeValue[] | null> {
+  const storeRecordName = 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.__link,
+      recordLink: root,
+    };
+  }
+  return { kind: 'Success', data: value };
+}
+
+export function readLinkedFieldData(
+  environment: IsographEnvironment,
+  field: ReaderLinkedField,
+  storeRecord: StoreRecord,
+  root: Link,
+  variables: Variables,
+  networkRequest: PromiseWrapper<void, any>,
+
+  readData: <TReadFromStore>(
+    ast: ReaderAst<TReadFromStore>,
+    root: Link,
+  ) => ReadDataResult<object>,
+): ReadDataResult<unknown> {
+  const storeRecordName = 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 +
+            '. Link is ' +
+            JSON.stringify(item),
+          recordLink: root,
+        };
+      } else if (link === null) {
+        results.push(null);
+        continue;
+      }
+
+      const result = readData(field.selections, link);
+      if (result.kind === 'MissingData') {
+        return {
+          kind: 'MissingData',
+          reason:
+            'Missing data for ' +
+            storeRecordName +
+            ' on root ' +
+            root.__link +
+            '. Link is ' +
+            JSON.stringify(item),
+          nestedReason: result,
+          recordLink: result.recordLink,
+        };
+      }
+      results.push(result.data);
+    }
+    return {
+      kind: 'Success',
+      data: results,
+    };
+  }
+  let link = assertLink(value);
+
+  if (field.condition) {
+    const data = readData(field.condition.readerAst, root);
+    if (data.kind === 'MissingData') {
+      return {
+        kind: 'MissingData',
+        reason:
+          'Missing data for ' + storeRecordName + ' on root ' + root.__link,
+        nestedReason: data,
+        recordLink: data.recordLink,
+      };
+    }
+
+    const readerWithRefetchQueries = {
+      kind: 'ReaderWithRefetchQueries',
+      readerArtifact: field.condition,
+      // TODO this is wrong
+      // should map field.condition.usedRefetchQueries
+      // but it doesn't exist
+      nestedRefetchQueries: [],
+    } satisfies ReaderWithRefetchQueries<any, any>;
+
+    const fragment = {
+      kind: 'FragmentReference',
+      readerWithRefetchQueries: wrapResolvedValue(readerWithRefetchQueries),
+      root,
+      variables: generateChildVariableMap(
+        variables,
+        // TODO this is wrong
+        // should use field.condition.variables
+        // but it doesn't exist
+        [],
+      ),
+      networkRequest,
+    } satisfies FragmentReference<any, any>;
+
+    const condition = field.condition.resolver({
+      data: data.data,
+      parameters: {},
+      ...(field.condition.hasUpdatable
+        ? {
+            startUpdate: getOrCreateCachedStartUpdate(
+              environment,
+              fragment,
+              readerWithRefetchQueries.readerArtifact.fieldName,
+            ),
+          }
+        : undefined),
+    });
+    if (condition === true) {
+      link = root;
+    } else if (condition === false) {
+      link = null;
+    } else {
+      link = condition;
+    }
+  }
+
+  if (link === undefined) {
+    // TODO make this configurable, and also generated and derived from the schema
+    const missingFieldHandler = environment.missingFieldHandler;
+
+    const altLink = missingFieldHandler?.(
+      storeRecord,
+      root,
+      field.fieldName,
+      field.arguments,
+      variables,
+    );
+    logMessage(environment, {
+      kind: 'MissingFieldHandlerCalled',
+      root,
+      storeRecord,
+      fieldName: field.fieldName,
+      arguments: field.arguments,
+      variables,
+    });
+
+    if (altLink === undefined) {
+      return {
+        kind: 'MissingData',
+        reason:
+          'No link for ' +
+          storeRecordName +
+          ' on root ' +
+          root.__link +
+          '. Link is ' +
+          JSON.stringify(value),
+        recordLink: root,
+      };
+    } else {
+      link = altLink;
+    }
+  } else if (link === null) {
+    return {
+      kind: 'Success',
+      data: null,
+    };
+  }
+  const targetId = link;
+  const data = readData(field.selections, targetId);
+  if (data.kind === 'MissingData') {
+    return {
+      kind: 'MissingData',
+      reason: 'Missing data for ' + storeRecordName + ' on root ' + root.__link,
+      nestedReason: data,
+      recordLink: data.recordLink,
+    };
+  }
+  return data;
+}
+
 export type NetworkRequestReaderOptions = {
   suspendIfInFlight: boolean;
   throwOnNetworkError: boolean;
@@ -804,3 +793,69 @@ function stableStringifyArgs(args: object) {
   }
   return s;
 }
+
+export function readImperativelyLoadedField(
+  environment: IsographEnvironment,
+  field: ReaderImperativelyLoadedField,
+  root: Link,
+  variables: Variables,
+  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
+  networkRequest: PromiseWrapper<void, any>,
+  networkRequestOptions: NetworkRequestReaderOptions,
+  mutableEncounteredRecords: EncounteredIds,
+): ReadDataResult<unknown> {
+  // First, we read the data using the refetch reader AST (i.e. read out the
+  // id field).
+  const data = readData(
+    environment,
+    field.refetchReaderArtifact.readerAst,
+    root,
+    variables,
+    // Refetch fields just read the id, and don't need refetch query artifacts
+    [],
+    // This is probably indicative of the fact that we are doing redundant checks
+    // on the status of this network request...
+    networkRequest,
+    networkRequestOptions,
+    mutableEncounteredRecords,
+  );
+  if (data.kind === 'MissingData') {
+    return {
+      kind: 'MissingData',
+      reason: 'Missing data for ' + field.alias + ' on root ' + root.__link,
+      nestedReason: data,
+      recordLink: data.recordLink,
+    };
+  } else {
+    const refetchQueryIndex = field.refetchQuery;
+    const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
+    if (refetchQuery == null) {
+      throw new Error(
+        'refetchQuery is null in RefetchField. This is indicative of a bug in Isograph.',
+      );
+    }
+    const refetchQueryArtifact = refetchQuery.artifact;
+    const allowedVariables = refetchQuery.allowedVariables;
+
+    // Second, we allow the user to call the resolver, which will ultimately
+    // use the resolver reader AST to get the resolver parameters.
+    return {
+      kind: 'Success',
+      data: (args: any) => [
+        // Stable id
+        root.__link + '__' + field.name,
+        // Fetcher
+        field.refetchReaderArtifact.resolver(
+          environment,
+          refetchQueryArtifact,
+          data.data,
+          filterVariables({ ...args, ...variables }, allowedVariables),
+          root,
+          // TODO these params should be removed
+          null,
+          [],
+        ),
+      ],
+    };
+  }
+}