fix(stitch): handle unresolvable fields (#6117)

* fix(stitch): handle unresolvable fields

* Correct

* Fix TS

* Update packages/delegate/src/delegateToSchema.ts

Co-authored-by: Kamil Kisiela <[email protected]>

* Update packages/delegate/src/delegateToSchema.ts

---------

Co-authored-by: Kamil Kisiela <[email protected]>

Author: ardatan

.changeset/green-sheep-bake.md

@@ -0,0 +1,71 @@
+---
+"@graphql-tools/stitch": patch
+---
+
+Add field as an unavailable field only if it is not able to resolve by any other subschema;
+
+When the following query is sent to the gateway with the following subschemas, the gateway should resolve `Category.details` from A Subschema using `Product` resolver instead of trying to resolve by using non-existing `Category` resolver from A Subschema.
+
+Previously, the query planner decides to resolve `Category.details` after resolving `Category` from C Subschema. But it will be too late to resolve `details` because `Category` is not resolvable in A Subschema.
+
+So the requests for `Category.details` and the rest of `Category` should be different.
+
+So for the following query, we expect a full result;
+```graphql
+    query {
+      productFromA(id: "1") {
+        id
+        name
+        category {
+          id
+          name
+          details
+        }
+      }
+    }
+```
+
+
+```graphql
+# A Subschema
+type Query {
+  productFromA(id: ID): Product
+  # No category resolver is present
+}
+
+type Product {
+  id: ID
+  category: Category
+}
+
+type Category {
+  details: CategoryDetails
+}
+```
+
+```graphql
+# B Subschema
+type Query {
+  productFromB(id: ID): Product
+}
+type Product {
+  id: ID
+  name: String
+  category: Category
+}
+type Category {
+  id: ID
+}
+```
+
+```graphql
+# C Subschema
+type Query {
+  categoryFromC(id: ID): Category
+}
+
+type Category {
+  id: ID
+  name: String
+}
+```

packages/stitch/src/createDelegationPlanBuilder.ts

@@ -145,7 +145,17 @@ function calculateDelegationStage(
         const fields = typeInSubschema.getFields();
         const field = fields[fieldNode.name.value];
         if (field != null) {
-          const unavailableFields = extractUnavailableFields(field, fieldNode);
+          const unavailableFields = extractUnavailableFields(field, fieldNode, fieldType => {
+            if (!nonUniqueSubschema.merge?.[fieldType.name]) {
+              delegationMap.set(nonUniqueSubschema, {
+                kind: Kind.SELECTION_SET,
+                selections: [fieldNode],
+              });
+              // Ignore unresolvable fields
+              return false;
+            }
+            return true;
+          });
           const currentScore = calculateScore(unavailableFields);
           if (currentScore < bestScore) {
             bestScore = currentScore;

packages/stitch/src/getFieldsNotInSubschema.ts

@@ -3,6 +3,7 @@ import {
   FragmentDefinitionNode,
   getNamedType,
   GraphQLField,
+  GraphQLInterfaceType,
   GraphQLObjectType,
   GraphQLSchema,
   Kind,
@@ -43,7 +44,11 @@ export function getFieldsNotInSubschema(
     } else {
       const field = fields[fieldName];
       for (const subFieldNode of subFieldNodes) {
-        const unavailableFields = extractUnavailableFields(field, subFieldNode);
+        const unavailableFields = extractUnavailableFields(
+          field,
+          subFieldNode,
+          (fieldType, selection) => !fieldNodesByField?.[fieldType.name]?.[selection.name.value],
+        );
         if (unavailableFields.length) {
           fieldsNotInSchema.add({
             ...subFieldNode,
@@ -63,7 +68,6 @@ export function getFieldsNotInSubschema(
           for (const subFieldNode of subFieldNodes) {
             fieldsNotInSchema.add(subFieldNode);
           }
-
           fieldsNotInSchema.add(fieldNode);
         }
       }
@@ -73,7 +77,11 @@ export function getFieldsNotInSubschema(
   return Array.from(fieldsNotInSchema);
 }
 
-export function extractUnavailableFields(field: GraphQLField<any, any>, fieldNode: FieldNode) {
+export function extractUnavailableFields(
+  field: GraphQLField<any, any>,
+  fieldNode: FieldNode,
+  shouldAdd: (fieldType: GraphQLObjectType | GraphQLInterfaceType, selection: FieldNode) => boolean,
+) {
   if (fieldNode.selectionSet) {
     const fieldType = getNamedType(field.type);
     // TODO: Only object types are supported
@@ -82,18 +90,23 @@ export function extractUnavailableFields(field: GraphQLField<any, any>, fieldNod
     }
     const subFields = fieldType.getFields();
     const unavailableSelections: SelectionNode[] = [];
-    let hasTypeName = false;
     for (const selection of fieldNode.selectionSet.selections) {
       if (selection.kind === Kind.FIELD) {
         if (selection.name.value === '__typename') {
-          hasTypeName = true;
           continue;
         }
-        const selectionField = subFields[selection.name.value];
+        const fieldName = selection.name.value;
+        const selectionField = subFields[fieldName];
         if (!selectionField) {
-          unavailableSelections.push(selection);
+          if (shouldAdd(fieldType, selection)) {
+            unavailableSelections.push(selection);
+          }
         } else {
-          const unavailableSubFields = extractUnavailableFields(selectionField, selection);
+          const unavailableSubFields = extractUnavailableFields(
+            selectionField,
+            selection,
+            shouldAdd,
+          );
           if (unavailableSubFields.length) {
             unavailableSelections.push({
               ...selection,
@@ -108,15 +121,6 @@ export function extractUnavailableFields(field: GraphQLField<any, any>, fieldNod
         // TODO: Support for inline fragments
       }
     }
-    if (unavailableSelections.length && hasTypeName) {
-      unavailableSelections.unshift({
-        kind: Kind.FIELD,
-        name: {
-          kind: Kind.NAME,
-          value: '__typename',
-        },
-      });
-    }
     return unavailableSelections;
   }
   return [];

packages/stitch/tests/extractUnavailableFields.test.ts

@@ -48,7 +48,7 @@ describe('extractUnavailableFields', () => {
     if (!userField) {
       throw new Error('User field not found');
     }
-    const unavailableFields = extractUnavailableFields(userField, userSelection);
+    const unavailableFields = extractUnavailableFields(userField, userSelection, () => true);
     const extractedSelectionSet: SelectionSetNode = {
       kind: Kind.SELECTION_SET,
       selections: unavailableFields,
@@ -57,7 +57,7 @@ describe('extractUnavailableFields', () => {
       `{ email friends { id name email } }`,
     );
   });
-  it('excludes the fields only with __typename', () => {
+  it('excludes __typename', () => {
     const schema = makeExecutableSchema({
       typeDefs: /* GraphQL */ `
         type Query {
@@ -80,6 +80,7 @@ describe('extractUnavailableFields', () => {
             __typename
             id
             name
+            description
           }
         }
       }
@@ -102,11 +103,73 @@ describe('extractUnavailableFields', () => {
     if (!userField) {
       throw new Error('User field not found');
     }
-    const unavailableFields = extractUnavailableFields(userField, userSelection);
+    const unavailableFields = extractUnavailableFields(userField, userSelection, () => true);
     const extractedSelectionSet: SelectionSetNode = {
       kind: Kind.SELECTION_SET,
       selections: unavailableFields,
     };
-    expect(stripWhitespaces(print(extractedSelectionSet))).toBe('');
+    expect(stripWhitespaces(print(extractedSelectionSet))).toBe('{ friends { description } }');
+  });
+  it('picks the subfields only when available to resolve', () => {
+    const schema = makeExecutableSchema({
+      typeDefs: /* GraphQL */ `
+        type Query {
+          post: Post
+        }
+        type Post {
+          id: ID!
+        }
+      `,
+    });
+    const fieldNodesByField = {
+      Post: {
+        id: [],
+        name: [],
+      },
+      Category: {
+        id: [],
+        // details: undefined, // This field is not available to resolve
+      },
+    };
+    const postQuery = /* GraphQL */ `
+      query {
+        post {
+          id
+          name
+          category {
+            id
+            details
+          }
+        }
+      }
+    `;
+    const postQueryDoc = parse(postQuery, { noLocation: true });
+    const operationAst = getOperationAST(postQueryDoc, null);
+    if (!operationAst) {
+      throw new Error('Operation AST not found');
+    }
+    const selectionSet = operationAst.selectionSet;
+    const postSelection = selectionSet.selections[0];
+    if (postSelection.kind !== 'Field') {
+      throw new Error('Post selection not found');
+    }
+    const queryType = schema.getType('Query');
+    if (!isObjectType(queryType)) {
+      throw new Error('Query type not found');
+    }
+    const postField = queryType.getFields()['post'];
+    if (!postField) {
+      throw new Error('Post field not found');
+    }
+    const unavailableFields = extractUnavailableFields(
+      postField,
+      postSelection,
+      (fieldType, selection) => !fieldNodesByField?.[fieldType.name]?.[selection.name.value],
+    );
+    const extractedSelectionSet: SelectionSetNode = {
+      kind: Kind.SELECTION_SET,
+      selections: unavailableFields,
+    };
+    expect(stripWhitespaces(print(extractedSelectionSet))).toBe('{ category { id details } }');
   });
 });