@apollo/gateway 2.0.0-alpha.4 → 2.0.0-preview.0

package/src/__tests__/executeQueryPlan.test.ts

@@ -19,7 +19,7 @@ import { QueryPlan, QueryPlanner } from '@apollo/query-planner';
 import { ApolloGateway } from '..';
 import { ApolloServerBase as ApolloServer } from 'apollo-server-core';
 import { getFederatedTestingSchema } from './execution-utils';
-import { Schema, Operation, parseOperation, buildSchemaFromAST } from '@apollo/federation-internals';
+import { Schema, Operation, parseOperation, buildSchemaFromAST, arrayEquals } from '@apollo/federation-internals';
 import { addResolversToSchema, GraphQLResolverMap } from '../schema-helper';
 
 expect.addSnapshotSerializer(astSerializer);
@@ -2736,4 +2736,259 @@ describe('executeQueryPlan', () => {
       expect(response.errors?.map((e) => e.message)).toStrictEqual(['String cannot represent value: ["invalid"]']);
     });
   });
+
+  describe('@key', () => {
+    test('Works on a list of scalar', async () => {
+      const s1_data = [
+        { id: [0, 1], f1: "foo" },
+        { id: [2, 3], f1: "bar" },
+        { id: [4, 5], f1: "baz" },
+      ];
+
+      const s1 = {
+        name: 'S1',
+        typeDefs: gql`
+          type T1 @key(fields: "id") {
+            id: [Int]
+            f1: String
+          }
+        `,
+        resolvers: {
+          T1: {
+            __resolveReference(ref: { id: number[] }) {
+              return s1_data.find((e) => arrayEquals(e.id, ref.id));
+            },
+          },
+        }
+      }
+
+      const s2 = {
+        name: 'S2',
+        typeDefs: gql`
+          type Query {
+            getT1s: [T1]
+          }
+
+          type T1 {
+            id: [Int]
+          }
+        `,
+        resolvers: {
+          Query: {
+            getT1s() {
+              return [{id: [2, 3]}, {id: [4, 5]}];
+            },
+          },
+        }
+      }
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2 ]);
+
+      const operation = parseOp(`
+        query {
+          getT1s {
+            id
+            f1
+          }
+        }
+        `, schema);
+      const queryPlan = buildPlan(operation, queryPlanner);
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "S2") {
+              {
+                getT1s {
+                  __typename
+                  id
+                }
+              }
+            },
+            Flatten(path: "getT1s.@") {
+              Fetch(service: "S1") {
+                {
+                  ... on T1 {
+                    __typename
+                    id
+                  }
+                } =>
+                {
+                  ... on T1 {
+                    f1
+                  }
+                }
+              },
+            },
+          },
+        }
+      `);
+
+      const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      // `null` should bubble up since `f2` is now non-nullable. But we should still get the `id: 0` response.
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "getT1s": Array [
+            Object {
+              "f1": "bar",
+              "id": Array [
+                2,
+                3,
+              ],
+            },
+            Object {
+              "f1": "baz",
+              "id": Array [
+                4,
+                5,
+              ],
+            },
+          ],
+        }
+        `);
+    });
+
+    test('Works on a list of objects', async () => {
+      const s1_data = [
+        { o: [{a: 0, b: "b0", c: "zero"}, {a: 1, b: "b1", c: "one"}], f1: "foo" },
+        { o: [{a: 2, b: "b2", c: "two"}], f1: "bar" },
+        { o: [{a: 3, b: "b3", c: "three"}, {a: 4, b: "b4", c: "four"}], f1: "baz" },
+      ];
+
+      const s1 = {
+        name: 'S1',
+        typeDefs: gql`
+          type T1 @key(fields: "o { a c }") {
+            o: [O]
+            f1: String
+          }
+
+          type O {
+            a: Int
+            b: String
+            c: String
+          }
+        `,
+        resolvers: {
+          T1: {
+            __resolveReference(ref: { o: {a : number, c: string}[] }) {
+              return s1_data.find((e) => arrayEquals(e.o, ref.o, (x, y) => x.a === y.a && x.c === y.c));
+            },
+          },
+        }
+      }
+
+      const s2 = {
+        name: 'S2',
+        typeDefs: gql`
+          type Query {
+            getT1s: [T1]
+          }
+
+          type T1 {
+            o: [O]
+          }
+
+          type O {
+            a: Int
+            b: String
+            c: String
+          }
+        `,
+        resolvers: {
+          Query: {
+            getT1s() {
+              return [{o: [{a: 2, b: "b2", c: "two"}]}, {o: [{a: 3, b: "b3", c: "three"}, {a: 4, b: "b4", c: "four"}]}];
+            },
+          },
+        }
+      }
+
+      const { serviceMap, schema, queryPlanner} = getFederatedTestingSchema([ s1, s2 ]);
+
+      const operation = parseOp(`
+        query {
+          getT1s {
+            o {
+              a
+              b
+              c
+            }
+            f1
+          }
+        }
+        `, schema);
+      const queryPlan = buildPlan(operation, queryPlanner);
+      expect(queryPlan).toMatchInlineSnapshot(`
+        QueryPlan {
+          Sequence {
+            Fetch(service: "S2") {
+              {
+                getT1s {
+                  __typename
+                  o {
+                    a
+                    c
+                    b
+                  }
+                }
+              }
+            },
+            Flatten(path: "getT1s.@") {
+              Fetch(service: "S1") {
+                {
+                  ... on T1 {
+                    __typename
+                    o {
+                      a
+                      c
+                    }
+                  }
+                } =>
+                {
+                  ... on T1 {
+                    f1
+                  }
+                }
+              },
+            },
+          },
+        }
+      `);
+
+      const response = await executePlan(queryPlan, operation, undefined, schema, serviceMap);
+      // `null` should bubble up since `f2` is now non-nullable. But we should still get the `id: 0` response.
+      expect(response.data).toMatchInlineSnapshot(`
+        Object {
+          "getT1s": Array [
+            Object {
+              "f1": "bar",
+              "o": Array [
+                Object {
+                  "a": 2,
+                  "b": "b2",
+                  "c": "two",
+                },
+              ],
+            },
+            Object {
+              "f1": "baz",
+              "o": Array [
+                Object {
+                  "a": 3,
+                  "b": "b3",
+                  "c": "three",
+                },
+                Object {
+                  "a": 4,
+                  "b": "b4",
+                  "c": "four",
+                },
+              ],
+            },
+          ],
+        }
+        `);
+    });
+  });
+
 });

package/src/__tests__/gateway/lifecycle-hooks.test.ts

@@ -18,6 +18,8 @@ import {
 } from 'apollo-federation-integration-testsuite';
 import { Logger } from 'apollo-server-types';
 import resolvable from '@josephg/resolvable';
+import { createHash } from '../../utilities/createHash';
+import { getTestingSupergraphSdl } from '../execution-utils';
 
 // The order of this was specified to preserve existing test coverage. Typically
 // we would just import and use the `fixtures` array.
@@ -135,13 +137,17 @@ describe('lifecycle hooks', () => {
 
     const [firstCall, secondCall] = mockDidUpdate.mock.calls;
 
-    const expectedFirstId = 'd20cfb7a9c51179aa494ed9e98153f0042892bd225437af064bf1c1aa68eab86'
+    // Note that we've composing our usual test fixtures here 
+    const expectedFirstId = createHash('sha256').update(getTestingSupergraphSdl()).digest('hex');
     expect(firstCall[0]!.compositionId).toEqual(expectedFirstId);
     // first call should have no second "previous" argument
     expect(firstCall[1]).toBeUndefined();
 
+    // Note that this assertion is a tad fragile in that every time we modify
+    // the supergraph (even just formatting differences), this ID will change
+    // and this test will have to updated. 
     expect(secondCall[0]!.compositionId).toEqual(
-      '7dad7ab8284165a86241b8973d71f0d6ac8cb142095c717dd23443522850c225',
+      '3ca7f295b11b070d1e1b56a698cbfabb70cb2b5912a4ff0ecae2fb91e8709838',
     );
     // second call should have previous info in the second arg
     expect(secondCall[1]!.compositionId).toEqual(expectedFirstId);

package/src/__tests__/gateway/supergraphSdl.test.ts

@@ -53,6 +53,8 @@ afterEach(async () => {
   }
 });
 
+const testingFixturesDefaultCompositionId = createHash('sha256').update(getTestingSupergraphSdl()).digest('hex');
+
 describe('Using supergraphSdl static configuration', () => {
   it('successfully starts and serves requests to the proper services', async () => {
     const server = await getSupergraphSdlGatewayServer();
@@ -187,7 +189,7 @@ describe('Using supergraphSdl dynamic configuration', () => {
     const { state, compositionId } = gateway.__testing();
     expect(state.phase).toEqual('loaded');
     expect(compositionId).toEqual(
-      'd20cfb7a9c51179aa494ed9e98153f0042892bd225437af064bf1c1aa68eab86',
+      testingFixturesDefaultCompositionId,
     );
 
     await gateway.stop();
@@ -212,7 +214,7 @@ describe('Using supergraphSdl dynamic configuration', () => {
     const { state, compositionId } = gateway.__testing();
     expect(state.phase).toEqual('loaded');
     expect(compositionId).toEqual(
-      'd20cfb7a9c51179aa494ed9e98153f0042892bd225437af064bf1c1aa68eab86',
+      testingFixturesDefaultCompositionId,
     );
 
     await expect(healthCheckCallback!(supergraphSdl)).resolves.toBeUndefined();
@@ -294,7 +296,7 @@ describe('Using supergraphSdl dynamic configuration', () => {
       const { state, compositionId } = gateway.__testing();
       expect(state.phase).toEqual('loaded');
       expect(compositionId).toEqual(
-        'd20cfb7a9c51179aa494ed9e98153f0042892bd225437af064bf1c1aa68eab86',
+        testingFixturesDefaultCompositionId
       );
 
       await expect(healthCheckCallback!(supergraphSdl)).rejects.toThrowError(

package/src/__tests__/integration/abstract-types.test.ts

@@ -1,7 +1,6 @@
-import gql from 'graphql-tag';
 import { execute } from '../execution-utils';
 
-import { astSerializer, queryPlanSerializer } from 'apollo-federation-integration-testsuite';
+import { astSerializer, fed2gql as gql, queryPlanSerializer } from 'apollo-federation-integration-testsuite';
 
 expect.addSnapshotSerializer(astSerializer);
 expect.addSnapshotSerializer(queryPlanSerializer);
@@ -849,7 +848,7 @@ describe("doesn't result in duplicate fetches", () => {
           type User @key(fields: "id") {
             id: ID!
             name: String
-            username: String
+            username: String @shareable
           }
         `,
       },
@@ -1085,7 +1084,7 @@ it("when including the same nested fields under different type conditions", asyn
           type User @key(fields: "id") {
             id: ID!
             name: String
-            username: String
+            username: String @shareable
           }
         `,
       },
@@ -1293,7 +1292,7 @@ it('when including multiple nested fields to the same service under different ty
           type User @key(fields: "id") {
             id: ID!
             name: String
-            username: String
+            username: String @shareable
           }
         `,
       },
@@ -1514,7 +1513,7 @@ it('when exploding types through multiple levels', async () => {
         type User @key(fields: "id") {
           id: ID!
           name: String
-          username: String
+          username: String @shareable
         }
       `,
     },
@@ -1700,7 +1699,7 @@ it("when including the same nested fields under different type conditions that a
           type User @key(fields: "id") {
             id: ID!
             name: String
-            username: String
+            username: String @shareable
           }
         `,
       },

package/src/__tests__/integration/nockMocks.ts

@@ -121,9 +121,10 @@ export function mockSupergraphSdlRequestSuccessIfAfter(
 }
 
 export function mockSupergraphSdlRequestIfAfterUnchanged(
-    ifAfter: string | null = null,
+  ifAfter: string | null = null,
+  url: string = mockCloudConfigUrl1,
 ) {
-  return mockSupergraphSdlRequestIfAfter(ifAfter).reply(
+  return mockSupergraphSdlRequestIfAfter(ifAfter, url).reply(
       200,
       JSON.stringify({
         data: {

package/src/__tests__/integration/value-types.test.ts

@@ -1,7 +1,7 @@
-import gql from 'graphql-tag';
 import { execute } from '../execution-utils';
 import {
   astSerializer,
+  fed2gql as gql,
   queryPlanSerializer,
 } from 'apollo-federation-integration-testsuite';
 
@@ -200,7 +200,7 @@ describe('value types', () => {
           valueType: ValueType
         }
 
-        type ValueType {
+        type ValueType @shareable {
           id: ID!
           user: User! @provides(fields: "name")
         }
@@ -226,7 +226,7 @@ describe('value types', () => {
           otherValueType: ValueType
         }
 
-        type ValueType {
+        type ValueType @shareable {
           id: ID!
           user: User! @provides(fields: "name")
         }
@@ -250,7 +250,7 @@ describe('value types', () => {
       typeDefs: gql`
         type User @key(fields: "id") {
           id: ID!
-          name: String!
+          name: String! @shareable
           address: String!
         }
       `,

package/src/executeQueryPlan.ts

@@ -298,6 +298,7 @@ async function executeFetch<TContext>(
             context,
             fetch.operation,
             variables,
+            fetch.operationName
         );
 
         for (const entity of entities) {
@@ -333,6 +334,7 @@ async function executeFetch<TContext>(
             context,
             fetch.operation,
             {...variables, representations},
+            fetch.operationName
         );
 
         if (!dataReceivedFromService) {
@@ -374,6 +376,7 @@ async function executeFetch<TContext>(
     context: ExecutionContext<TContext>,
     source: string,
     variables: Record<string, any>,
+    operationName: string | undefined
   ): Promise<ResultMap | void | null> {
     // We declare this as 'any' because it is missing url and method, which
     // GraphQLRequest.http is supposed to have if it exists.
@@ -402,6 +405,7 @@ async function executeFetch<TContext>(
       request: {
         query: source,
         variables,
+        operationName,
         http,
       },
       incomingRequestContext: context.requestContext,

package/src/index.ts

@@ -402,7 +402,7 @@ export class ApolloGateway implements GraphQLService {
           apiKey: this.apolloConfig!.key!,
           uplinkEndpoints,
           maxRetries:
-            this.config.uplinkMaxRetries ?? uplinkEndpoints.length * 3,
+            this.config.uplinkMaxRetries ?? uplinkEndpoints.length * 3 - 1, // -1 for the initial request
           subgraphHealthCheck: this.config.serviceHealthCheck,
           fetcher: this.fetcher,
           logger: this.logger,
@@ -1127,3 +1127,6 @@ export {
   SupergraphSdlHook,
   SupergraphManager
 } from './config';
+
+export { UplinkFetcherError } from "./supergraphManagers"
+

package/src/supergraphManagers/LegacyFetcher/index.ts

@@ -219,7 +219,7 @@ export class LegacyFetcher implements SupergraphManager {
 
   private logUpdateFailure(e: any) {
     this.config.logger?.error(
-      'UplinkFetcher failed to update supergraph with the following error: ' +
+      'LegacyFetcher failed to update supergraph with the following error: ' +
         (e.message ?? e),
     );
   }

package/src/supergraphManagers/LocalCompose/index.ts

@@ -72,7 +72,7 @@ export class LocalCompose implements SupergraphManager {
 
   private logUpdateFailure(e: any) {
     this.config.logger?.error(
-      'UplinkFetcher failed to update supergraph with the following error: ' +
+      'LocalCompose failed to update supergraph with the following error: ' +
         (e.message ?? e),
     );
   }