@apollo/gateway 0.45.0 → 0.47.0

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

@@ -1,8 +1,10 @@
 import gql from 'graphql-tag';
 import { ApolloGateway } from '../..';
 import {
+  DynamicGatewayConfig,
   Experimental_DidResolveQueryPlanCallback,
   Experimental_UpdateServiceDefinitions,
+  ServiceDefinitionUpdate,
 } from '../../config';
 import {
   product,
@@ -11,8 +13,11 @@ import {
   accounts,
   books,
   documents,
+  fixtures,
+  fixturesWithUpdate,
 } from 'apollo-federation-integration-testsuite';
 import { Logger } from 'apollo-server-types';
+import resolvable from '@josephg/resolvable';
 
 // The order of this was specified to preserve existing test coverage. Typically
 // we would just import and use the `fixtures` array.
@@ -47,16 +52,14 @@ beforeEach(() => {
 
 describe('lifecycle hooks', () => {
   it('uses updateServiceDefinitions override', async () => {
-    const experimental_updateServiceDefinitions: Experimental_UpdateServiceDefinitions = jest.fn(
-      async () => {
+    const experimental_updateServiceDefinitions: Experimental_UpdateServiceDefinitions =
+      jest.fn(async () => {
         return { serviceDefinitions, isNewSchema: true };
-      },
-    );
+      });
 
     const gateway = new ApolloGateway({
       serviceList: serviceDefinitions,
       experimental_updateServiceDefinitions,
-      experimental_didUpdateComposition: jest.fn(),
       logger,
     });
 
@@ -67,39 +70,7 @@ describe('lifecycle hooks', () => {
     await gateway.stop();
   });
 
-  it('calls experimental_didFailComposition with a bad config', async () => {
-    const experimental_didFailComposition = jest.fn();
-
-    const gateway = new ApolloGateway({
-      async experimental_updateServiceDefinitions() {
-        return {
-          serviceDefinitions: [serviceDefinitions[0]],
-          compositionMetadata: {
-            formatVersion: 1,
-            id: 'abc',
-            implementingServiceLocations: [],
-            schemaHash: 'abc',
-          },
-          isNewSchema: true,
-        };
-      },
-      serviceList: [],
-      experimental_didFailComposition,
-      logger,
-    });
-
-    await expect(gateway.load()).rejects.toThrowError();
-
-    const callbackArgs = experimental_didFailComposition.mock.calls[0][0];
-    expect(callbackArgs.serviceList).toHaveLength(1);
-    expect(callbackArgs.errors[0]).toMatchInlineSnapshot(
-      `[GraphQLError: [product] Book -> \`Book\` is an extension type, but \`Book\` is not defined in any service]`,
-    );
-    expect(callbackArgs.compositionMetadata.id).toEqual('abc');
-    expect(experimental_didFailComposition).toBeCalled();
-  });
-
-  it('calls experimental_didUpdateComposition on schema update', async () => {
+  it('calls experimental_didUpdateSupergraph on schema update', async () => {
     const compositionMetadata = {
       formatVersion: 1,
       id: 'abc',
@@ -107,81 +78,73 @@ describe('lifecycle hooks', () => {
       schemaHash: 'hash1',
     };
 
-    const update: Experimental_UpdateServiceDefinitions = async () => ({
-      serviceDefinitions,
-      isNewSchema: true,
-      compositionMetadata: {
-        ...compositionMetadata,
-        id: '123',
-        schemaHash: 'hash2',
-      },
-    });
-
-    // This is the simplest way I could find to achieve mocked functions that leverage our types
-    const mockUpdate = jest.fn(update);
-
-    // We want to return a different composition across two ticks, so we mock it
-    // slightly differenty
-    mockUpdate.mockImplementationOnce(async () => {
-      const services = serviceDefinitions.filter(s => s.name !== 'books');
-      return {
-        serviceDefinitions: [
-          ...services,
-          {
-            name: 'book',
-            typeDefs: books.typeDefs,
-            url: 'http://localhost:32542',
+    const mockUpdate = jest
+      .fn<Promise<ServiceDefinitionUpdate>, [config: DynamicGatewayConfig]>()
+      .mockImplementationOnce(async () => {
+        return {
+          serviceDefinitions: fixtures,
+          isNewSchema: true,
+          compositionMetadata: {
+            ...compositionMetadata,
+            id: '123',
+            schemaHash: 'hash2',
           },
-        ],
-        isNewSchema: true,
-        compositionMetadata,
-      };
-    });
+        };
+      })
+      // We want to return a different composition across two ticks, so we mock it
+      // slightly differently
+      .mockImplementationOnce(async () => {
+        return {
+          serviceDefinitions: fixturesWithUpdate,
+          isNewSchema: true,
+          compositionMetadata,
+        };
+      });
 
     const mockDidUpdate = jest.fn();
 
     const gateway = new ApolloGateway({
       experimental_updateServiceDefinitions: mockUpdate,
-      experimental_didUpdateComposition: mockDidUpdate,
+      experimental_didUpdateSupergraph: mockDidUpdate,
       logger,
     });
-    // @ts-ignore for testing purposes, a short pollInterval is ideal so we'll override here
-    gateway.experimental_pollInterval = 100;
+    // for testing purposes, a short pollInterval is ideal so we'll override here
+    gateway['pollIntervalInMs'] = 100;
 
-    let resolve1: Function;
-    let resolve2: Function;
-    const schemaChangeBlocker1 = new Promise(res => (resolve1 = res));
-    const schemaChangeBlocker2 = new Promise(res => (resolve2 = res));
+    const schemaChangeBlocker1 = resolvable();
+    const schemaChangeBlocker2 = resolvable();
 
-    gateway.onSchemaChange(
+    gateway.onSchemaLoadOrUpdate(
       jest
         .fn()
-        .mockImplementationOnce(() => resolve1())
-        .mockImplementationOnce(() => resolve2()),
+        .mockImplementationOnce(() => schemaChangeBlocker1.resolve())
+        .mockImplementationOnce(() => schemaChangeBlocker2.resolve()),
     );
 
     await gateway.load();
 
     await schemaChangeBlocker1;
+
     expect(mockUpdate).toBeCalledTimes(1);
     expect(mockDidUpdate).toBeCalledTimes(1);
 
     await schemaChangeBlocker2;
+
     expect(mockUpdate).toBeCalledTimes(2);
     expect(mockDidUpdate).toBeCalledTimes(2);
 
     const [firstCall, secondCall] = mockDidUpdate.mock.calls;
 
-    expect(firstCall[0]!.schema).toBeDefined();
-    expect(firstCall[0].compositionMetadata!.schemaHash).toEqual('hash1');
+    const expectedFirstId = '562c22b3382b56b1651944a96e89a361fe847b9b32660eae5ecbd12adc20bf8b'
+    expect(firstCall[0]!.compositionId).toEqual(expectedFirstId);
     // first call should have no second "previous" argument
     expect(firstCall[1]).toBeUndefined();
 
-    expect(secondCall[0].schema).toBeDefined();
-    expect(secondCall[0].compositionMetadata!.schemaHash).toEqual('hash2');
+    expect(secondCall[0]!.compositionId).toEqual(
+      '0ced02894592ade4376276d11735b46723eb84850c32765cb78502ba5c29a563',
+    );
     // second call should have previous info in the second arg
-    expect(secondCall[1]!.schema).toBeDefined();
-    expect(secondCall[1]!.compositionMetadata!.schemaHash).toEqual('hash1');
+    expect(secondCall[1]!.compositionId).toEqual(expectedFirstId);
 
     await gateway.stop();
   });
@@ -206,34 +169,31 @@ describe('lifecycle hooks', () => {
   it('warns when polling on the default fetcher', async () => {
     new ApolloGateway({
       serviceList: serviceDefinitions,
-      experimental_pollInterval: 10,
+      pollIntervalInMs: 10,
       logger,
     });
-    expect(logger.warn).toHaveBeenCalledTimes(1);
     expect(logger.warn).toHaveBeenCalledWith(
       'Polling running services is dangerous and not recommended in production. Polling should only be used against a registry. If you are polling running services, use with caution.',
     );
   });
 
   it('registers schema change callbacks when experimental_pollInterval is set for unmanaged configs', async () => {
-    const experimental_updateServiceDefinitions: Experimental_UpdateServiceDefinitions = jest.fn(
-      async (_config) => {
+    const experimental_updateServiceDefinitions: Experimental_UpdateServiceDefinitions =
+      jest.fn(async (_config) => {
         return { serviceDefinitions, isNewSchema: true };
-      },
-    );
+      });
 
     const gateway = new ApolloGateway({
       serviceList: [{ name: 'book', url: 'http://localhost:32542' }],
       experimental_updateServiceDefinitions,
-      experimental_pollInterval: 100,
+      pollIntervalInMs: 100,
       logger,
     });
 
-    let resolve: Function;
-    const schemaChangeBlocker = new Promise(res => (resolve = res));
-    const schemaChangeCallback = jest.fn(() => resolve());
+    const schemaChangeBlocker = resolvable();
+    const schemaChangeCallback = jest.fn(() => schemaChangeBlocker.resolve());
 
-    gateway.onSchemaChange(schemaChangeCallback);
+    gateway.onSchemaLoadOrUpdate(schemaChangeCallback);
     await gateway.load();
 
     await schemaChangeBlocker;
@@ -243,12 +203,11 @@ describe('lifecycle hooks', () => {
   });
 
   it('calls experimental_didResolveQueryPlan when executor is called', async () => {
-    const experimental_didResolveQueryPlan: Experimental_DidResolveQueryPlanCallback = jest.fn()
+    const experimental_didResolveQueryPlan: Experimental_DidResolveQueryPlanCallback =
+      jest.fn();
 
     const gateway = new ApolloGateway({
-      localServiceList: [
-        books
-      ],
+      localServiceList: [books],
       experimental_didResolveQueryPlan,
     });
 
@@ -258,7 +217,7 @@ describe('lifecycle hooks', () => {
       { book(isbn: "0262510871") { year } }
     `;
 
-     // @ts-ignore
+    // @ts-ignore
     await executor({
       source,
       document: gql(source),

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

@@ -36,11 +36,16 @@ describe('opentelemetry', () => {
   describe('with local data', () =>
   {
     async function gateway() {
+      const localDataSources = Object.fromEntries(
+        fixtures.map((f) => [
+          f.name,
+          new LocalGraphQLDataSource(buildSubgraphSchema(f)),
+        ]),
+      );
       const gateway = new ApolloGateway({
         localServiceList: fixtures,
-        buildService: service => {
-          // @ts-ignore
-          return new LocalGraphQLDataSource(buildSubgraphSchema([service]));
+        buildService(service) {
+          return localDataSources[service.name];
         },
       });
 

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

@@ -6,14 +6,20 @@ import { LocalGraphQLDataSource } from '../../datasources/LocalGraphQLDataSource
 import { ApolloGateway } from '../../';
 import { fixtures } from 'apollo-federation-integration-testsuite';
 import { QueryPlanner } from '@apollo/query-planner';
+
 it('caches the query plan for a request', async () => {
   const buildQueryPlanSpy = jest.spyOn(QueryPlanner.prototype, 'buildQueryPlan');
 
+  const localDataSources = Object.fromEntries(
+    fixtures.map((f) => [
+      f.name,
+      new LocalGraphQLDataSource(buildSubgraphSchema(f)),
+    ]),
+  );
   const gateway = new ApolloGateway({
     localServiceList: fixtures,
-    buildService: service => {
-      // @ts-ignore
-      return new LocalGraphQLDataSource(buildSubgraphSchema([service]));
+    buildService(service) {
+      return localDataSources[service.name];
     },
   });
 
@@ -65,11 +71,17 @@ it('supports multiple operations and operationName', async () => {
     }
   `;
 
+  const localDataSources = Object.fromEntries(
+    fixtures.map((f) => [
+      f.name,
+      new LocalGraphQLDataSource(buildSubgraphSchema(f)),
+    ]),
+  );
+
   const gateway = new ApolloGateway({
     localServiceList: fixtures,
-    buildService: service => {
-      // @ts-ignore
-      return new LocalGraphQLDataSource(buildSubgraphSchema([service]));
+    buildService(service) {
+      return localDataSources[service.name];
     },
   });
 
@@ -170,11 +182,15 @@ it('does not corrupt cached queryplan data across requests', async () => {
     },
   };
 
+  const dataSources: Record<string, LocalGraphQLDataSource> = {
+    a: new LocalGraphQLDataSource(buildSubgraphSchema(serviceA)),
+    b: new LocalGraphQLDataSource(buildSubgraphSchema(serviceB)),
+  };
+
   const gateway = new ApolloGateway({
     localServiceList: [serviceA, serviceB],
-    buildService: service => {
-      // @ts-ignore
-      return new LocalGraphQLDataSource(buildSubgraphSchema([service]));
+    buildService(service) {
+      return dataSources[service.name];
     },
   });
 

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

@@ -1,18 +1,16 @@
 import { gunzipSync } from 'zlib';
 import nock from 'nock';
-import { GraphQLSchemaModule } from 'apollo-graphql';
-import gql from 'graphql-tag';
 import { buildSubgraphSchema } from '@apollo/subgraph';
 import { ApolloServer } from 'apollo-server';
 import { ApolloServerPluginUsageReporting } from 'apollo-server-core';
-import { execute, toPromise } from 'apollo-link';
-import { createHttpLink } from 'apollo-link-http';
 import fetch from 'node-fetch';
 import { ApolloGateway } from '../..';
 import { Plugin, Config, Refs } from 'pretty-format';
 import { Report, Trace } from 'apollo-reporting-protobuf';
 import { fixtures } from 'apollo-federation-integration-testsuite';
 import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
+import resolvable, { Resolvable } from '@josephg/resolvable';
+import { GraphQLSchemaModule } from '../../schema-helper';
 
 // Normalize specific fields that change often (eg timestamps) to static values,
 // to make snapshot testing viable.  (If these helpers are more generally
@@ -89,19 +87,16 @@ describe('reporting', () => {
   let backendServers: ApolloServer[];
   let gatewayServer: ApolloServer;
   let gatewayUrl: string;
-  let reportPromise: Promise<any>;
+  let reportPromise: Resolvable<any>;
 
   beforeEach(async () => {
-    let reportResolver: (report: any) => void;
-    reportPromise = new Promise<any>((resolve) => {
-      reportResolver = resolve;
-    });
+    reportPromise = resolvable();
 
     nockBeforeEach();
     nock('https://usage-reporting.api.apollographql.com')
       .post('/api/ingress/traces')
       .reply(200, (_: any, requestBody: string) => {
-        reportResolver(requestBody);
+        reportPromise.resolve(requestBody);
         return 'ok';
       });
 
@@ -143,7 +138,7 @@ describe('reporting', () => {
   });
 
   it(`queries three services`, async () => {
-    const query = gql`
+    const query = `#graphql
       query {
         me {
           name {
@@ -157,12 +152,15 @@ describe('reporting', () => {
       }
     `;
 
-    const result = await toPromise(
-      execute(createHttpLink({ uri: gatewayUrl, fetch: fetch as any }), {
-        query,
-      }),
-    );
-    expect(result).toMatchInlineSnapshot(`
+    const result = await fetch(gatewayUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ query }),
+    });
+    const body = await result.json();
+    expect(body).toMatchInlineSnapshot(`
       Object {
         "data": Object {
           "me": Object {
@@ -233,6 +231,34 @@ describe('reporting', () => {
         "tracesPerQuery": Object {
           "# -
       {me{name{first last}}topProducts{name}}": Object {
+            "referencedFieldsByType": Object {
+              "Name": Object {
+                "fieldNames": Array [
+                  "first",
+                  "last",
+                ],
+                "isInterface": false,
+              },
+              "Product": Object {
+                "fieldNames": Array [
+                  "name",
+                ],
+                "isInterface": true,
+              },
+              "Query": Object {
+                "fieldNames": Array [
+                  "me",
+                  "topProducts",
+                ],
+                "isInterface": false,
+              },
+              "User": Object {
+                "fieldNames": Array [
+                  "name",
+                ],
+                "isInterface": false,
+              },
+            },
             "trace": Array [
               Object {
                 "cachePolicy": Object {
@@ -240,14 +266,13 @@ describe('reporting', () => {
                   "scope": "PRIVATE",
                 },
                 "clientName": "",
-                "clientReferenceId": "",
                 "clientVersion": "",
-                "details": Object {},
                 "durationNs": 12345,
                 "endTime": Object {
                   "nanos": 123000000,
                   "seconds": "1562203363",
                 },
+                "fieldExecutionWeight": 1,
                 "forbiddenOperation": false,
                 "fullQueryCacheHit": false,
                 "http": Object {