Filter selection sets recursively when finalizing gateway requests (#1301)

Author: enisdenjo

.changeset/clean-rules-beam.md

@@ -0,0 +1,7 @@
+---
+'@graphql-tools/delegate': patch
+---
+
+Filter selection sets recursively when finalizing gateway requests
+
+Because abstract types can be nested.

packages/delegate/src/finalizeGatewayRequest.ts

@@ -15,6 +15,7 @@ import {
   getNamedType,
   GraphQLField,
   GraphQLNamedType,
+  GraphQLObjectType,
   GraphQLSchema,
   GraphQLType,
   isAbstractType,
@@ -28,6 +29,7 @@ import {
   OperationDefinitionNode,
   SelectionNode,
   SelectionSetNode,
+  TypeInfo,
   VariableDefinitionNode,
   visit,
   visitWithTypeInfo,
@@ -483,7 +485,48 @@ function finalizeSelectionSet(
   const seenNonNullableMap = new WeakMap<readonly ASTNode[], Set<string>>();
   const seenNullableMap = new WeakMap<readonly ASTNode[], Set<string>>();
 
-  const filteredSelectionSet = visit(
+  const filteredSelectionSet = filterSelectionSet(
+    schema,
+    typeInfo,
+    validFragments,
+    selectionSet,
+    onOverlappingAliases,
+    usedFragments,
+    seenNonNullableMap,
+    seenNullableMap,
+  );
+
+  visit(
+    filteredSelectionSet,
+    {
+      [Kind.VARIABLE]: (variableNode) => {
+        usedVariables.push(variableNode.name.value);
+      },
+    },
+    // visitorKeys argument usage a la https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-graphql/src/batching/merge-queries.js
+    // empty keys cannot be removed only because of typescript errors
+    // will hopefully be fixed in future version of graphql-js to be optional
+    variablesVisitorKeys as any,
+  );
+
+  return {
+    selectionSet: filteredSelectionSet,
+    usedFragments,
+    usedVariables,
+  };
+}
+
+function filterSelectionSet(
+  schema: GraphQLSchema,
+  typeInfo: TypeInfo,
+  validFragments: { [name: string]: GraphQLType },
+  selectionSet: SelectionSetNode,
+  onOverlappingAliases: () => void,
+  usedFragments: Array<string>,
+  seenNonNullableMap: WeakMap<readonly ASTNode[], Set<string>>,
+  seenNullableMap: WeakMap<readonly ASTNode[], Set<string>>,
+) {
+  return visit(
     selectionSet,
     visitWithTypeInfo(typeInfo, {
       [Kind.FIELD]: {
@@ -541,20 +584,81 @@ function finalizeSelectionSet(
               }
             }
             if (possibleTypeNames.length > 0) {
-              return possibleTypeNames.map((possibleTypeName) => ({
-                kind: Kind.INLINE_FRAGMENT,
-                typeCondition: {
-                  kind: Kind.NAMED_TYPE,
-                  name: {
-                    kind: Kind.NAME,
-                    value: possibleTypeName,
+              const spreads = possibleTypeNames.map((possibleTypeName) => {
+                if (!node.selectionSet?.selections) {
+                  // leaf field, no selection set. return as is we're sure it exists
+                  return {
+                    kind: Kind.INLINE_FRAGMENT,
+                    typeCondition: {
+                      kind: Kind.NAMED_TYPE,
+                      name: {
+                        kind: Kind.NAME,
+                        value: possibleTypeName,
+                      },
+                    },
+                    selectionSet: {
+                      kind: Kind.SELECTION_SET,
+                      selections: [node],
+                    },
+                  };
+                }
+
+                // object field with selection set. filter it recursively
+                const possibleType = schema.getType(
+                  possibleTypeName,
+                ) as GraphQLObjectType; // it's an object type because union members must be objects
+
+                const possibleField = possibleType.getFields()[node.name.value];
+                if (!possibleField) {
+                  // the field does not exist on the possible type, skip the spread altogether
+                  return undefined;
+                }
+
+                // recursively filter the selection set because abstract types can be nested
+                const fieldFilteredSelectionSet = filterSelectionSet(
+                  schema,
+                  getTypeInfoWithType(schema, possibleField.type),
+                  validFragments,
+                  node.selectionSet,
+                  onOverlappingAliases,
+                  usedFragments,
+                  seenNonNullableMap,
+                  seenNullableMap,
+                );
+
+                if (!fieldFilteredSelectionSet.selections.length) {
+                  // no selections remain after filtering the field, skip the spread altogether
+                  return undefined;
+                }
+
+                return {
+                  kind: Kind.INLINE_FRAGMENT,
+                  typeCondition: {
+                    kind: Kind.NAMED_TYPE,
+                    name: {
+                      kind: Kind.NAME,
+                      value: possibleTypeName,
+                    },
                   },
-                },
-                selectionSet: {
-                  kind: Kind.SELECTION_SET,
-                  selections: [node],
-                },
-              }));
+                  selectionSet: {
+                    kind: Kind.SELECTION_SET,
+                    selections: [
+                      {
+                        ...node,
+                        selectionSet: fieldFilteredSelectionSet,
+                      },
+                    ],
+                  },
+                };
+              });
+              const nonEmptySpreads = spreads.filter(Boolean);
+              if (!nonEmptySpreads.length) {
+                // no spreads remain after filtering, skip the field altogether.
+                // this is important to avoid invalid ast nodes causing empty lines
+                // in the resulting query
+                return undefined;
+              }
+              return nonEmptySpreads;
             }
           }
           return undefined;
@@ -729,25 +833,6 @@ function finalizeSelectionSet(
     // will hopefully be fixed in future version of graphql-js to be optional
     filteredSelectionSetVisitorKeys as any,
   );
-
-  visit(
-    filteredSelectionSet,
-    {
-      [Kind.VARIABLE]: (variableNode) => {
-        usedVariables.push(variableNode.name.value);
-      },
-    },
-    // visitorKeys argument usage a la https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-graphql/src/batching/merge-queries.js
-    // empty keys cannot be removed only because of typescript errors
-    // will hopefully be fixed in future version of graphql-js to be optional
-    variablesVisitorKeys as any,
-  );
-
-  return {
-    selectionSet: filteredSelectionSet,
-    usedFragments,
-    usedVariables,
-  };
 }
 
 function union(...arrays: Array<Array<string>>): Array<string> {

packages/delegate/tests/finalizeGatewayRequest.test.ts

@@ -226,5 +226,94 @@ describe('finalizeGatewayRequest', () => {
   }
 }`);
     });
+    it('should remove fields that dont exist in schema', () => {
+      const query = parse(/* GraphQL */ `
+        query foo {
+          foo {
+            name
+            nickname
+          }
+        }
+      `);
+      const filteredQuery = finalizeGatewayRequest(
+        {
+          document: query,
+        },
+        {
+          targetSchema,
+        } as DelegationContext,
+        () => {},
+      );
+      expect(print(filteredQuery.document)).toMatchInlineSnapshot(`
+        "query foo {
+          foo {
+            __typename
+            ... on Bar {
+              name
+            }
+          }
+        }"
+      `);
+    });
+    it('should remove nested fields that dont exist in schema', () => {
+      const query = parse(/* GraphQL */ `
+        query foo {
+          foo {
+            name {
+              first
+              nickname
+            }
+          }
+        }
+      `);
+      const filteredQuery = finalizeGatewayRequest(
+        {
+          document: query,
+        },
+        {
+          targetSchema,
+        } as DelegationContext,
+        () => {},
+      );
+      expect(print(filteredQuery.document)).toMatchInlineSnapshot(`
+        "query foo {
+          foo {
+            __typename
+            ... on Baz {
+              name {
+                first
+              }
+            }
+          }
+        }"
+      `);
+    });
+    it('should remove fields whose nested fields dont exist in schema', () => {
+      const query = parse(/* GraphQL */ `
+        query foo {
+          foo {
+            name {
+              nickname
+            }
+          }
+        }
+      `);
+      const filteredQuery = finalizeGatewayRequest(
+        {
+          document: query,
+        },
+        {
+          targetSchema,
+        } as DelegationContext,
+        () => {},
+      );
+      expect(print(filteredQuery.document)).toMatchInlineSnapshot(`
+          "query foo {
+            foo {
+              __typename
+            }
+          }"
+        `);
+    });
   });
 });