@apollo/gateway 2.4.1 → 2.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apollo/gateway",
-  "version": "2.4.1",
+  "version": "2.4.3",
   "description": "Apollo Gateway",
   "author": "Apollo <packages@apollographql.com>",
   "main": "dist/index.js",
@@ -25,9 +25,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@apollo/composition": "2.4.1",
-    "@apollo/federation-internals": "2.4.1",
-    "@apollo/query-planner": "2.4.1",
+    "@apollo/composition": "2.4.3",
+    "@apollo/federation-internals": "2.4.3",
+    "@apollo/query-planner": "2.4.3",
     "@apollo/server-gateway-interface": "^1.1.0",
     "@apollo/usage-reporting-protobuf": "^4.1.0",
     "@apollo/utils.createhash": "^2.0.0",

package/src/__tests__/executeQueryPlan.test.ts

@@ -3802,10 +3802,15 @@ describe('executeQueryPlan', () => {
       s1,
     }: {
       s1?: {
+        // additional resolvers for interface I
         iResolversExtra?: any,
+        // provide a default __resolveReference for the interface
         hasIResolveReference?: boolean,
+        // turn an id into extra data returned by __resolveReference (if hasIResolveReference is true)
         iResolveReferenceExtra?: (id: string) => { [k: string]: any },
+        // additional resolvers for type A
         aResolversExtra?: any,
+        // additional resolvers for type B
         bResolversExtra?: any,
       }
     }) => {
@@ -4136,7 +4141,75 @@ describe('executeQueryPlan', () => {
         + 'Either the object returned by "I.__resolveReference" must include a valid `__typename` field, '
         + 'or the "I" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.'
       ],
-    }])('resolving an interface @key $name', async ({s1, expectedErrors}) => {
+    }, {
+      name: 'with an async __resolveReference and a non-default __resolveType',
+      s1: {
+        iResolversExtra: {
+          async __resolveReference(ref: { id: string }) {
+            return ref.id === 'idA'
+              ? { id: ref.id, x: 1, z: 3 }
+              : { id: ref.id, x: 10, w: 30 };
+          },
+          __resolveType(ref: { id: string }) {
+            switch (ref.id) {
+              case 'idA':
+                return 'A';
+              case 'idB':
+                return 'B';
+              default:
+                throw new Error('Unknown type: ' + ref.id);
+            }
+          },
+        },
+      },
+    }, {
+      name: 'with an async __resolveReference and a non-default async __resolveType',
+      s1: {
+        iResolversExtra: {
+          async __resolveReference(ref: { id: string }) {
+            return ref.id === 'idA'
+              ? { id: ref.id, x: 1, z: 3 }
+              : { id: ref.id, x: 10, w: 30 };
+          },
+          async __resolveType(ref: { id: string }) {
+            switch (ref.id) {
+              case 'idA':
+                return 'A';
+              case 'idB':
+                return 'B';
+              default:
+                throw new Error('Unknown type: ' + ref.id);
+            }
+          },
+        },
+      },
+    }, {
+      name: 'with an async __resolveReference and async __isTypeOf on implementations',
+      s1: {
+        iResolversExtra: {
+          async __resolveReference(ref: {
+            id: string;
+            // I don't understand the TypeScript error that occurs when the
+            // return type is removed here (like all the others); it surfaces
+            // because `aResolversExtra` is defined, which I can't explain.
+          }): Promise<Record<string, any>> {
+            return ref.id === 'idA'
+              ? { id: ref.id, x: 1, z: 3 }
+              : { id: ref.id, x: 10, w: 30 };
+          },
+        },
+        aResolversExtra: {
+          async __isTypeOf(ref: { id: string }) {
+            return ref.id === 'idA';
+          },
+        },
+        bResolversExtra: {
+          async __isTypeOf(ref: { id: string }) {
+            return ref.id === 'idB';
+          },
+        },
+      },
+    }])('resolving an interface @key $name', async ({ s1, expectedErrors }) => {
       const tester = defineSchema({ s1 });
 
       const { plan, response } = await tester(`
@@ -4863,6 +4936,251 @@ describe('executeQueryPlan', () => {
         }
       `);
     });
+
+    test('handles @requires on @interfaceObject that applies to only one of the queried implementation', async () => {
+      // The case this test is that where the @interfaceObject in s2 has a @requires, but the query we send requests the field on which
+      // there is this @require only for one of the implementation type, which it request another field with no require for another implementation.
+      // And we're making sure the requirements only get queried for T1, the first type.
+      const s1 = {
+        name: 's1',
+        typeDefs: gql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/v2.4", import: ["@key"])
+
+          type Query {
+            is: [I!]!
+          }
+
+          interface I @key(fields: "id") {
+            id: ID!
+            name: String
+            req: Req
+          }
+
+          type T1 implements I @key(fields: "id") {
+            id: ID!
+            name: String
+            req: Req
+          }
+
+          type T2 implements I @key(fields: "id") {
+            id: ID!
+            name: String
+            req: Req
+          }
+
+          type Req {
+            id: ID!
+          }
+        `,
+        resolvers: {
+          Query: {
+            is: () => [
+              { __typename: 'T1', id: '2', name: 'e2', req: { id: 'r1'} },
+              { __typename: 'T2', id: '4', name: 'e4', req: { id: 'r2'} },
+              { __typename: 'T1', id: '1', name: 'e1', req: { id: 'r3'} }
+            ]
+          },
+        }
+      }
+
+      const s2 = {
+        name: 's2',
+        typeDefs: gql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/v2.4", import: ["@key", "@interfaceObject", "@external", "@requires"])
+
+          type I @key(fields: "id") @interfaceObject {
+            id: ID!
+            req: Req @external
+            v: String! @requires(fields: "req { id }")
+          }
+
+          type Req {
+            id: ID! @external
+          }
+        `,
+        resolvers: {
+          I: {
+            __resolveReference(ref: any) {
+              return {
+                ...ref,
+                v: `req=${ref.req.id}`
+              };
+            },
+          }
+        }
+      }
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2 ]);
+
+      let operation = parseOp(`
+        {
+          is {
+            ... on T1 {
+              v
+            }
+            ... on T2 {
+              name
+            }
+          }
+        }
+        `, schema);
+
+      let queryPlan = buildPlan(operation, queryPlanner);
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "s1") {
+              {
+                is {
+                  __typename
+                  ... on T1 {
+                    __typename
+                    id
+                    req {
+                      id
+                    }
+                  }
+                  ... on T2 {
+                    name
+                  }
+                }
+              }
+            },
+            Flatten(path: "is.@") {
+              Fetch(service: "s2") {
+                {
+                  ... on T1 {
+                    __typename
+                    id
+                  }
+                  ... on I {
+                    __typename
+                    req {
+                      id
+                    }
+                  }
+                } =>
+                {
+                  ... on I {
+                    v
+                  }
+                }
+              },
+            },
+          },
+        }
+      `);
+
+      let response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      expect(response.errors).toBeUndefined();
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "is": Array [
+            Object {
+              "v": "req=r1",
+            },
+            Object {
+              "name": "e4",
+            },
+            Object {
+              "v": "req=r3",
+            },
+          ],
+        }
+      `);
+
+      // Sanity checking that if we ask for `v` (the field with @requires), then everything still works.
+      operation = parseOp(`
+        {
+          is {
+            ... on T1 {
+              v
+            }
+            ... on T2 {
+              v
+              name
+            }
+          }
+        }
+        `, schema);
+
+      global.console = require('console');
+      queryPlan = buildPlan(operation, queryPlanner);
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "s1") {
+              {
+                is {
+                  __typename
+                  ... on T1 {
+                    __typename
+                    id
+                    req {
+                      id
+                    }
+                  }
+                  ... on T2 {
+                    __typename
+                    id
+                    req {
+                      id
+                    }
+                    name
+                  }
+                }
+              }
+            },
+            Flatten(path: "is.@") {
+              Fetch(service: "s2") {
+                {
+                  ... on T1 {
+                    __typename
+                    id
+                  }
+                  ... on I {
+                    __typename
+                    req {
+                      id
+                    }
+                  }
+                  ... on T2 {
+                    __typename
+                    id
+                  }
+                } =>
+                {
+                  ... on I {
+                    v
+                  }
+                }
+              },
+            },
+          },
+        }
+      `);
+
+      response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      expect(response.errors).toBeUndefined();
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "is": Array [
+            Object {
+              "v": "req=r1",
+            },
+            Object {
+              "name": "e4",
+              "v": "req=r2",
+            },
+            Object {
+              "v": "req=r3",
+            },
+          ],
+        }
+      `);
+    });
   });
 
   describe('fields with conflicting types needing aliasing', () => {