Handle unresolved elements gracefully

Author: mduesterhoeft

packages/apollo-gateway/src/__tests__/__fixtures__/schemas/product.ts

@@ -8,6 +8,7 @@ export const typeDefs = gql`
 
   extend type Query {
     product(upc: String!): Product
+    products(upcs: [String!]!): [Product]
     vehicle(id: String!): Vehicle
     topProducts(first: Int = 5): [Product]
     topCars(first: Int = 5): [Car]
@@ -150,7 +151,8 @@ const products = [
   { __typename: 'Book', isbn: '0201633612', price: 49 },
   { __typename: 'Book', isbn: '1234567890', price: 59 },
   { __typename: 'Book', isbn: '404404404', price: 0 },
-  { __typename: 'Book', isbn: '0987654321', price: 29 },
+  { __typename: 'Book', isbn: '0987654321', price: 29, upc: '0987654321' },
+  { __typename: 'Book', isbn: '9999999999', price: 31, upc: '9999999999' },
 ];
 
 const vehicles = [
@@ -231,6 +233,10 @@ export const resolvers: GraphQLResolverMap<any> = {
     product(_, args) {
       return products.find(product => product.upc === args.upc);
     },
+    products(_, args) {
+      const upcs: Array<string> = args.upcs
+      return upcs.map(upc => products.find(product => product.upc === upc));
+    },
     vehicle(_, args) {
       return vehicles.find(vehicles => vehicles.id === args.id);
     },

packages/apollo-gateway/src/__tests__/executeQueryPlan.test.ts

@@ -672,4 +672,50 @@ describe('executeQueryPlan', () => {
       }
     `);
   });
+
+  it('can execute queries with selections on unresolved @requires fields', async () => {
+    // query a book not known to the book service
+    const query = gql`
+      query {
+        products(upcs: ["9999999999", "0987654321"]) {
+          upc
+          name
+          price
+        }
+      }
+    `;
+
+    const operationContext = buildOperationContext(schema, query);
+    const queryPlan = buildQueryPlan(operationContext);
+
+    const response = await executeQueryPlan(
+      queryPlan,
+      serviceMap,
+      buildRequestContext(),
+      operationContext,
+    );
+
+    expect(response.errors?.map(e => e.message)).toEqual(expect.arrayContaining([
+      "Cannot return null for non-nullable field Book.isbn.",
+      "Field \"title\" was not found in response.",
+      "Field \"year\" was not found in response.",
+    ]));
+
+    expect(response.data).toMatchInlineSnapshot(`
+      Object {
+        "products": Array [
+          Object {
+            "name": "undefined (undefined)",
+            "price": "31",
+            "upc": "9999999999",
+          },
+          Object {
+            "name": "No Books Like This Book! (2019)",
+            "price": "29",
+            "upc": "0987654321",
+          },
+        ],
+      }
+    `);
+  });
 });

packages/apollo-gateway/src/executeQueryPlan.ts

@@ -237,7 +237,7 @@ async function executeFetch<TContext>(
     const representationToEntity: number[] = [];
 
     entities.forEach((entity, index) => {
-      const representation = executeSelectionSet(entity, requires);
+      const representation = executeSelectionSet(entity, requires, context);
       if (representation && representation[TypeNameMetaFieldDef.name]) {
         representations.push(representation);
         representationToEntity.push(index);
@@ -388,9 +388,10 @@ async function executeFetch<TContext>(
  * @param source Result of GraphQL execution.
  * @param selectionSet
  */
-function executeSelectionSet(
+function executeSelectionSet<TContext>(
   source: Record<string, any> | null,
   selectionSet: SelectionSetNode,
+  context: ExecutionContext<TContext>,
 ): Record<string, any> {
   const result: Record<string, any> = Object.create(null);
 
@@ -409,16 +410,19 @@ function executeSelectionSet(
           break;
         }
         if (typeof source[responseName] === 'undefined') {
-          throw new Error(`Field "${responseName}" was not found in response.`);
+          // collect error but continue to resolve
+          context.errors.push(new GraphQLError(`Field "${responseName}" was not found in response.`));
+          break;
         }
         if (Array.isArray(source[responseName])) {
           result[responseName] = source[responseName].map((value: any) =>
-            selectionSet ? executeSelectionSet(value, selectionSet) : value,
+            selectionSet ? executeSelectionSet(value, selectionSet, context) : value,
           );
         } else if (selectionSet) {
           result[responseName] = executeSelectionSet(
             source[responseName],
             selectionSet,
+            context
           );
         } else {
           result[responseName] = source[responseName];
@@ -433,7 +437,7 @@ function executeSelectionSet(
         if (typename === selection.typeCondition.name.value) {
           deepMerge(
             result,
-            executeSelectionSet(source, selection.selectionSet),
+            executeSelectionSet(source, selection.selectionSet, context),
           );
         }
         break;