@isograph/react 0.0.0-main-90264a00 → 0.0.0-main-2fbc0faf

package/dist/read.js

@@ -0,0 +1,233 @@
+"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 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, IsographEnvironment_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, IsographEnvironment_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/reader.d.ts

@@ -1,4 +1,4 @@
-import { Arguments } from './index';
+import { Arguments } from './util';
 export type ReaderArtifact<TReadFromStore extends Object, TResolverResult> = {
     kind: 'ReaderArtifact';
     readerAst: ReaderAst<TReadFromStore>;

package/dist/useImperativeReference.d.ts

@@ -1,5 +1,6 @@
 import { UnassignedState } from '@isograph/react-disposable-state';
-import { type IsographEntrypoint, type FragmentReference, ExtractReadFromStore, ExtractResolverResult } from './index';
+import { ExtractReadFromStore, ExtractResolverResult, IsographEntrypoint } from './entrypoint';
+import { FragmentReference } from './FragmentReference';
 export declare function useImperativeReference<TEntrypoint extends IsographEntrypoint<any, any>>(entrypoint: TEntrypoint): {
     queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, ExtractResolverResult<TEntrypoint>> | UnassignedState;
     loadQueryReference: (variables: {

package/dist/useImperativeReference.js

@@ -2,19 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useImperativeReference = void 0;
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
-const index_1 = require("./index");
+const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
+const cache_1 = require("./cache");
+const IsographEnvironment_1 = require("./IsographEnvironment");
 function useImperativeReference(entrypoint) {
     const { state, setState } = (0, react_disposable_state_1.useUpdatableDisposableState)();
-    const environment = (0, index_1.useIsographEnvironment)();
+    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
     return {
         queryReference: state,
         loadQueryReference: (variables) => {
-            const [_networkRequest, disposeNetworkRequest] = (0, index_1.makeNetworkRequest)(environment, entrypoint, variables);
+            const [_networkRequest, disposeNetworkRequest] = (0, cache_1.makeNetworkRequest)(environment, entrypoint, variables);
             setState([
                 {
                     kind: 'FragmentReference',
                     readerArtifact: entrypoint.readerArtifact,
-                    root: index_1.ROOT_ID,
+                    root: IsographEnvironment_1.ROOT_ID,
                     variables,
                     nestedRefetchQueries: entrypoint.nestedRefetchQueries,
                 },

package/dist/useLazyReference.d.ts

@@ -0,0 +1,7 @@
+import { FragmentReference, Variable } from './FragmentReference';
+import { ExtractReadFromStore, ExtractResolverResult } from './entrypoint';
+export declare function useLazyReference<TEntrypoint>(entrypoint: TEntrypoint | ((_: any) => any), variables: {
+    [key: string]: Variable;
+}): {
+    queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, ExtractResolverResult<TEntrypoint>>;
+};

package/dist/useLazyReference.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLazyReference = void 0;
+const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
+const IsographEnvironment_1 = require("./IsographEnvironment");
+const entrypoint_1 = require("./entrypoint");
+const cache_1 = require("./cache");
+const isograph_react_disposable_state_1 = require("@isograph/isograph-react-disposable-state");
+// 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, 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
+    const data = (0, isograph_react_disposable_state_1.useLazyDisposableState)(cache).state;
+    return {
+        queryReference: {
+            kind: 'FragmentReference',
+            readerArtifact: entrypoint.readerArtifact,
+            root: IsographEnvironment_1.ROOT_ID,
+            variables,
+            nestedRefetchQueries: entrypoint.nestedRefetchQueries,
+        },
+    };
+}
+exports.useLazyReference = useLazyReference;

package/dist/useResult.d.ts

@@ -0,0 +1,2 @@
+import { FragmentReference } from './FragmentReference';
+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/dist/util.d.ts

@@ -0,0 +1,11 @@
+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];
+export type ArgumentName = string;
+export type ArgumentValue = {
+    kind: 'Variable';
+    name: string;
+} | {
+    kind: 'Literal';
+    value: any;
+};

package/dist/util.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-90264a00",
+  "version": "0.0.0-main-2fbc0faf",
   "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-2fbc0faf",
+    "@isograph/react-disposable-state": "0.0.0-main-2fbc0faf",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/EntrypointReader.tsx

@@ -1,10 +1,7 @@
 import * as React from 'react';
-import {
-  ExtractReadFromStore,
-  IsographEntrypoint,
-  type FragmentReference,
-  useResult,
-} from './index';
+import { ExtractReadFromStore, IsographEntrypoint } from './entrypoint';
+import { FragmentReference } from './FragmentReference';
+import { useResult } from './useResult';
 
 export function EntrypointReader<
   TProps extends Record<any, any>,

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[];
+};

package/src/IsographEnvironment.tsx

@@ -113,3 +113,16 @@ export function defaultMissingFieldHandler(
     }
   }
 }
+
+export function assertLink(link: DataTypeValue): Link | null {
+  if (Array.isArray(link)) {
+    throw new Error('Unexpected array');
+  }
+  if (link == null) {
+    return null;
+  }
+  if (typeof link === 'object') {
+    return link;
+  }
+  throw new Error('Invalid link');
+}

package/src/cache.tsx

@@ -4,17 +4,6 @@ import {
   ParentCache,
 } from '@isograph/react-disposable-state';
 import { PromiseWrapper, wrapPromise } from './PromiseWrapper';
-import {
-  Argument,
-  ArgumentValue,
-  IsographEntrypoint,
-  NormalizationAst,
-  NormalizationLinkedField,
-  NormalizationScalarField,
-  ReaderLinkedField,
-  ReaderScalarField,
-  RefetchQueryArtifactWrapper,
-} from './index';
 import {
   DataId,
   ROOT_ID,
@@ -28,6 +17,15 @@ import {
   retainQuery,
   unretainQuery,
 } from './garbageCollection';
+import {
+  IsographEntrypoint,
+  NormalizationAst,
+  NormalizationLinkedField,
+  NormalizationScalarField,
+  RefetchQueryArtifactWrapper,
+} from './entrypoint';
+import { ReaderLinkedField, ReaderScalarField } from './reader';
+import { Argument, ArgumentValue } from './util';
 
 declare global {
   interface Window {

package/src/componentCache.ts

@@ -1,10 +1,8 @@
-import {
-  ReaderArtifact,
-  RefetchQueryArtifactWrapper,
-  readButDoNotEvaluate,
-} from './index';
 import { stableCopy } from './cache';
+import { RefetchQueryArtifactWrapper } from './entrypoint';
 import { IsographEnvironment, DataId } from './IsographEnvironment';
+import { readButDoNotEvaluate } from './read';
+import { ReaderArtifact } from './reader';
 
 export function getOrCreateCachedComponent(
   environment: IsographEnvironment,

package/src/entrypoint.ts

@@ -1,5 +1,5 @@
-import { Arguments } from './index';
 import { ReaderArtifact } from './reader';
+import { Arguments } from './util';
 
 // This type should be treated as an opaque type.
 export type IsographEntrypoint<
@@ -57,3 +57,8 @@ export function assertIsEntrypoint<
 ): asserts value is IsographEntrypoint<TReadFromStore, TResolverResult> {
   if (typeof value === 'function') throw new Error('Not a string');
 }
+
+export type ExtractReadFromStore<Type> =
+  Type extends IsographEntrypoint<infer X, any> ? X : never;
+export type ExtractResolverResult<Type> =
+  Type extends IsographEntrypoint<any, infer X> ? X : never;

package/src/garbageCollection.ts

@@ -4,9 +4,10 @@ import {
   IsographStore,
   ROOT_ID,
   StoreRecord,
+  assertLink,
 } from './IsographEnvironment';
-import { NormalizationAst, assertLink } from './index';
 import { getParentRecordKey } from './cache';
+import { NormalizationAst } from './entrypoint';
 
 export type RetainedQuery = {
   normalizationAst: NormalizationAst;