Fix nested computed fields (#6469)

Author: ardatan

.changeset/stale-feet-rhyme.md

@@ -0,0 +1,41 @@
+---
+'@graphql-tools/federation': patch
+'@graphql-tools/delegate': patch
+---
+
+Handle merged selection sets in the computed fields;
+
+When a selection set for a computed field needs to be merged, resolve that required selection set fully then resolve the computed field.
+In the following case, the selection set for the `author` field in the `Post` type is merged with the selection set for the `authorId` field in the `Comment` type.
+
+```graphql
+type Query {
+  feed: [Post!]!
+}
+
+type Post {
+  id: ID!
+  author: User! @computed(selectionSet: "{ comments { authorId } }")
+}
+
+type Comment {
+  id: ID!
+  authorId: ID!
+}
+
+type User {
+  id: ID!
+  name: String!
+}
+```
+
+```graphql
+type Post {
+  id: ID!
+  comments: [Comment!]!
+}
+
+type Comment {
+  id: ID!
+}
+```

packages/delegate/src/defaultMergedResolver.ts

@@ -1,5 +1,6 @@
 import {
   defaultFieldResolver,
+  FieldNode,
   GraphQLResolveInfo,
   Kind,
   responsePathAsArray,
@@ -15,7 +16,11 @@ import {
 } from './mergeFields.js';
 import { resolveExternalValue } from './resolveExternalValue.js';
 import { Subschema } from './Subschema.js';
-import { FIELD_SUBSCHEMA_MAP_SYMBOL, UNPATHED_ERRORS_SYMBOL } from './symbols.js';
+import {
+  FIELD_SUBSCHEMA_MAP_SYMBOL,
+  OBJECT_SUBSCHEMA_SYMBOL,
+  UNPATHED_ERRORS_SYMBOL,
+} from './symbols.js';
 import { ExternalObject, MergedTypeResolver, StitchingInfo } from './types.js';
 
 /**
@@ -66,6 +71,7 @@ export function defaultMergedResolver(
       }
       const deferred = createDeferred();
       missingDeferredFields.set(responseKey, deferred);
+      handleResult(parent, responseKey, context, info);
       return deferred.promise;
     }
     return undefined;
@@ -110,16 +116,35 @@ function handleLeftOver<TContext extends Record<string, any>>(
   if (stitchingInfo) {
     for (const possibleSubschema of leftOver.nonProxiableSubschemas) {
       const parentTypeName = info.parentType.name;
-      const selectionSet =
+      const selectionSets = new Set<SelectionSetNode>();
+      const mainSelectionSet =
         stitchingInfo.mergedTypes[parentTypeName].selectionSets.get(possibleSubschema);
+      if (mainSelectionSet) {
+        selectionSets.add(mainSelectionSet);
+      }
+      for (const fieldNode of leftOver.unproxiableFieldNodes) {
+        const fieldName = fieldNode.name.value;
+        const fieldSelectionSet =
+          stitchingInfo.mergedTypes[parentTypeName].fieldSelectionSets.get(possibleSubschema)?.[
+            fieldName
+          ];
+        if (fieldSelectionSet) {
+          selectionSets.add(fieldSelectionSet);
+        }
+      }
       // Wait until the parent is flattened, then check if non proxiable subschemas are satisfied now,
       // then the deferred fields can be resolved
-      if (selectionSet) {
+      if (selectionSets.size) {
+        const selectionSet: SelectionSetNode = {
+          kind: Kind.SELECTION_SET,
+          selections: Array.from(selectionSets).flatMap(selectionSet => selectionSet.selections),
+        };
         const flattenedParent$ = flattenPromise(parent);
         if (isPromise(flattenedParent$)) {
           flattenedParent$.then(flattenedParent => {
             handleFlattenedParent(
               flattenedParent,
+              parent,
               possibleSubschema,
               selectionSet,
               leftOver,
@@ -132,6 +157,7 @@ function handleLeftOver<TContext extends Record<string, any>>(
         } else {
           handleFlattenedParent(
             flattenedParent$,
+            parent,
             possibleSubschema,
             selectionSet,
             leftOver,
@@ -148,6 +174,7 @@ function handleLeftOver<TContext extends Record<string, any>>(
 
 function handleFlattenedParent<TContext extends Record<string, any>>(
   flattenedParent: ExternalObject,
+  leftOverParent: ExternalObject,
   possibleSubschema: Subschema,
   selectionSet: SelectionSetNode,
   leftOver: DelegationPlanLeftOver,
@@ -158,7 +185,8 @@ function handleFlattenedParent<TContext extends Record<string, any>>(
 ) {
   // If this subschema is satisfied now, try to resolve the deferred fields
   if (parentSatisfiedSelectionSet(flattenedParent, selectionSet)) {
-    for (const [leftOverParent, missingFieldNodes] of leftOver.missingFieldsParentMap) {
+    const missingFieldNodes = leftOver.missingFieldsParentMap.get(leftOverParent);
+    if (missingFieldNodes) {
       const resolver = stitchingInfo.mergedTypes[parentTypeName].resolvers.get(possibleSubschema);
       if (resolver) {
         try {
@@ -208,6 +236,84 @@ function handleFlattenedParent<TContext extends Record<string, any>>(
         }
       }
     }
+  } else {
+    // try to resolve the missing fields
+    for (const selectionNode of selectionSet.selections) {
+      if (selectionNode.kind === Kind.FIELD && selectionNode.selectionSet?.selections?.length) {
+        const responseKey = selectionNode.alias?.value ?? selectionNode.name.value;
+        const nestedParent = flattenedParent[responseKey];
+        const nestedSelectionSet = selectionNode.selectionSet;
+        if (nestedParent != null) {
+          if (!parentSatisfiedSelectionSet(nestedParent, nestedSelectionSet)) {
+            async function handleNestedParentItem(nestedParentItem: any, fieldNode: FieldNode) {
+              const nestedTypeName = nestedParentItem['__typename'];
+              const sourceSubschema = getSubschema(flattenedParent, responseKey) as Subschema;
+              if (sourceSubschema && nestedTypeName) {
+                const delegationPlan = stitchingInfo.mergedTypes[
+                  nestedTypeName
+                ].delegationPlanBuilder(
+                  info.schema,
+                  sourceSubschema,
+                  info.variableValues,
+                  info.fragments,
+                  [fieldNode],
+                );
+                // Later optimize
+                for (const delegationMap of delegationPlan) {
+                  for (const [subschema, selectionSet] of delegationMap) {
+                    const resolver =
+                      stitchingInfo.mergedTypes[nestedTypeName].resolvers.get(subschema);
+                    if (resolver) {
+                      const res = await resolver(
+                        nestedParentItem,
+                        context,
+                        info,
+                        subschema,
+                        selectionSet,
+                        info.parentType,
+                        info.parentType,
+                      );
+                      if (res) {
+                        handleResolverResult(
+                          res,
+                          subschema,
+                          selectionSet,
+                          nestedParentItem,
+                          (nestedParentItem[FIELD_SUBSCHEMA_MAP_SYMBOL] ||= new Map()),
+                          info,
+                          responsePathAsArray(info.path),
+                          (nestedParentItem[UNPATHED_ERRORS_SYMBOL] ||= []),
+                        );
+                      }
+                    }
+                  }
+                }
+                if (parentSatisfiedSelectionSet(nestedParent, nestedSelectionSet)) {
+                  handleFlattenedParent(
+                    flattenedParent,
+                    leftOverParent,
+                    possibleSubschema,
+                    selectionSet,
+                    leftOver,
+                    stitchingInfo,
+                    parentTypeName,
+                    context,
+                    info,
+                  );
+                }
+              }
+            }
+            if (Array.isArray(nestedParent)) {
+              nestedParent.forEach(nestedParentItem =>
+                handleNestedParentItem(nestedParentItem, selectionNode),
+              );
+            } else {
+              handleNestedParentItem(nestedParent, selectionNode);
+            }
+          }
+        }
+      }
+    }
   }
 }
 
@@ -339,6 +445,15 @@ function flattenPromise<T>(data: T): Promise<T> | T {
         newData[key] = keyResult;
       }
     }
+    if (data[OBJECT_SUBSCHEMA_SYMBOL]) {
+      newData[OBJECT_SUBSCHEMA_SYMBOL] = data[OBJECT_SUBSCHEMA_SYMBOL];
+    }
+    if (data[FIELD_SUBSCHEMA_MAP_SYMBOL]) {
+      newData[FIELD_SUBSCHEMA_MAP_SYMBOL] = data[FIELD_SUBSCHEMA_MAP_SYMBOL];
+    }
+    if (data[UNPATHED_ERRORS_SYMBOL]) {
+      newData[UNPATHED_ERRORS_SYMBOL] = data[UNPATHED_ERRORS_SYMBOL];
+    }
     if (jobs.length) {
       return Promise.all(jobs).then(() => newData) as Promise<T>;
     }

packages/delegate/src/mergeFields.ts

@@ -37,9 +37,9 @@ export function annotateExternalObject<TContext>(
   subschemaMap: Record<string, GraphQLSchema | SubschemaConfig<any, any, any, Record<string, any>>>,
 ): ExternalObject {
   Object.defineProperties(object, {
-    [OBJECT_SUBSCHEMA_SYMBOL]: { value: subschema },
-    [FIELD_SUBSCHEMA_MAP_SYMBOL]: { value: subschemaMap },
-    [UNPATHED_ERRORS_SYMBOL]: { value: errors },
+    [OBJECT_SUBSCHEMA_SYMBOL]: { value: subschema, writable: true },
+    [FIELD_SUBSCHEMA_MAP_SYMBOL]: { value: subschemaMap, writable: true },
+    [UNPATHED_ERRORS_SYMBOL]: { value: errors, writable: true },
   });
   return object;
 }

packages/delegate/src/resolveExternalValue.ts

@@ -178,7 +178,7 @@ function reportUnpathedErrorsViaNull(unpathedErrors: Array<GraphQLError>) {
 
     if (unreportedErrors.length) {
       if (unreportedErrors.length === 1) {
-        return unreportedErrors[0];
+        return locatedError(unreportedErrors[0], undefined as any, unreportedErrors[0].path as any);
       }
 
       return new AggregateError(

packages/federation/src/supergraph.ts

@@ -662,9 +662,12 @@ export function getStitchingOptionsFromSupergraphSdl(
         if (fieldsKeyMap) {
           const fieldsConfig: Record<string, MergedFieldConfig> = (mergedTypeConfig.fields = {});
           for (const [fieldName, fieldNameKey] of fieldsKeyMap) {
-            extraKeys.add(fieldNameKey);
+            const aliasedFieldNameKey = fieldNameKey.includes('(')
+              ? `_${fieldNameKey.split('(')[0]}: ${fieldNameKey}`
+              : fieldNameKey;
+            extraKeys.add(aliasedFieldNameKey);
             fieldsConfig[fieldName] = {
-              selectionSet: `{ ${fieldNameKey} }`,
+              selectionSet: `{ ${aliasedFieldNameKey} }`,
               computed: true,
             };
           }

packages/federation/src/utils.ts

@@ -24,20 +24,21 @@ export function projectDataSelectionSet(data: any, selectionSet?: SelectionSetNo
   };
   for (const selection of selectionSet.selections) {
     if (selection.kind === Kind.FIELD) {
-      const key = selection.name.value;
-      if (Object.prototype.hasOwnProperty.call(data, key)) {
-        const projectedKeyData = projectDataSelectionSet(data[key], selection.selectionSet);
-        if (projectedData[key]) {
+      const fieldName = selection.name.value;
+      const responseKey = selection.alias?.value || selection.name.value;
+      if (Object.prototype.hasOwnProperty.call(data, responseKey)) {
+        const projectedKeyData = projectDataSelectionSet(data[responseKey], selection.selectionSet);
+        if (projectedData[fieldName]) {
           if (projectedKeyData != null && !(projectedKeyData instanceof Error)) {
-            projectedData[key] = mergeDeep(
-              [projectedData[key], projectedKeyData],
+            projectedData[fieldName] = mergeDeep(
+              [projectedData[fieldName], projectedKeyData],
               undefined,
               true,
               true,
             );
           }
         } else {
-          projectedData[key] = projectedKeyData;
+          projectedData[fieldName] = projectedKeyData;
         }
       }
     } else if (selection.kind === Kind.INLINE_FRAGMENT) {

packages/federation/test/federation-compatibility.test.ts

@@ -21,7 +21,7 @@ import {
 } from '@graphql-tools/utils';
 import { getStitchedSchemaFromSupergraphSdl } from '../src/supergraph';
 
-describe.skip('Federation Compatibility', () => {
+describe('Federation Compatibility', () => {
   if (!existsSync(join(__dirname, 'fixtures', 'federation-compatibility'))) {
     console.warn('Make sure you fetched the fixtures from the API first');
     it.skip('skipping tests', () => {});