Executor changes with helpers needed for executor and validation

mjmahone · mjmahone · commit 2e4a9bcdb257 · 2022-12-19T03:11:51.000-05:00
diff --git a/src/execution/__tests__/variables-test.ts b/src/execution/__tests__/variables-test.ts
@@ -82,6 +82,13 @@ function fieldWithInputArg(
   };
 }
 
+const NestedType: GraphQLObjectType = new GraphQLObjectType({
+  name: 'NestedType',
+  fields: {
+    echo: fieldWithInputArg({ type: GraphQLString }),
+  },
+});
+
 const TestType = new GraphQLObjectType({
   name: 'TestType',
   fields: {
@@ -107,6 +114,10 @@ const TestType = new GraphQLObjectType({
       defaultValue: 'Hello World',
     }),
     list: fieldWithInputArg({ type: new GraphQLList(GraphQLString) }),
+    nested: {
+      type: NestedType,
+      resolve: () => ({}),
+    },
     nnList: fieldWithInputArg({
       type: new GraphQLNonNull(new GraphQLList(GraphQLString)),
     }),
@@ -1006,6 +1017,222 @@ describe('Execute: Handles inputs', () => {
     });
   });
 
+  describe('using fragment arguments', () => {
+    it('when there are no fragment arguments', () => {
+      const result = executeQuery(`
+        query {
+          ...a
+        }
+        fragment a on TestType {
+          fieldWithNonNullableStringInput(input: "A")
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          fieldWithNonNullableStringInput: '"A"',
+        },
+      });
+    });
+
+    it('when a value is required and provided', () => {
+      const result = executeQuery(`
+        query {
+          ...a(value: "A")
+        }
+        fragment a($value: String!) on TestType {
+          fieldWithNonNullableStringInput(input: $value)
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          fieldWithNonNullableStringInput: '"A"',
+        },
+      });
+    });
+
+    it('when a value is required and not provided', () => {
+      const result = executeQuery(`
+        query {
+          ...a
+        }
+        fragment a($value: String!) on TestType {
+          fieldWithNullableStringInput(input: $value)
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          fieldWithNullableStringInput: null,
+        },
+      });
+    });
+
+    it('when the definition has a default and is provided', () => {
+      const result = executeQuery(`
+        query {
+          ...a(value: "A")
+        }
+        fragment a($value: String! = "B") on TestType {
+          fieldWithNonNullableStringInput(input: $value)
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          fieldWithNonNullableStringInput: '"A"',
+        },
+      });
+    });
+
+    it('when the definition has a default and is not provided', () => {
+      const result = executeQuery(`
+        query {
+          ...a
+        }
+        fragment a($value: String! = "B") on TestType {
+          fieldWithNonNullableStringInput(input: $value)
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          fieldWithNonNullableStringInput: '"B"',
+        },
+      });
+    });
+
+    it('when the definition has a non-nullable default and is provided null', () => {
+      const result = executeQuery(`
+        query {
+          ...a(value: null)
+        }
+        fragment a($value: String! = "B") on TestType {
+          fieldWithNullableStringInput(input: $value)
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          fieldWithNullableStringInput: 'null',
+        },
+      });
+    });
+
+    it('when the definition has no default and is not provided', () => {
+      const result = executeQuery(`
+        query {
+          ...a
+        }
+        fragment a($value: String) on TestType {
+          fieldWithNonNullableStringInputAndDefaultArgumentValue(input: $value)
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          fieldWithNonNullableStringInputAndDefaultArgumentValue:
+            '"Hello World"',
+        },
+      });
+    });
+
+    it('when an argument is shadowed by an operation variable', () => {
+      const result = executeQuery(`
+        query($x: String! = "A") {
+          ...a(x: "B")
+        }
+        fragment a($x: String) on TestType {
+          fieldWithNullableStringInput(input: $x)
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          fieldWithNullableStringInput: '"B"',
+        },
+      });
+    });
+
+    it('when a nullable argument with a field default is not provided and shadowed by an operation variable', () => {
+      const result = executeQuery(`
+        query($x: String = "A") {
+          ...a
+        }
+        fragment a($x: String) on TestType {
+          fieldWithNonNullableStringInputAndDefaultArgumentValue(input: $x)
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          fieldWithNonNullableStringInputAndDefaultArgumentValue:
+            '"Hello World"',
+        },
+      });
+    });
+
+    it('when a fragment is used with different args', () => {
+      const result = executeQuery(`
+        query($x: String = "Hello") {
+          a: nested {
+            ...a(x: "a")
+          }
+          b: nested {
+            ...a(x: "b", b: true)
+          }
+          hello: nested {
+            ...a(x: $x)
+          }
+        }
+        fragment a($x: String, $b: Boolean = false) on NestedType {
+          a: echo(input: $x) @skip(if: $b)
+          b: echo(input: $x) @include(if: $b)
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          a: {
+            a: '"a"',
+          },
+          b: {
+            b: '"b"',
+          },
+          hello: {
+            a: '"Hello"',
+          },
+        },
+      });
+    });
+
+    it('when the argument variable is nested in a complex type', () => {
+      const result = executeQuery(`
+        query {
+          ...a(value: "C")
+        }
+        fragment a($value: String) on TestType {
+          list(input: ["A", "B", $value, "D"])
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          list: '["A", "B", "C", "D"]',
+        },
+      });
+    });
+
+    it('when argument variables are used recursively', () => {
+      const result = executeQuery(`
+        query {
+          ...a(aValue: "C")
+        }
+        fragment a($aValue: String) on TestType {
+          ...b(bValue: $aValue)
+        }
+        fragment b($bValue: String) on TestType {
+          list(input: ["A", "B", $bValue, "D"])
+        }
+      `);
+      expect(result).to.deep.equal({
+        data: {
+          list: '["A", "B", "C", "D"]',
+        },
+      });
+    });
+  });
+
   describe('getVariableValues: limit maximum number of coercion errors', () => {
     const doc = parse(`
       query ($input: [String!]) {
diff --git a/src/execution/collectFields.ts b/src/execution/collectFields.ts
@@ -19,6 +19,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';
@@ -116,7 +118,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) {
@@ -147,7 +149,7 @@ function collectFieldsImpl(
             selection.selectionSet,
             patchFields,
             patches,
-            visitedFragmentNames,
+            visitedFragmentKeys,
           );
           patches.push({
             label: defer.label,
@@ -162,24 +164,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(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)
@@ -188,20 +190,24 @@ function collectFieldsImpl(
         }
 
         if (!defer) {
-          visitedFragmentNames.add(fragName);
+          visitedFragmentKeys.add(fragmentKey);
         }
 
+        const fragmentSelectionSet = substituteFragmentArguments(
+          fragment,
+          selection,
+        );
         if (defer) {
           const patchFields = new AccumulatorMap<string, FieldNode>();
           collectFieldsImpl(
             schema,
             fragments,
             variableValues,
             runtimeType,
-            fragment.selectionSet,
+            fragmentSelectionSet,
             patchFields,
             patches,
-            visitedFragmentNames,
+            visitedFragmentKeys,
           );
           patches.push({
             label: defer.label,
@@ -213,10 +219,10 @@ function collectFieldsImpl(
             fragments,
             variableValues,
             runtimeType,
-            fragment.selectionSet,
+            fragmentSelectionSet,
             fields,
             patches,
-            visitedFragmentNames,
+            visitedFragmentKeys,
           );
         }
         break;
diff --git a/src/utilities/keyForFragmentSpread.ts b/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(',') + ')';
+}
diff --git a/src/utilities/substituteFragmentArguments.ts b/src/utilities/substituteFragmentArguments.ts
