@isograph/react 0.0.0-main-dc9ca2f6 → 0.0.0-main-905800be

package/dist/IsographEnvironment.d.ts

@@ -1,8 +1,6 @@
-import { ReactNode } from 'react';
-import * as React from 'react';
+/// <reference types="react" />
 import { ParentCache } from '@isograph/isograph-react-disposable-state';
-import { NormalizationAst } from './index';
-export declare const IsographEnvironmentContext: React.Context<IsographEnvironment | null>;
+import { RetainedQuery } from './garbageCollection';
 type ComponentName = string;
 type StringifiedArgs = string;
 type ComponentCache = {
@@ -16,10 +14,6 @@ export type Subscriptions = Set<() => void>;
 type SuspenseCache = {
     [index: string]: ParentCache<any>;
 };
-export type RetainedQuery = {
-    normalizationAst: NormalizationAst;
-    variables: {};
-};
 export type IsographEnvironment = {
     store: IsographStore;
     networkFunction: IsographNetworkFunction;
@@ -51,18 +45,13 @@ export type IsographStore = {
     [index: DataId]: StoreRecord | null;
     __ROOT: StoreRecord;
 };
-export type IsographEnvironmentProviderProps = {
-    environment: IsographEnvironment;
-    children: ReactNode;
-};
-export declare function IsographEnvironmentProvider({ environment, children, }: IsographEnvironmentProviderProps): React.JSX.Element;
-export declare function useIsographEnvironment(): IsographEnvironment;
 export declare function createIsographEnvironment(store: IsographStore, networkFunction: IsographNetworkFunction, missingFieldHandler?: MissingFieldHandler): IsographEnvironment;
 export declare function createIsographStore(): {
     __ROOT: {};
 };
-export declare function garbageCollectEnvironment(environment: IsographEnvironment): void;
-type DidUnretainSomeQuery = boolean;
-export declare function unretainQuery(environment: IsographEnvironment, retainedQuery: RetainedQuery): DidUnretainSomeQuery;
-export declare function retainQuery(environment: IsographEnvironment, queryToRetain: RetainedQuery): void;
+export declare function defaultMissingFieldHandler(_storeRecord: StoreRecord, _root: DataId, fieldName: string, arguments_: {
+    [index: string]: any;
+} | null, variables: {
+    [index: string]: any;
+} | null): Link | undefined;
 export {};

package/dist/IsographEnvironment.js

@@ -1,47 +1,7 @@
 "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.retainQuery = exports.unretainQuery = exports.garbageCollectEnvironment = exports.createIsographStore = exports.createIsographEnvironment = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.ROOT_ID = exports.IsographEnvironmentContext = void 0;
-const react_1 = require("react");
-const React = __importStar(require("react"));
-const cache_1 = require("./cache");
-exports.IsographEnvironmentContext = (0, react_1.createContext)(null);
+exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = void 0;
 exports.ROOT_ID = '__ROOT';
-function IsographEnvironmentProvider({ environment, children, }) {
-    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;
 const DEFAULT_GC_BUFFER_SIZE = 10;
 function createIsographEnvironment(store, networkFunction, missingFieldHandler) {
     return {
@@ -63,82 +23,14 @@ function createIsographStore() {
     };
 }
 exports.createIsographStore = createIsographStore;
-function garbageCollectEnvironment(environment) {
-    const retainedIds = new Set([exports.ROOT_ID]);
-    for (const query of environment.retainedQueries) {
-        recordReachableIds(environment.store, query, retainedIds);
-    }
-    for (const query of environment.gcBuffer) {
-        recordReachableIds(environment.store, query, retainedIds);
-    }
-    for (const dataId in environment.store) {
-        if (!retainedIds.has(dataId)) {
-            delete environment.store[dataId];
-        }
-    }
-}
-exports.garbageCollectEnvironment = garbageCollectEnvironment;
-function recordReachableIds(store, retainedQuery, mutableRetainedIds) {
-    recordReachableIdsFromRecord(store, store[exports.ROOT_ID], mutableRetainedIds, retainedQuery.normalizationAst, retainedQuery.variables);
-}
-function getLinkedId(data) {
-    // @ts-expect-error
-    if (data.__link != null) {
-        // @ts-expect-error
-        return data.__link;
-    }
-    else {
-        throw new Error('Record in an invalid state');
-    }
-}
-function recordReachableIdsFromRecord(store, currentRecord, mutableRetainedIds, selections, variables) {
-    for (const selection of selections) {
-        switch (selection.kind) {
-            case 'Linked':
-                const linkKey = (0, cache_1.getParentRecordKey)(selection, variables !== null && variables !== void 0 ? variables : {});
-                const linkedFieldOrFields = currentRecord[linkKey];
-                const ids = [];
-                if (Array.isArray(linkedFieldOrFields)) {
-                    for (const link of linkedFieldOrFields) {
-                        if (link != null) {
-                            const id = getLinkedId(link);
-                            ids.push(id);
-                        }
-                    }
-                }
-                else {
-                    if (linkedFieldOrFields != null) {
-                        const id = getLinkedId(linkedFieldOrFields);
-                        ids.push(id);
-                    }
-                }
-                for (const nextRecordId of ids) {
-                    const nextRecord = store[nextRecordId];
-                    if (nextRecord != null) {
-                        mutableRetainedIds.add(nextRecordId);
-                        recordReachableIdsFromRecord(store, nextRecord, mutableRetainedIds, selection.selections, variables);
-                    }
-                }
-                continue;
-            case 'Scalar':
-                continue;
+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];
+        // TODO can we handle explicit nulls here too? Probably, after wrapping in objects
+        if (value != null) {
+            return { __link: value };
         }
     }
 }
-function unretainQuery(environment, retainedQuery) {
-    environment.retainedQueries.delete(retainedQuery);
-    environment.gcBuffer.push(retainedQuery);
-    if (environment.gcBuffer.length > environment.gcBufferSize) {
-        environment.gcBuffer.shift();
-        return true;
-    }
-    return false;
-}
-exports.unretainQuery = unretainQuery;
-function retainQuery(environment, queryToRetain) {
-    environment.retainedQueries.add(queryToRetain);
-    // TODO can we remove this query from the buffer somehow?
-    // We are relying on === equality, but we really should be comparing
-    // id + variables
-}
-exports.retainQuery = retainQuery;
+exports.defaultMissingFieldHandler = defaultMissingFieldHandler;

package/dist/IsographEnvironmentProvider.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+import { type IsographEnvironment } from './IsographEnvironment';
+export declare const IsographEnvironmentContext: React.Context<IsographEnvironment | null>;
+export type IsographEnvironmentProviderProps = {
+    environment: IsographEnvironment;
+    children: ReactNode;
+};
+export declare function IsographEnvironmentProvider({ environment, children, }: IsographEnvironmentProviderProps): React.JSX.Element;
+export declare function useIsographEnvironment(): IsographEnvironment;

package/dist/IsographEnvironmentProvider.js

@@ -0,0 +1,42 @@
+"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.IsographEnvironmentContext = void 0;
+const React = __importStar(require("react"));
+const react_1 = require("react");
+exports.IsographEnvironmentContext = (0, react_1.createContext)(null);
+function IsographEnvironmentProvider({ environment, children, }) {
+    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/cache.js

@@ -4,6 +4,7 @@ exports.SECOND_SPLIT_KEY = exports.FIRST_SPLIT_KEY = exports.getParentRecordKey
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
 const PromiseWrapper_1 = require("./PromiseWrapper");
 const IsographEnvironment_1 = require("./IsographEnvironment");
+const garbageCollection_1 = require("./garbageCollection");
 function getOrCreateCache(environment, index, factory) {
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('getting cache for', {
@@ -69,7 +70,7 @@ function makeNetworkRequest(environment, artifact, variables) {
                 kind: 'UndisposedComplete',
                 retainedQuery,
             };
-            (0, IsographEnvironment_1.retainQuery)(environment, retainedQuery);
+            (0, garbageCollection_1.retainQuery)(environment, retainedQuery);
         }
         // TODO return null
         return networkResponse;
@@ -79,9 +80,9 @@ function makeNetworkRequest(environment, artifact, variables) {
         wrapper,
         () => {
             if (status.kind === 'UndisposedComplete') {
-                const didUnretainSomeQuery = (0, IsographEnvironment_1.unretainQuery)(environment, status.retainedQuery);
+                const didUnretainSomeQuery = (0, garbageCollection_1.unretainQuery)(environment, status.retainedQuery);
                 if (didUnretainSomeQuery) {
-                    (0, IsographEnvironment_1.garbageCollectEnvironment)(environment);
+                    (0, garbageCollection_1.garbageCollectEnvironment)(environment);
                 }
             }
             status = {

package/dist/entrypoint.d.ts

@@ -0,0 +1,32 @@
+import { Arguments } from './index';
+import { ReaderArtifact } from './reader';
+export type IsographEntrypoint<TReadFromStore extends Object, TResolverResult> = {
+    kind: 'Entrypoint';
+    queryText: string;
+    normalizationAst: NormalizationAst;
+    readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
+    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+};
+export type NormalizationAstNode = NormalizationScalarField | NormalizationLinkedField;
+export type NormalizationAst = NormalizationAstNode[];
+export type NormalizationScalarField = {
+    kind: 'Scalar';
+    fieldName: string;
+    arguments: Arguments | null;
+};
+export type NormalizationLinkedField = {
+    kind: 'Linked';
+    fieldName: string;
+    arguments: Arguments | null;
+    selections: NormalizationAst;
+};
+export type RefetchQueryArtifact = {
+    kind: 'RefetchQuery';
+    queryText: string;
+    normalizationAst: NormalizationAst;
+};
+export type RefetchQueryArtifactWrapper = {
+    artifact: RefetchQueryArtifact;
+    allowedVariables: string[];
+};
+export declare function assertIsEntrypoint<TReadFromStore extends Object, TResolverResult>(value: IsographEntrypoint<TReadFromStore, TResolverResult> | ((_: any) => any) | any): asserts value is IsographEntrypoint<TReadFromStore, TResolverResult>;

package/dist/entrypoint.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsEntrypoint = void 0;
+function assertIsEntrypoint(value) {
+    if (typeof value === 'function')
+        throw new Error('Not a string');
+}
+exports.assertIsEntrypoint = assertIsEntrypoint;

package/dist/garbageCollection.d.ts

@@ -0,0 +1,11 @@
+import { IsographEnvironment } from './IsographEnvironment';
+import { NormalizationAst } from './index';
+export type RetainedQuery = {
+    normalizationAst: NormalizationAst;
+    variables: {};
+};
+type DidUnretainSomeQuery = boolean;
+export declare function unretainQuery(environment: IsographEnvironment, retainedQuery: RetainedQuery): DidUnretainSomeQuery;
+export declare function retainQuery(environment: IsographEnvironment, queryToRetain: RetainedQuery): void;
+export declare function garbageCollectEnvironment(environment: IsographEnvironment): void;
+export {};

package/dist/garbageCollection.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.garbageCollectEnvironment = exports.retainQuery = exports.unretainQuery = void 0;
+const IsographEnvironment_1 = require("./IsographEnvironment");
+const index_1 = require("./index");
+const cache_1 = require("./cache");
+function unretainQuery(environment, retainedQuery) {
+    environment.retainedQueries.delete(retainedQuery);
+    environment.gcBuffer.push(retainedQuery);
+    if (environment.gcBuffer.length > environment.gcBufferSize) {
+        environment.gcBuffer.shift();
+        return true;
+    }
+    return false;
+}
+exports.unretainQuery = unretainQuery;
+function retainQuery(environment, queryToRetain) {
+    environment.retainedQueries.add(queryToRetain);
+    // TODO can we remove this query from the buffer somehow?
+    // We are relying on === equality, but we really should be comparing
+    // id + variables
+}
+exports.retainQuery = retainQuery;
+function garbageCollectEnvironment(environment) {
+    const retainedIds = new Set([IsographEnvironment_1.ROOT_ID]);
+    for (const query of environment.retainedQueries) {
+        recordReachableIds(environment.store, query, retainedIds);
+    }
+    for (const query of environment.gcBuffer) {
+        recordReachableIds(environment.store, query, retainedIds);
+    }
+    for (const dataId in environment.store) {
+        if (!retainedIds.has(dataId)) {
+            delete environment.store[dataId];
+        }
+    }
+}
+exports.garbageCollectEnvironment = garbageCollectEnvironment;
+function recordReachableIds(store, retainedQuery, mutableRetainedIds) {
+    recordReachableIdsFromRecord(store, store[IsographEnvironment_1.ROOT_ID], mutableRetainedIds, retainedQuery.normalizationAst, retainedQuery.variables);
+}
+function recordReachableIdsFromRecord(store, currentRecord, mutableRetainedIds, selections, variables) {
+    for (const selection of selections) {
+        switch (selection.kind) {
+            case 'Linked':
+                const linkKey = (0, cache_1.getParentRecordKey)(selection, variables !== null && variables !== void 0 ? variables : {});
+                const linkedFieldOrFields = currentRecord[linkKey];
+                const ids = [];
+                if (Array.isArray(linkedFieldOrFields)) {
+                    for (const maybeLink of linkedFieldOrFields) {
+                        const link = (0, index_1.assertLink)(maybeLink);
+                        if (link != null) {
+                            ids.push(link.__link);
+                        }
+                    }
+                }
+                else {
+                    const link = (0, index_1.assertLink)(linkedFieldOrFields);
+                    if (link != null) {
+                        ids.push(link.__link);
+                    }
+                }
+                for (const nextRecordId of ids) {
+                    const nextRecord = store[nextRecordId];
+                    if (nextRecord != null) {
+                        mutableRetainedIds.add(nextRecordId);
+                        recordReachableIdsFromRecord(store, nextRecord, mutableRetainedIds, selection.selections, variables);
+                    }
+                }
+                continue;
+            case 'Scalar':
+                continue;
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,85 +1,16 @@
-import { DataId, IsographEnvironment, Link, StoreRecord } from './IsographEnvironment';
+import { DataId, DataTypeValue, IsographEnvironment, Link } from './IsographEnvironment';
+import { ReaderArtifact } from './reader';
+import { IsographEntrypoint, RefetchQueryArtifactWrapper } from './entrypoint';
+export { retainQuery, unretainQuery, type RetainedQuery, garbageCollectEnvironment, } from './garbageCollection';
 export { type PromiseWrapper } from './PromiseWrapper';
 export { makeNetworkRequest, subscribe } from './cache';
-export { IsographEnvironmentContext, ROOT_ID, type DataId, type DataTypeValue, type IsographEnvironment, IsographEnvironmentProvider, type IsographEnvironmentProviderProps, type IsographNetworkFunction, type IsographStore, type Link, type StoreRecord, useIsographEnvironment, createIsographEnvironment, createIsographStore, } from './IsographEnvironment';
+export { ROOT_ID, type DataId, type DataTypeValue, type IsographEnvironment, type IsographNetworkFunction, type IsographStore, type Link, type StoreRecord, createIsographEnvironment, createIsographStore, defaultMissingFieldHandler, } from './IsographEnvironment';
+export { IsographEnvironmentProvider, useIsographEnvironment, type IsographEnvironmentProviderProps, } from './IsographEnvironmentProvider';
 export { useImperativeReference } from './useImperativeReference';
 export { EntrypointReader } from './EntrypointReader';
-export type IsographEntrypoint<TReadFromStore extends Object, TResolverResult> = {
-    kind: 'Entrypoint';
-    queryText: string;
-    normalizationAst: NormalizationAst;
-    readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
-    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
-};
-export type ReaderArtifact<TReadFromStore extends Object, TResolverResult> = {
-    kind: 'ReaderArtifact';
-    readerAst: ReaderAst<TReadFromStore>;
-    resolver: (data: TReadFromStore, runtimeProps: any) => TResolverResult;
-    variant: ReaderResolverVariant;
-};
-export type ReaderAstNode = ReaderScalarField | ReaderLinkedField | ReaderResolverField | ReaderRefetchField | ReaderMutationField;
-export type ReaderAst<TReadFromStore> = ReaderAstNode[];
+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 type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> = T extends (arg1: any, arg2: infer P) => any ? P : never;
-export type ReaderScalarField = {
-    kind: 'Scalar';
-    fieldName: string;
-    alias: string | null;
-    arguments: Arguments | null;
-};
-export type ReaderLinkedField = {
-    kind: 'Linked';
-    fieldName: string;
-    alias: string | null;
-    selections: ReaderAst<unknown>;
-    arguments: Arguments | null;
-};
-export type ReaderResolverVariant = {
-    kind: 'Eager';
-} | {
-    kind: 'Component';
-    componentName: string;
-};
-export type ReaderResolverField = {
-    kind: 'Resolver';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    arguments: Arguments | null;
-    usedRefetchQueries: number[];
-};
-export type ReaderRefetchField = {
-    kind: 'RefetchField';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    refetchQuery: number;
-};
-export type ReaderMutationField = {
-    kind: 'MutationField';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    refetchQuery: number;
-};
-export type NormalizationAstNode = NormalizationScalarField | NormalizationLinkedField;
-export type NormalizationAst = NormalizationAstNode[];
-export type NormalizationScalarField = {
-    kind: 'Scalar';
-    fieldName: string;
-    arguments: Arguments | null;
-};
-export type NormalizationLinkedField = {
-    kind: 'Linked';
-    fieldName: string;
-    arguments: Arguments | null;
-    selections: NormalizationAst;
-};
-export type RefetchQueryArtifact = {
-    kind: 'RefetchQuery';
-    queryText: string;
-    normalizationAst: NormalizationAst;
-};
-export type RefetchQueryArtifactWrapper = {
-    artifact: RefetchQueryArtifact;
-    allowedVariables: string[];
-};
 export type Arguments = Argument[];
 export type Argument = [ArgumentName, ArgumentValue];
 export type ArgumentName = string;
@@ -110,11 +41,7 @@ export declare function useLazyReference<TEntrypoint>(entrypoint: 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 defaultMissingFieldHandler(_storeRecord: StoreRecord, _root: DataId, fieldName: string, arguments_: {
-    [index: string]: any;
-} | null, variables: {
-    [index: string]: any;
-} | null): Link | undefined;
+export declare function assertLink(link: DataTypeValue): Link | null;
 export type IsographComponentProps<TDataType, TOtherProps = Object> = {
     data: TDataType;
 } & TOtherProps;

package/dist/index.js

@@ -1,36 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultMissingFieldHandler = exports.readButDoNotEvaluate = exports.read = exports.useResult = exports.useLazyReference = exports.EntrypointReader = exports.useImperativeReference = exports.createIsographStore = exports.createIsographEnvironment = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.ROOT_ID = exports.IsographEnvironmentContext = exports.subscribe = exports.makeNetworkRequest = void 0;
+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;
 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");
+Object.defineProperty(exports, "retainQuery", { enumerable: true, get: function () { return garbageCollection_1.retainQuery; } });
+Object.defineProperty(exports, "unretainQuery", { enumerable: true, get: function () { return garbageCollection_1.unretainQuery; } });
+Object.defineProperty(exports, "garbageCollectEnvironment", { enumerable: true, get: function () { return garbageCollection_1.garbageCollectEnvironment; } });
 var cache_2 = require("./cache");
 Object.defineProperty(exports, "makeNetworkRequest", { enumerable: true, get: function () { return cache_2.makeNetworkRequest; } });
 Object.defineProperty(exports, "subscribe", { enumerable: true, get: function () { return cache_2.subscribe; } });
 var IsographEnvironment_2 = require("./IsographEnvironment");
-Object.defineProperty(exports, "IsographEnvironmentContext", { enumerable: true, get: function () { return IsographEnvironment_2.IsographEnvironmentContext; } });
 Object.defineProperty(exports, "ROOT_ID", { enumerable: true, get: function () { return IsographEnvironment_2.ROOT_ID; } });
-Object.defineProperty(exports, "IsographEnvironmentProvider", { enumerable: true, get: function () { return IsographEnvironment_2.IsographEnvironmentProvider; } });
-Object.defineProperty(exports, "useIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironment_2.useIsographEnvironment; } });
 Object.defineProperty(exports, "createIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironment_2.createIsographEnvironment; } });
 Object.defineProperty(exports, "createIsographStore", { enumerable: true, get: function () { return IsographEnvironment_2.createIsographStore; } });
+Object.defineProperty(exports, "defaultMissingFieldHandler", { enumerable: true, get: function () { return IsographEnvironment_2.defaultMissingFieldHandler; } });
+var IsographEnvironmentProvider_2 = require("./IsographEnvironmentProvider");
+Object.defineProperty(exports, "IsographEnvironmentProvider", { enumerable: true, get: function () { return IsographEnvironmentProvider_2.IsographEnvironmentProvider; } });
+Object.defineProperty(exports, "useIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironmentProvider_2.useIsographEnvironment; } });
 var useImperativeReference_1 = require("./useImperativeReference");
 Object.defineProperty(exports, "useImperativeReference", { enumerable: true, get: function () { return useImperativeReference_1.useImperativeReference; } });
 var EntrypointReader_1 = require("./EntrypointReader");
 Object.defineProperty(exports, "EntrypointReader", { enumerable: true, get: function () { return EntrypointReader_1.EntrypointReader; } });
-function assertIsEntrypoint(value) {
-    if (typeof value === 'function')
-        throw new Error('Not a string');
-}
+var entrypoint_2 = require("./entrypoint");
+Object.defineProperty(exports, "assertIsEntrypoint", { enumerable: true, get: function () { return entrypoint_2.assertIsEntrypoint; } });
 // 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
 // any actual Entrypoint we pass will not be valid.
 function useLazyReference(entrypoint, variables) {
-    const environment = (0, IsographEnvironment_1.useIsographEnvironment)();
-    assertIsEntrypoint(entrypoint);
+    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
+    (0, entrypoint_1.assertIsEntrypoint)(entrypoint);
     const cache = (0, cache_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables);
     // TODO add comment explaining why we never use this value
     // @ts-ignore
@@ -47,7 +52,7 @@ function useLazyReference(entrypoint, variables) {
 }
 exports.useLazyReference = useLazyReference;
 function useResult(fragmentReference) {
-    const environment = (0, IsographEnvironment_1.useIsographEnvironment)();
+    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
     const [, setState] = (0, react_1.useState)();
     (0, react_1.useEffect)(() => {
         return (0, cache_1.subscribe)(environment, () => {
@@ -161,7 +166,7 @@ function readData(environment, 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 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 {
@@ -277,29 +282,19 @@ function readData(environment, ast, root, variables, nestedRefetchQueries) {
     }
     return { kind: 'Success', data: target };
 }
-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];
-        // TODO can we handle explicit nulls here too? Probably, after wrapping in objects
-        if (value != null) {
-            return { __link: value };
-        }
-    }
-}
-exports.defaultMissingFieldHandler = defaultMissingFieldHandler;
 function assertLink(link) {
     if (Array.isArray(link)) {
         throw new Error('Unexpected array');
     }
+    if (link == null) {
+        return null;
+    }
     if (typeof link === 'object') {
         return link;
     }
-    if (link === undefined) {
-        return undefined;
-    }
     throw new Error('Invalid link');
 }
+exports.assertLink = assertLink;
 function filterVariables(variables, allowedVariables) {
     const result = {};
     for (const key of allowedVariables) {

package/dist/reader.d.ts

@@ -0,0 +1,47 @@
+import { Arguments } from './index';
+export type ReaderArtifact<TReadFromStore extends Object, TResolverResult> = {
+    kind: 'ReaderArtifact';
+    readerAst: ReaderAst<TReadFromStore>;
+    resolver: (data: TReadFromStore, runtimeProps: any) => TResolverResult;
+    variant: ReaderResolverVariant;
+};
+export type ReaderAstNode = ReaderScalarField | ReaderLinkedField | ReaderResolverField | ReaderRefetchField | ReaderMutationField;
+export type ReaderAst<TReadFromStore> = ReaderAstNode[];
+export type ReaderScalarField = {
+    kind: 'Scalar';
+    fieldName: string;
+    alias: string | null;
+    arguments: Arguments | null;
+};
+export type ReaderLinkedField = {
+    kind: 'Linked';
+    fieldName: string;
+    alias: string | null;
+    selections: ReaderAst<unknown>;
+    arguments: Arguments | null;
+};
+export type ReaderResolverVariant = {
+    kind: 'Eager';
+} | {
+    kind: 'Component';
+    componentName: string;
+};
+export type ReaderResolverField = {
+    kind: 'Resolver';
+    alias: string;
+    readerArtifact: ReaderArtifact<any, any>;
+    arguments: Arguments | null;
+    usedRefetchQueries: number[];
+};
+export type ReaderRefetchField = {
+    kind: 'RefetchField';
+    alias: string;
+    readerArtifact: ReaderArtifact<any, any>;
+    refetchQuery: number;
+};
+export type ReaderMutationField = {
+    kind: 'MutationField';
+    alias: string;
+    readerArtifact: ReaderArtifact<any, any>;
+    refetchQuery: number;
+};