Execution works with new AST node

Author: mjmahone

src/execution/collectFields.ts

@@ -22,6 +22,8 @@ import {
 } from '../type/directives.js';
 import type { GraphQLSchema } from '../type/schema.js';
 
+import { keyForFragmentSpread } from '../utilities/keyForFragmentSpread.js';
+import { substituteFragmentArguments } from '../utilities/substituteFragmentArguments.js';
 import { typeFromAST } from '../utilities/typeFromAST.js';
 
 import { getDirectiveValues } from './values.js';
@@ -124,7 +126,7 @@ function collectFieldsImpl(
   selectionSet: SelectionSetNode,
   fields: AccumulatorMap<string, FieldNode>,
   patches: Array<PatchFields>,
-  visitedFragmentNames: Set<string>,
+  visitedFragmentKeys: Set<string>,
 ): void {
   for (const selection of selectionSet.selections) {
     switch (selection.kind) {
@@ -156,7 +158,7 @@ function collectFieldsImpl(
             selection.selectionSet,
             patchFields,
             patches,
-            visitedFragmentNames,
+            visitedFragmentKeys,
           );
           patches.push({
             label: defer.label,
@@ -172,24 +174,24 @@ function collectFieldsImpl(
             selection.selectionSet,
             fields,
             patches,
-            visitedFragmentNames,
+            visitedFragmentKeys,
           );
         }
         break;
       }
       case Kind.FRAGMENT_SPREAD: {
-        const fragName = selection.name.value;
+        const fragmentKey = keyForFragmentSpread(selection);
 
         if (!shouldIncludeNode(variableValues, selection)) {
           continue;
         }
 
         const defer = getDeferValues(operation, variableValues, selection);
-        if (visitedFragmentNames.has(fragName) && !defer) {
+        if (visitedFragmentKeys.has(fragmentKey) && !defer) {
           continue;
         }
 
-        const fragment = fragments[fragName];
+        const fragment = fragments[selection.name.value];
         if (
           !fragment ||
           !doesFragmentConditionMatch(schema, fragment, runtimeType)
@@ -198,9 +200,13 @@ function collectFieldsImpl(
         }
 
         if (!defer) {
-          visitedFragmentNames.add(fragName);
+          visitedFragmentKeys.add(fragmentKey);
         }
 
+        const fragmentSelectionSet = substituteFragmentArguments(
+          fragment,
+          selection,
+        );
         if (defer) {
           const patchFields = new AccumulatorMap<string, FieldNode>();
           collectFieldsImpl(
@@ -209,10 +215,10 @@ function collectFieldsImpl(
             variableValues,
             operation,
             runtimeType,
-            fragment.selectionSet,
+            fragmentSelectionSet,
             patchFields,
             patches,
-            visitedFragmentNames,
+            visitedFragmentKeys,
           );
           patches.push({
             label: defer.label,
@@ -225,10 +231,10 @@ function collectFieldsImpl(
             variableValues,
             operation,
             runtimeType,
-            fragment.selectionSet,
+            fragmentSelectionSet,
             fields,
             patches,
-            visitedFragmentNames,
+            visitedFragmentKeys,
           );
         }
         break;

src/utilities/keyForFragmentSpread.ts

@@ -0,0 +1,23 @@
+import type { FragmentSpreadNode } from '../language/ast.js';
+import { print } from '../language/printer.js';
+
+/**
+ * Create a key that uniquely identifies common fragment spreads.
+ * Treats the fragment spread as the source of truth for the key: it
+ * does not bother to look up the argument definitions to de-duplicate default-variable args.
+ *
+ * Using the fragment definition to more accurately de-duplicate common spreads
+ * is a potential performance win, but in practice it seems unlikely to be common.
+ */
+export function keyForFragmentSpread(fragmentSpread: FragmentSpreadNode) {
+  const fragmentName = fragmentSpread.name.value;
+  const fragmentArguments = fragmentSpread.arguments;
+  if (fragmentArguments == null || fragmentArguments.length === 0) {
+    return fragmentName;
+  }
+
+  const printedArguments: Array<string> = fragmentArguments
+    .map(print)
+    .sort((a, b) => a.localeCompare(b));
+  return fragmentName + '(' + printedArguments.join(',') + ')';
+}

src/utilities/substituteFragmentArguments.ts

@@ -0,0 +1,78 @@
+import type { Maybe } from '../jsutils/Maybe.js';
+import type { ObjMap } from '../jsutils/ObjMap.js';
+
+import type {
+  ArgumentNode,
+  FragmentArgumentDefinitionNode,
+  FragmentDefinitionNode,
+  FragmentSpreadNode,
+  SelectionSetNode,
+  ValueNode,
+} from '../language/ast.js';
+import { Kind } from '../language/kinds.js';
+import { visit } from '../language/visitor.js';
+
+/**
+ * Replaces all fragment argument values with non-fragment-scoped values.
+ *
+ * NOTE: fragment arguments are scoped to the fragment they're defined on.
+ * Therefore, after we apply the passed-in arguments, all remaining variables
+ * must be either operation defined variables or explicitly unset.
+ */
+export function substituteFragmentArguments(
+  def: FragmentDefinitionNode,
+  fragmentSpread: FragmentSpreadNode,
+): SelectionSetNode {
+  const argumentDefinitions = def.arguments;
+  if (argumentDefinitions == null || argumentDefinitions.length === 0) {
+    return def.selectionSet;
+  }
+  const argumentValues = fragmentArgumentSubstitutions(
+    argumentDefinitions,
+    fragmentSpread.arguments,
+  );
+  return visit(def.selectionSet, {
+    Variable(node) {
+      return argumentValues[node.name.value];
+    },
+  });
+}
+
+export function fragmentArgumentSubstitutions(
+  argumentDefinitions: ReadonlyArray<FragmentArgumentDefinitionNode>,
+  argumentValues: Maybe<ReadonlyArray<ArgumentNode>>,
+): ObjMap<ValueNode> {
+  const substitutions: ObjMap<ValueNode> = {};
+  if (argumentValues) {
+    for (const argument of argumentValues) {
+      substitutions[argument.name.value] = argument.value;
+    }
+  }
+
+  for (const argumentDefinition of argumentDefinitions) {
+    const argumentName = argumentDefinition.variable.name.value;
+    if (substitutions[argumentName]) {
+      continue;
+    }
+
+    const defaultValue = argumentDefinition.defaultValue;
+    if (defaultValue) {
+      substitutions[argumentName] = defaultValue;
+    } else {
+      // We need a way to allow unset arguments without accidentally
+      // replacing an unset fragment argument with an operation
+      // variable value. Fragment arguments must always have LOCAL scope.
+      //
+      // To remove this hack, we need to either:
+      //    - include fragment argument scope when evaluating fields
+      //    - make unset fragment arguments invalid
+      // Requiring the spread to pass all non-default-defined arguments is nice,
+      // but makes field argument default values impossible to use.
+      substitutions[argumentName] = {
+        kind: Kind.VARIABLE,
+        name: { kind: Kind.NAME, value: '__UNSET' },
+      };
+    }
+  }
+  return substitutions;
+}