Resolve fields from other subschemas when merging types from subscriptions in additional type defs (#8740)

* full delegate when resolving subscription event

* resolve actually

* resolve shippingestimate

* changelog

* proper comments

Author: enisdenjo

.changeset/spotty-pigs-sell.md

@@ -0,0 +1,5 @@
+---
+'@graphql-mesh/utils': patch
+---
+
+Resolve fields from other subschemas when merging types from subscriptions in additional type defs

e2e/subscriptions-type-merging/mesh.config.ts

@@ -10,6 +10,11 @@ export const composeConfig = defineConfig({
         endpoint: `http://localhost:${opts.getServicePort('products')}/graphql`,
       }),
     },
+    {
+      sourceHandler: loadGraphQLHTTPSubgraph('inventory', {
+        endpoint: `http://localhost:${opts.getServicePort('inventory')}/graphql`,
+      }),
+    },
   ],
   additionalTypeDefs: /* GraphQL */ `
     extend schema {

e2e/subscriptions-type-merging/services/inventory.ts

@@ -0,0 +1,37 @@
+import { createServer } from 'node:http';
+import { parse } from 'graphql';
+import { createYoga } from 'graphql-yoga';
+import { buildSubgraphSchema } from '@apollo/subgraph';
+import { Opts } from '@e2e/opts';
+
+const port = Opts(process.argv).getServicePort('inventory');
+
+createServer(
+  createYoga({
+    schema: buildSubgraphSchema({
+      typeDefs: parse(/* GraphQL */ `
+        type Query {
+          hello: String!
+        }
+        type Product @key(fields: "id") {
+          id: ID! @external
+          price: Float! @external
+          shippingEstimate: Int @requires(fields: "price")
+        }
+      `),
+      resolvers: {
+        Query: {
+          hello: () => 'world',
+        },
+        Product: {
+          __resolveReference: ref => ({
+            ...ref,
+            shippingEstimate: Math.floor(ref.price / 10),
+          }),
+        },
+      },
+    }),
+  }),
+).listen(port, () => {
+  console.log(`Inventory subgraph running on http://localhost:${port}/graphql`);
+});

e2e/subscriptions-type-merging/subscriptions-type-merging.test.ts

@@ -37,7 +37,8 @@ afterAll(async () => {
 
 it('consumes the pubsub topics and resolves the types correctly', async () => {
   await using products = await service('products');
-  await using composition = await compose({ output: 'graphql', services: [products] });
+  await using inventory = await service('inventory');
+  await using composition = await compose({ output: 'graphql', services: [products, inventory] });
   await using gw = await serve({ supergraph: composition.output, env: redisEnv });
   const sseClient = createClient({
     retryAttempts: 0,
@@ -51,6 +52,7 @@ it('consumes the pubsub topics and resolves the types correctly', async () => {
           id
           name
           price
+          shippingEstimate
         }
       }
     `,
@@ -77,6 +79,7 @@ it('consumes the pubsub topics and resolves the types correctly', async () => {
             id,
             name: 'Roomba X' + id,
             price: 100,
+            shippingEstimate: 10,
           },
         },
       },
@@ -89,6 +92,7 @@ it('consumes the pubsub topics and resolves the types correctly', async () => {
             id: 'noid',
             name: 'Roborock 80P',
             price: 100,
+            shippingEstimate: 10,
           },
         },
       },

packages/legacy/utils/src/resolve-additional-resolvers.ts

@@ -5,9 +5,17 @@ import type {
   GraphQLResolveInfo,
   GraphQLSchema,
   GraphQLType,
+  OperationTypeNode,
   SelectionSetNode,
 } from 'graphql';
-import { getNamedType, isAbstractType, isInterfaceType, isObjectType, Kind } from 'graphql';
+import {
+  getNamedType,
+  GraphQLList,
+  isAbstractType,
+  isInterfaceType,
+  isObjectType,
+  Kind,
+} from 'graphql';
 import lodashGet from 'lodash.get';
 import toPath from 'lodash.topath';
 import { process } from '@graphql-mesh/cross-helpers';
@@ -20,9 +28,11 @@ import {
   type MeshPubSub,
   type YamlConfig,
 } from '@graphql-mesh/types';
+import { batchDelegateToSchema } from '@graphql-tools/batch-delegate';
 import {
+  delegateToSchema,
   subtractSelectionSets,
-  type MergedTypeResolver,
+  type MergedTypeConfig,
   type StitchingInfo,
   type Subschema,
 } from '@graphql-tools/delegate';
@@ -224,7 +234,7 @@ export function resolveAdditionalResolversWithoutImport(
               return resolvePayload(payload); // no stitching, cannot be resolved anywhere else
             }
             const returnTypeName = getNamedType(info.returnType).name;
-            const mergedTypeInfo = stitchingInfo?.mergedTypes?.[returnTypeName];
+            const mergedTypeInfo = stitchingInfo.mergedTypes[returnTypeName];
             if (!mergedTypeInfo) {
               return resolvePayload(payload); // this type is not merged or resolvable
             }
@@ -244,39 +254,65 @@ export function resolveAdditionalResolversWithoutImport(
               return resolvePayload(payload);
             }
 
-            // find the best resolver by diffing the selection sets
-            let resolver: MergedTypeResolver | null = null;
+            // find the best subgraph by diffing the selection sets
             let subschema: Subschema | null = null;
+            let mergedTypeConfig: MergedTypeConfig | null = null;
             for (const [requiredSubschema, requiredSelSet] of mergedTypeInfo.selectionSets) {
-              const matchResolver = mergedTypeInfo?.resolvers.get(requiredSubschema);
-              if (!matchResolver) {
-                // the subschema has no resolvers, nothing to search for
+              const tentativeMergedTypeConfig = requiredSubschema.merge?.[returnTypeName];
+              if (tentativeMergedTypeConfig?.fields) {
+                // this resolver requires additional fields (think `@requires(fields: "x")`)
+                // TODO: actually implement whether the payload already contains those fields
+                // TODO: is there a better way for finding a match?
                 continue;
               }
               const diff = subtractSelectionSets(requiredSelSet, availableSelSet);
               if (!diff.selections.length) {
                 // all of the fields of the requesting (available) selection set is exist in the required selection set
-                resolver = matchResolver;
                 subschema = requiredSubschema;
+                mergedTypeConfig = tentativeMergedTypeConfig;
                 break;
               }
             }
-            if (!resolver || !subschema) {
+            if (!subschema || !mergedTypeConfig) {
               // the type cannot be resolved
               return resolvePayload(payload);
             }
 
             return handleMaybePromise(
-              () =>
-                resolver(
-                  payload,
-                  ctx,
-                  info,
-                  subschema,
-                  missingSelectionSet,
-                  undefined,
-                  info.returnType,
-                ),
+              () => {
+                if (mergedTypeConfig.argsFromKeys) {
+                  return batchDelegateToSchema({
+                    schema: subschema,
+                    operation: 'query' as OperationTypeNode,
+                    fieldName: mergedTypeConfig.fieldName,
+                    returnType: new GraphQLList(info.returnType),
+                    key: mergedTypeConfig.key?.(payload) || payload, // TODO: should use valueFromResults on the args too?
+                    argsFromKeys: mergedTypeConfig.argsFromKeys,
+                    valuesFromResults: mergedTypeConfig.valuesFromResults,
+                    selectionSet: missingSelectionSet,
+                    context: ctx,
+                    info,
+                    dataLoaderOptions: mergedTypeConfig.dataLoaderOptions,
+                    skipTypeMerging: false, // important to be false so that fields outside this subgraph can be resolved properly
+                  });
+                }
+                if (mergedTypeConfig.args) {
+                  return delegateToSchema({
+                    schema: subschema,
+                    operation: 'query' as OperationTypeNode,
+                    fieldName: mergedTypeConfig.fieldName,
+                    returnType: info.returnType,
+                    args: mergedTypeConfig.args(payload), // TODO: should use valueFromResults on the args too?
+                    selectionSet: missingSelectionSet,
+                    context: ctx,
+                    info,
+                    skipTypeMerging: false, // important to be false so that fields outside this subgraph can be resolved properly
+                  });
+                }
+                // no way to delegate to anything, return empty - i.e. resolve just payload
+                // should not happen though, there'll be something to use
+                return {};
+              },
               resolved => resolvePayload(mergeDeep([payload, resolved])),
             );
           },