@isograph/react 0.0.0-main-3247c783 → 0.0.0-main-c174d679

package/dist/cache.js

@@ -364,6 +364,12 @@ function getStoreKeyChunkForArgumentValue(argumentValue, variables) {
         case 'Variable': {
             return variables[argumentValue.name];
         }
+        case 'String': {
+            return argumentValue.value;
+        }
+        case 'Enum': {
+            return argumentValue.value;
+        }
         default: {
             // TODO configure eslint to allow unused vars starting with _
             // Ensure we have covered all variants
@@ -393,6 +399,14 @@ function getNetworkResponseKey(astNode) {
                     argumentValueChunk = 'v_' + argumentValue.name;
                     break;
                 }
+                case 'String': {
+                    argumentValueChunk = 's_' + argumentValue.value;
+                    break;
+                }
+                case 'Enum': {
+                    argumentValueChunk = 'e_' + argumentValue.value;
+                    break;
+                }
                 default: {
                     // Ensure we have covered all variants
                     let _ = argumentValue;

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { ROOT_ID, type DataId, type DataTypeValue, type IsographEnvironment, typ
 export { IsographEnvironmentProvider, useIsographEnvironment, type IsographEnvironmentProviderProps, } from './IsographEnvironmentProvider';
 export { useImperativeReference } from './useImperativeReference';
 export { EntrypointReader } from './EntrypointReader';
-export { EagerReaderArtifact, ComponentReaderArtifact, MutationReaderArtifact, RefetchReaderArtifact, ReaderAst, ReaderAstNode, ReaderLinkedField, ReaderResolverField, ReaderScalarField, TopLevelReaderArtifact, LoadableField, } from './reader';
+export { EagerReaderArtifact, ComponentReaderArtifact, RefetchReaderArtifact, ReaderAst, ReaderAstNode, ReaderLinkedField, ReaderNonLoadableResolverField, ReaderScalarField, TopLevelReaderArtifact, LoadableField, } from './reader';
 export { NormalizationAst, NormalizationAstNode, NormalizationLinkedField, NormalizationScalarField, IsographEntrypoint, assertIsEntrypoint, RefetchQueryNormalizationArtifact, RefetchQueryNormalizationArtifactWrapper, } from './entrypoint';
 export { readButDoNotEvaluate } from './read';
 export { useResult } from './useResult';

package/dist/read.js

@@ -155,11 +155,13 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, mutab
                     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) => [
+                    target[field.alias] = (args) => [
                         // Stable id
                         root + '__' + field.name,
                         // Fetcher
-                        field.refetchReaderArtifact.resolver(environment, refetchQueryArtifact, data.data, filterVariables(variables, allowedVariables), root, field.resolverReaderArtifact, field.usedRefetchQueries.map((id) => nestedRefetchQueries[id])),
+                        field.refetchReaderArtifact.resolver(environment, refetchQueryArtifact, data.data, filterVariables(Object.assign(Object.assign({}, args), variables), allowedVariables), root, 
+                        // TODO these params should be removed
+                        null, []),
                     ];
                 }
                 break;
@@ -186,12 +188,51 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, mutab
                         kind: 'FragmentReference',
                         readerArtifact: field.readerArtifact,
                         root,
-                        variables,
+                        variables: generateChildVariableMap(variables, field.arguments),
                         nestedRefetchQueries: resolverRefetchQueries,
                     });
                 }
                 break;
             }
+            case 'LoadablySelectedField': {
+                const refetchReaderParams = readData(environment, field.refetchReaderAst, root, variables, 
+                // Refetch fields just read the id, and don't need refetch query artifacts
+                [], mutableEncounteredRecords);
+                if (refetchReaderParams.kind === 'MissingData') {
+                    return {
+                        kind: 'MissingData',
+                        reason: 'Missing data for ' + field.alias + ' on root ' + root,
+                        nestedReason: refetchReaderParams,
+                    };
+                }
+                else {
+                    target[field.alias] = (args) => [
+                        // Stable id
+                        root + '__' + field.name,
+                        // Fetcher
+                        () => {
+                            // TODO we should use the reader AST for this
+                            const includeReadOutData = (variables, readOutData) => {
+                                variables.id = readOutData.id;
+                                return variables;
+                            };
+                            const localVariables = includeReadOutData(args !== null && args !== void 0 ? args : {}, refetchReaderParams.data);
+                            writeQueryArgsToVariables(localVariables, field.queryArguments, variables);
+                            const [_networkRequest, disposeNetworkRequest] = (0, cache_1.makeNetworkRequest)(environment, field.entrypoint, localVariables);
+                            const fragmentReference = {
+                                kind: 'FragmentReference',
+                                readerArtifact: field.entrypoint.readerArtifact,
+                                // TODO localVariables is not guaranteed to have an id field
+                                root: localVariables.id,
+                                variables: localVariables,
+                                nestedRefetchQueries: field.entrypoint.nestedRefetchQueries,
+                            };
+                            return [fragmentReference, disposeNetworkRequest];
+                        },
+                    ];
+                }
+                break;
+            }
             default: {
                 // Ensure we have covered all variants
                 let _ = field;
@@ -214,3 +255,50 @@ function filterVariables(variables, allowedVariables) {
     }
     return result;
 }
+function generateChildVariableMap(variables, fieldArguments) {
+    if (fieldArguments == null) {
+        return {};
+    }
+    const childVars = {};
+    for (const [name, value] of fieldArguments) {
+        if (value.kind === 'Variable') {
+            // @ts-expect-error
+            childVars[name] = variables[value.name];
+        }
+        else {
+            // @ts-expect-error
+            childVars[name] = value;
+        }
+    }
+    return childVars;
+}
+function writeQueryArgsToVariables(targetVariables, queryArgs, variables) {
+    if (queryArgs == null) {
+        return;
+    }
+    for (const [name, argType] of queryArgs) {
+        switch (argType.kind) {
+            case 'Variable': {
+                targetVariables[name] = variables[argType.name];
+                break;
+            }
+            case 'Enum': {
+                targetVariables[name] = argType.value;
+                break;
+            }
+            case 'Literal': {
+                targetVariables[name] = argType.value;
+                break;
+            }
+            case 'String': {
+                targetVariables[name] = argType.value;
+                break;
+            }
+            default: {
+                const _ = argType;
+                _;
+                throw new Error('Unexpected case');
+            }
+        }
+    }
+}

package/dist/reader.d.ts

@@ -2,7 +2,7 @@
 import { Factory } from '@isograph/disposable-types';
 import { FragmentReference } from './FragmentReference';
 import { ComponentOrFieldName, DataId, IsographEnvironment } from './IsographEnvironment';
-import { RefetchQueryNormalizationArtifact, RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
+import { IsographEntrypoint, RefetchQueryNormalizationArtifact, RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
 import { Arguments } from './util';
 export type TopLevelReaderArtifact<TReadFromStore extends Object, TClientFieldValue, TComponentProps extends Record<string, never>> = EagerReaderArtifact<TReadFromStore, TClientFieldValue> | ComponentReaderArtifact<TReadFromStore, TComponentProps>;
 export type EagerReaderArtifact<TReadFromStore extends Object, TClientFieldValue> = {
@@ -21,12 +21,7 @@ export type RefetchReaderArtifact = {
     readonly readerAst: ReaderAst<unknown>;
     readonly resolver: (environment: IsographEnvironment, artifact: RefetchQueryNormalizationArtifact, variables: any, filteredVariables: any, rootId: DataId, readerArtifact: TopLevelReaderArtifact<any, any, any> | null, nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[]) => () => void;
 };
-export type MutationReaderArtifact<TReadFromStore extends Object> = {
-    readonly kind: 'MutationReaderArtifact';
-    readonly readerAst: ReaderAst<unknown>;
-    readonly resolver: (environment: IsographEnvironment, entrypoint: RefetchQueryNormalizationArtifact, readOutData: TReadFromStore, filteredVariables: any, rootId: DataId, readerArtifact: TopLevelReaderArtifact<any, any, any> | null, nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[]) => (mutationParams: any) => void;
-};
-export type ReaderAstNode = ReaderScalarField | ReaderLinkedField | ReaderResolverField | ReaderImperativelyLoadedField;
+export type ReaderAstNode = ReaderScalarField | ReaderLinkedField | ReaderNonLoadableResolverField | ReaderImperativelyLoadedField | ReaderLoadableField;
 export type ReaderAst<TReadFromStore> = ReadonlyArray<ReaderAstNode>;
 export type ReaderScalarField = {
     readonly kind: 'Scalar';
@@ -41,7 +36,7 @@ export type ReaderLinkedField = {
     readonly selections: ReaderAst<unknown>;
     readonly arguments: Arguments | null;
 };
-export type ReaderResolverField = {
+export type ReaderNonLoadableResolverField = {
     readonly kind: 'Resolver';
     readonly alias: string;
     readonly readerArtifact: TopLevelReaderArtifact<any, any, any>;
@@ -51,11 +46,17 @@ export type ReaderResolverField = {
 export type ReaderImperativelyLoadedField = {
     readonly kind: 'ImperativelyLoadedField';
     readonly alias: string;
-    readonly refetchReaderArtifact: MutationReaderArtifact<any> | RefetchReaderArtifact;
-    readonly resolverReaderArtifact: TopLevelReaderArtifact<any, any, any> | null;
+    readonly refetchReaderArtifact: RefetchReaderArtifact;
     readonly refetchQuery: number;
     readonly name: string;
-    readonly usedRefetchQueries: number[];
+};
+export type ReaderLoadableField = {
+    readonly kind: 'LoadablySelectedField';
+    readonly alias: string;
+    readonly name: string;
+    readonly queryArguments: Arguments | null;
+    readonly refetchReaderAst: ReaderAst<any>;
+    readonly entrypoint: IsographEntrypoint<any, any>;
 };
 type StableId = string;
 export type LoadableField<TArgs, TResult> = (args: TArgs) => [StableId, Factory<FragmentReference<any, TResult>>];

package/dist/util.d.ts

@@ -8,4 +8,10 @@ export type ArgumentValue = {
 } | {
     readonly kind: 'Literal';
     readonly value: any;
+} | {
+    readonly kind: 'String';
+    readonly value: string;
+} | {
+    readonly kind: 'Enum';
+    readonly value: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-3247c783",
+  "version": "0.0.0-main-c174d679",
   "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-3247c783",
-    "@isograph/react-disposable-state": "0.0.0-main-3247c783",
+    "@isograph/disposable-types": "0.0.0-main-c174d679",
+    "@isograph/react-disposable-state": "0.0.0-main-c174d679",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/cache.ts

@@ -650,6 +650,12 @@ function getStoreKeyChunkForArgumentValue(
     case 'Variable': {
       return variables[argumentValue.name];
     }
+    case 'String': {
+      return argumentValue.value;
+    }
+    case 'Enum': {
+      return argumentValue.value;
+    }
     default: {
       // TODO configure eslint to allow unused vars starting with _
       // Ensure we have covered all variants
@@ -683,6 +689,14 @@ function getNetworkResponseKey(
           argumentValueChunk = 'v_' + argumentValue.name;
           break;
         }
+        case 'String': {
+          argumentValueChunk = 's_' + argumentValue.value;
+          break;
+        }
+        case 'Enum': {
+          argumentValueChunk = 'e_' + argumentValue.value;
+          break;
+        }
         default: {
           // Ensure we have covered all variants
           let _: never = argumentValue;

package/src/index.ts

@@ -29,12 +29,11 @@ export { EntrypointReader } from './EntrypointReader';
 export {
   EagerReaderArtifact,
   ComponentReaderArtifact,
-  MutationReaderArtifact,
   RefetchReaderArtifact,
   ReaderAst,
   ReaderAstNode,
   ReaderLinkedField,
-  ReaderResolverField,
+  ReaderNonLoadableResolverField,
   ReaderScalarField,
   TopLevelReaderArtifact,
   LoadableField,

package/src/read.ts

@@ -1,4 +1,4 @@
-import { getParentRecordKey, onNextChange } from './cache';
+import { getParentRecordKey, makeNetworkRequest, onNextChange } from './cache';
 import { getOrCreateCachedComponent } from './componentCache';
 import { RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
 import { FragmentReference, Variables } from './FragmentReference';
@@ -9,6 +9,7 @@ import {
   IsographEnvironment,
 } from './IsographEnvironment';
 import { ReaderAst } from './reader';
+import { Arguments } from './util';
 
 export type WithEncounteredRecords<T> = {
   readonly encounteredRecords: Set<DataId>;
@@ -222,7 +223,7 @@ function readData<TReadFromStore>(
 
           // 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: void) => [
+          target[field.alias] = (args: any) => [
             // Stable id
             root + '__' + field.name,
             // Fetcher
@@ -230,10 +231,11 @@ function readData<TReadFromStore>(
               environment,
               refetchQueryArtifact,
               data.data,
-              filterVariables(variables, allowedVariables),
+              filterVariables({ ...args, ...variables }, allowedVariables),
               root,
-              field.resolverReaderArtifact,
-              field.usedRefetchQueries.map((id) => nestedRefetchQueries[id]),
+              // TODO these params should be removed
+              null,
+              [],
             ),
           ];
         }
@@ -272,13 +274,69 @@ function readData<TReadFromStore>(
               kind: 'FragmentReference',
               readerArtifact: field.readerArtifact,
               root,
-              variables,
+              variables: generateChildVariableMap(variables, field.arguments),
               nestedRefetchQueries: resolverRefetchQueries,
             } as const,
           );
         }
         break;
       }
+      case 'LoadablySelectedField': {
+        const refetchReaderParams = readData(
+          environment,
+          field.refetchReaderAst,
+          root,
+          variables,
+          // Refetch fields just read the id, and don't need refetch query artifacts
+          [],
+          mutableEncounteredRecords,
+        );
+        if (refetchReaderParams.kind === 'MissingData') {
+          return {
+            kind: 'MissingData',
+            reason: 'Missing data for ' + field.alias + ' on root ' + root,
+            nestedReason: refetchReaderParams,
+          };
+        } else {
+          target[field.alias] = (args: any) => [
+            // Stable id
+            root + '__' + field.name,
+            // Fetcher
+            () => {
+              // TODO we should use the reader AST for this
+              const includeReadOutData = (variables: any, readOutData: any) => {
+                variables.id = readOutData.id;
+                return variables;
+              };
+              const localVariables = includeReadOutData(
+                args ?? {},
+                refetchReaderParams.data,
+              );
+              writeQueryArgsToVariables(
+                localVariables,
+                field.queryArguments,
+                variables,
+              );
+              const [_networkRequest, disposeNetworkRequest] =
+                makeNetworkRequest(
+                  environment,
+                  field.entrypoint,
+                  localVariables,
+                );
+              const fragmentReference = {
+                kind: 'FragmentReference',
+                readerArtifact: field.entrypoint.readerArtifact,
+                // TODO localVariables is not guaranteed to have an id field
+                root: localVariables.id,
+                variables: localVariables,
+                nestedRefetchQueries: field.entrypoint.nestedRefetchQueries,
+              } as const;
+              return [fragmentReference, disposeNetworkRequest];
+            },
+          ];
+        }
+        break;
+      }
       default: {
         // Ensure we have covered all variants
         let _: never = field;
@@ -305,3 +363,59 @@ function filterVariables(
   }
   return result;
 }
+
+function generateChildVariableMap(
+  variables: Variables,
+  fieldArguments: Arguments | null,
+): Variables {
+  if (fieldArguments == null) {
+    return {};
+  }
+
+  const childVars: Variables = {};
+  for (const [name, value] of fieldArguments) {
+    if (value.kind === 'Variable') {
+      // @ts-expect-error
+      childVars[name] = variables[value.name];
+    } else {
+      // @ts-expect-error
+      childVars[name] = value;
+    }
+  }
+  return childVars;
+}
+
+function writeQueryArgsToVariables(
+  targetVariables: any,
+  queryArgs: Arguments | null,
+  variables: Variables,
+) {
+  if (queryArgs == null) {
+    return;
+  }
+  for (const [name, argType] of queryArgs) {
+    switch (argType.kind) {
+      case 'Variable': {
+        targetVariables[name] = variables[argType.name];
+        break;
+      }
+      case 'Enum': {
+        targetVariables[name] = argType.value;
+        break;
+      }
+      case 'Literal': {
+        targetVariables[name] = argType.value;
+        break;
+      }
+      case 'String': {
+        targetVariables[name] = argType.value;
+        break;
+      }
+      default: {
+        const _: never = argType;
+        _;
+        throw new Error('Unexpected case');
+      }
+    }
+  }
+}

package/src/reader.ts

@@ -6,6 +6,7 @@ import {
   IsographEnvironment,
 } from './IsographEnvironment';
 import {
+  IsographEntrypoint,
   RefetchQueryNormalizationArtifact,
   RefetchQueryNormalizationArtifactWrapper,
 } from './entrypoint';
@@ -58,28 +59,12 @@ export type RefetchReaderArtifact = {
   ) => () => void;
 };
 
-export type MutationReaderArtifact<TReadFromStore extends Object> = {
-  readonly kind: 'MutationReaderArtifact';
-  readonly readerAst: ReaderAst<unknown>;
-  readonly resolver: (
-    environment: IsographEnvironment,
-    // TODO type this better
-    entrypoint: RefetchQueryNormalizationArtifact,
-    readOutData: TReadFromStore,
-    // TODO type this better
-    filteredVariables: any,
-    rootId: DataId,
-    readerArtifact: TopLevelReaderArtifact<any, any, any> | null,
-    // TODO type this better
-    nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
-  ) => (mutationParams: any) => void;
-};
-
 export type ReaderAstNode =
   | ReaderScalarField
   | ReaderLinkedField
-  | ReaderResolverField
-  | ReaderImperativelyLoadedField;
+  | ReaderNonLoadableResolverField
+  | ReaderImperativelyLoadedField
+  | ReaderLoadableField;
 
 // @ts-ignore
 export type ReaderAst<TReadFromStore> = ReadonlyArray<ReaderAstNode>;
@@ -98,7 +83,7 @@ export type ReaderLinkedField = {
   readonly arguments: Arguments | null;
 };
 
-export type ReaderResolverField = {
+export type ReaderNonLoadableResolverField = {
   readonly kind: 'Resolver';
   readonly alias: string;
   // TODO don't type this as any
@@ -110,13 +95,23 @@ export type ReaderResolverField = {
 export type ReaderImperativelyLoadedField = {
   readonly kind: 'ImperativelyLoadedField';
   readonly alias: string;
-  readonly refetchReaderArtifact:
-    | MutationReaderArtifact<any>
-    | RefetchReaderArtifact;
-  readonly resolverReaderArtifact: TopLevelReaderArtifact<any, any, any> | null;
+  readonly refetchReaderArtifact: RefetchReaderArtifact;
   readonly refetchQuery: number;
   readonly name: string;
-  readonly usedRefetchQueries: number[];
+};
+
+export type ReaderLoadableField = {
+  readonly kind: 'LoadablySelectedField';
+  readonly alias: string;
+
+  // To generate a stable id, we need the parent id + the name + the args that
+  // we pass to the field, which come from: queryArgs, refetchReaderAst
+  // (technically, but in practice that is always "id") and the user-provided args.
+  readonly name: string;
+  readonly queryArguments: Arguments | null;
+  readonly refetchReaderAst: ReaderAst<any>;
+
+  readonly entrypoint: IsographEntrypoint<any, any>;
 };
 
 type StableId = string;

package/src/util.ts

@@ -12,4 +12,12 @@ export type ArgumentValue =
   | {
       readonly kind: 'Literal';
       readonly value: any;
+    }
+  | {
+      readonly kind: 'String';
+      readonly value: string;
+    }
+  | {
+      readonly kind: 'Enum';
+      readonly value: string;
     };