fix(stitch): handle nested dependencies in computed fields (#6180)

.changeset/rare-grapes-drive.md

@@ -0,0 +1,24 @@
+---
+"@graphql-tools/stitch": patch
+---
+
+Handle nested dependencies in the computed fields
+```ts
+{
+  merge: {
+    Product: {
+      selectionSet: '{ id }',
+      fields: {
+        isExpensive: {
+          selectionSet: '{ price }',
+          computed: true,
+        },
+        canAfford: {
+          selectionSet: '{ isExpensive }',
+          computed: true,
+        },
+      }
+    }
+  }
+}
+```

packages/federation/test/fixtures/federation-compatibility/requires-requires/supergraph.graphql

@@ -0,0 +1,67 @@
+schema
+  @link(url: "https://specs.apollo.dev/link/v1.0")
+  @link(url: "https://specs.apollo.dev/join/v0.3", for: EXECUTION)
+  @link(url: "https://specs.apollo.dev/inaccessible/v0.2", for: SECURITY)
+{
+  query: Query
+}
+
+directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+
+directive @join__enumValue(graph: join__Graph!) repeatable on ENUM_VALUE
+
+directive @join__field(graph: join__Graph, requires: join__FieldSet, provides: join__FieldSet, type: String, external: Boolean, override: String, usedOverridden: Boolean) repeatable on FIELD_DEFINITION | INPUT_FIELD_DEFINITION
+
+directive @join__graph(name: String!, url: String!) on ENUM_VALUE
+
+directive @join__implements(graph: join__Graph!, interface: String!) repeatable on OBJECT | INTERFACE
+
+directive @join__type(graph: join__Graph!, key: join__FieldSet, extension: Boolean! = false, resolvable: Boolean! = true, isInterfaceObject: Boolean! = false) repeatable on OBJECT | INTERFACE | UNION | ENUM | INPUT_OBJECT | SCALAR
+
+directive @join__unionMember(graph: join__Graph!, member: String!) repeatable on UNION
+
+directive @link(url: String, as: String, for: link__Purpose, import: [link__Import]) repeatable on SCHEMA
+
+scalar join__FieldSet
+
+enum join__Graph {
+  A @join__graph(name: "a", url: "https://federation-compatibility.the-guild.dev/requires-requires/a")
+  B @join__graph(name: "b", url: "https://federation-compatibility.the-guild.dev/requires-requires/b")
+  C @join__graph(name: "c", url: "https://federation-compatibility.the-guild.dev/requires-requires/c")
+  D @join__graph(name: "d", url: "https://federation-compatibility.the-guild.dev/requires-requires/d")
+}
+
+scalar link__Import
+
+enum link__Purpose {
+  """
+  `SECURITY` features provide metadata necessary to securely resolve fields.
+  """
+  SECURITY
+
+  """
+  `EXECUTION` features provide metadata necessary for operation execution.
+  """
+  EXECUTION
+}
+
+type Product
+  @join__type(graph: A, key: "id")
+  @join__type(graph: B, key: "id")
+  @join__type(graph: C, key: "id")
+  @join__type(graph: D, key: "id")
+{
+  id: ID!
+  price: Float! @inaccessible @join__field(graph: A) @join__field(graph: C, external: true)
+  isExpensive: Boolean! @join__field(graph: C, requires: "price") @join__field(graph: D, external: true)
+  canAfford: Boolean! @join__field(graph: D, requires: "isExpensive")
+}
+
+type Query
+  @join__type(graph: A)
+  @join__type(graph: B)
+  @join__type(graph: C)
+  @join__type(graph: D)
+{
+  product: Product @join__field(graph: B)
+}

packages/federation/test/fixtures/federation-compatibility/requires-requires/tests.json

@@ -0,0 +1,33 @@
+[
+  {
+    "query": "\n      query {\n        product {\n          canAfford\n        }\n      }\n    ",
+    "expected": {
+      "data": {
+        "product": {
+          "canAfford": false
+        }
+      }
+    }
+  },
+  {
+    "query": "\n      query {\n        product {\n          isExpensive\n        }\n      }\n    ",
+    "expected": {
+      "data": {
+        "product": {
+          "isExpensive": true
+        }
+      }
+    }
+  },
+  {
+    "query": "\n      query {\n        product {\n          isExpensive\n          canAfford\n        }\n      }\n    ",
+    "expected": {
+      "data": {
+        "product": {
+          "isExpensive": true,
+          "canAfford": false
+        }
+      }
+    }
+  }
+]

packages/stitch/src/getFieldsNotInSubschema.ts

@@ -1,6 +1,7 @@
 import {
   FieldNode,
   FragmentDefinitionNode,
+  GraphQLField,
   GraphQLNamedOutputType,
   GraphQLObjectType,
   GraphQLSchema,
@@ -55,19 +56,65 @@ export function getFieldsNotInSubschema(
         }
       }
     }
-    const fieldNodesForField = fieldNodesByField?.[gatewayType.name]?.[fieldName];
-    if (fieldNodesForField) {
-      for (const fieldNode of fieldNodesForField) {
-        if (fieldNode.name.value !== '__typename' && !fields[fieldNode.name.value]) {
-          // consider node that depends on something not in the schema as not in the schema
-          for (const subFieldNode of subFieldNodes) {
-            fieldsNotInSchema.add(subFieldNode);
+    let addedSubFieldNodes = false;
+    const fieldNodesByFieldForType = fieldNodesByField?.[gatewayType.name];
+    const visitedFieldNames = new Set<string>();
+    if (fieldNodesByFieldForType) {
+      addMissingRequiredFields({
+        fieldName,
+        fields,
+        fieldsNotInSchema,
+        visitedFieldNames,
+        onAdd: () => {
+          if (!addedSubFieldNodes) {
+            for (const subFieldNode of subFieldNodes) {
+              fieldsNotInSchema.add(subFieldNode);
+            }
+            addedSubFieldNodes = true;
           }
-          fieldsNotInSchema.add(fieldNode);
-        }
-      }
+        },
+        fieldNodesByField: fieldNodesByFieldForType,
+      });
     }
   }
 
   return Array.from(fieldsNotInSchema);
 }
+
+function addMissingRequiredFields({
+  fieldName,
+  fields,
+  fieldsNotInSchema,
+  onAdd,
+  fieldNodesByField,
+  visitedFieldNames,
+}: {
+  fieldName: string;
+  fields: Record<string, GraphQLField<any, any>>;
+  fieldsNotInSchema: Set<FieldNode>;
+  onAdd: VoidFunction;
+  fieldNodesByField: Record<string, FieldNode[]>;
+  visitedFieldNames: Set<string>;
+}) {
+  if (visitedFieldNames.has(fieldName)) {
+    return;
+  }
+  visitedFieldNames.add(fieldName);
+  const fieldNodesForField = fieldNodesByField?.[fieldName];
+  if (fieldNodesForField) {
+    for (const fieldNode of fieldNodesForField) {
+      if (fieldNode.name.value !== '__typename' && !fields[fieldNode.name.value]) {
+        onAdd();
+        fieldsNotInSchema.add(fieldNode);
+        addMissingRequiredFields({
+          fieldName: fieldNode.name.value,
+          fields,
+          fieldsNotInSchema,
+          onAdd,
+          fieldNodesByField,
+          visitedFieldNames,
+        });
+      }
+    }
+  }
+}