@apollo/gateway 0.45.1 → 0.46.0-alpha.0

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

@@ -13,6 +13,7 @@ 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';
 
 // Normalize specific fields that change often (eg timestamps) to static values,
 // to make snapshot testing viable.  (If these helpers are more generally
@@ -89,19 +90,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';
       });
 

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

@@ -0,0 +1,390 @@
+import {
+  ApolloGateway,
+  SubgraphHealthCheckFunction,
+  SupergraphSdlUpdateFunction,
+} from '@apollo/gateway';
+import { fixturesWithUpdate } from 'apollo-federation-integration-testsuite';
+import { createHash } from 'apollo-graphql/lib/utilities/createHash';
+import { ApolloServer } from 'apollo-server';
+import { Logger } from 'apollo-server-types';
+import { fetch } from '../../__mocks__/apollo-server-env';
+import { getTestingSupergraphSdl } from '../execution-utils';
+import { mockAllServicesHealthCheckSuccess } from '../integration/nockMocks';
+import resolvable from '@josephg/resolvable';
+import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
+
+async function getSupergraphSdlGatewayServer() {
+  const server = new ApolloServer({
+    gateway: new ApolloGateway({
+      supergraphSdl: getTestingSupergraphSdl(),
+    }),
+  });
+
+  await server.listen({ port: 0 });
+  return server;
+}
+
+let logger: Logger;
+let gateway: ApolloGateway | null;
+beforeEach(() => {
+  nockBeforeEach();
+
+  logger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  };
+});
+
+afterEach(async () => {
+  nockAfterEach();
+
+  if (gateway) {
+    await gateway.stop();
+    gateway = null;
+  }
+});
+
+describe('Using supergraphSdl static configuration', () => {
+  it('successfully starts and serves requests to the proper services', async () => {
+    const server = await getSupergraphSdlGatewayServer();
+
+    fetch.mockJSONResponseOnce({
+      data: { me: { username: '@jbaxleyiii' } },
+    });
+
+    const result = await server.executeOperation({
+      query: '{ me { username } }',
+    });
+
+    expect(result.data).toMatchInlineSnapshot(`
+      Object {
+        "me": Object {
+          "username": "@jbaxleyiii",
+        },
+      }
+    `);
+
+    const [url, request] = fetch.mock.calls[0];
+    expect(url).toEqual('https://accounts.api.com');
+    expect(request?.body).toEqual(
+      JSON.stringify({ query: '{me{username}}', variables: {} }),
+    );
+    await server.stop();
+  });
+});
+
+describe('Using supergraphSdl dynamic configuration', () => {
+  it('calls the user provided function after `gateway.load()` is called', async () => {
+    const callbackSpy = jest.fn(async () => ({
+      supergraphSdl: getTestingSupergraphSdl(),
+    }));
+
+    gateway = new ApolloGateway({
+      supergraphSdl: callbackSpy,
+    });
+
+    expect(callbackSpy).not.toHaveBeenCalled();
+    await gateway.load();
+    expect(callbackSpy).toHaveBeenCalled();
+  });
+
+  it('starts and remains in `initialized` state until `supergraphSdl` Promise resolves', async () => {
+    const promiseGuaranteeingWeAreInTheCallback = resolvable();
+    const promiseGuaranteeingWeStayInTheCallback = resolvable();
+
+    gateway = new ApolloGateway({
+      async supergraphSdl() {
+        promiseGuaranteeingWeAreInTheCallback.resolve();
+        await promiseGuaranteeingWeStayInTheCallback;
+        return {
+          supergraphSdl: getTestingSupergraphSdl(),
+        };
+      },
+    });
+
+    expect(gateway.__testing().state.phase).toEqual('initialized');
+
+    const gatewayLoaded = gateway.load();
+    await promiseGuaranteeingWeAreInTheCallback;
+    expect(gateway.__testing().state.phase).toEqual('initialized');
+
+    promiseGuaranteeingWeStayInTheCallback.resolve();
+    await gatewayLoaded;
+    expect(gateway.__testing().state.phase).toEqual('loaded');
+  });
+
+  it('moves from `initialized` to `loaded` state after calling `load()` and after user Promise resolves', async () => {
+    const userPromise = resolvable<{ supergraphSdl: string }>();
+
+    gateway = new ApolloGateway({
+      async supergraphSdl() {
+        return userPromise;
+      },
+    });
+
+    const loadPromise = gateway.load();
+    expect(gateway.__testing().state.phase).toEqual('initialized');
+
+    const supergraphSdl = getTestingSupergraphSdl();
+    const expectedCompositionId = createHash('sha256')
+      .update(supergraphSdl)
+      .digest('hex');
+    userPromise.resolve({ supergraphSdl });
+
+    await loadPromise;
+    const { state, compositionId } = gateway.__testing();
+    expect(state.phase).toEqual('loaded');
+    expect(compositionId).toEqual(expectedCompositionId);
+  });
+
+  it('updates its supergraph after user calls update function', async () => {
+    const userPromise = resolvable<{ supergraphSdl: string }>();
+
+    let userUpdateFn: SupergraphSdlUpdateFunction;
+    gateway = new ApolloGateway({
+      async supergraphSdl({ update }) {
+        userUpdateFn = update;
+        return userPromise;
+      },
+    });
+
+    const supergraphSdl = getTestingSupergraphSdl();
+    const expectedId = createHash('sha256').update(supergraphSdl).digest('hex');
+    userPromise.resolve({ supergraphSdl: getTestingSupergraphSdl() });
+    await gateway.load();
+    expect(gateway.__testing().compositionId).toEqual(expectedId);
+
+    const updatedSupergraphSdl = getTestingSupergraphSdl(fixturesWithUpdate);
+    const expectedUpdatedId = createHash('sha256')
+      .update(updatedSupergraphSdl)
+      .digest('hex');
+
+    userUpdateFn!(updatedSupergraphSdl);
+    expect(gateway.__testing().compositionId).toEqual(expectedUpdatedId);
+  });
+
+  it('calls user-provided `cleanup` function when stopped', async () => {
+    const cleanup = jest.fn(() => Promise.resolve());
+    gateway = new ApolloGateway({
+      async supergraphSdl() {
+        return {
+          supergraphSdl: getTestingSupergraphSdl(),
+          cleanup,
+        };
+      },
+    });
+
+    await gateway.load();
+    const { state, compositionId } = gateway.__testing();
+    expect(state.phase).toEqual('loaded');
+    expect(compositionId).toEqual(
+      '562c22b3382b56b1651944a96e89a361fe847b9b32660eae5ecbd12adc20bf8b',
+    );
+
+    await gateway.stop();
+    expect(cleanup).toHaveBeenCalledTimes(1);
+  });
+
+  it('performs a successful health check on subgraphs', async () => {
+    mockAllServicesHealthCheckSuccess();
+
+    let healthCheckCallback: SubgraphHealthCheckFunction;
+    const supergraphSdl = getTestingSupergraphSdl();
+    gateway = new ApolloGateway({
+      async supergraphSdl({ healthCheck }) {
+        healthCheckCallback = healthCheck;
+        return {
+          supergraphSdl,
+        };
+      },
+    });
+
+    await gateway.load();
+    const { state, compositionId } = gateway.__testing();
+    expect(state.phase).toEqual('loaded');
+    expect(compositionId).toEqual(
+      '562c22b3382b56b1651944a96e89a361fe847b9b32660eae5ecbd12adc20bf8b',
+    );
+
+    await expect(healthCheckCallback!(supergraphSdl)).resolves.toBeUndefined();
+  });
+
+  it('calls `initialize` on an object provided to `supergraphSdl`', async () => {
+    const MockSdlUpdatingClass = {
+      initialize() {
+        return Promise.resolve({
+          supergraphSdl: getTestingSupergraphSdl(),
+        });
+      },
+    };
+    const initializeSpy = jest.spyOn(MockSdlUpdatingClass, 'initialize');
+
+    gateway = new ApolloGateway({
+      supergraphSdl: MockSdlUpdatingClass,
+    });
+
+    expect(initializeSpy).not.toHaveBeenCalled();
+    await gateway.load();
+    expect(initializeSpy).toHaveBeenCalled();
+  });
+
+  describe('errors', () => {
+    it('fails to load if `SupergraphManager` throws on initialization', async () => {
+      const failureMessage = 'Error from supergraphSdl function';
+      gateway = new ApolloGateway({
+        async supergraphSdl() {
+          throw new Error(failureMessage);
+        },
+        logger,
+      });
+
+      await expect(gateway.load()).rejects.toThrowError(failureMessage);
+
+      expect(gateway.__testing().state.phase).toEqual('failed to load');
+      // we don't want the `afterEach` to call `gateway.stop()` in this case
+      // since it would throw an error due to the gateway's failed to load state
+      gateway = null;
+    });
+
+    it('gracefully handles Promise rejections from user `cleanup` function', async () => {
+      const rejectionMessage = 'thrown from cleanup function';
+      const cleanup = jest.fn(() => Promise.reject(rejectionMessage));
+      gateway = new ApolloGateway({
+        async supergraphSdl() {
+          return {
+            supergraphSdl: getTestingSupergraphSdl(),
+            cleanup,
+          };
+        },
+        logger,
+      });
+
+      await gateway.load();
+      await expect(gateway.stop()).resolves.toBeUndefined();
+      expect(cleanup).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledWith(
+        'Error occured while calling user provided `cleanup` function: ' +
+          rejectionMessage,
+      );
+    });
+
+    it('throws an error when `healthCheck` rejects', async () => {
+      // no mocks, so nock will reject
+      let healthCheckCallback: SubgraphHealthCheckFunction;
+      const supergraphSdl = getTestingSupergraphSdl();
+      gateway = new ApolloGateway({
+        async supergraphSdl({ healthCheck }) {
+          healthCheckCallback = healthCheck;
+          return {
+            supergraphSdl,
+          };
+        },
+      });
+
+      await gateway.load();
+      const { state, compositionId } = gateway.__testing();
+      expect(state.phase).toEqual('loaded');
+      expect(compositionId).toEqual(
+        '562c22b3382b56b1651944a96e89a361fe847b9b32660eae5ecbd12adc20bf8b',
+      );
+
+      await expect(healthCheckCallback!(supergraphSdl)).rejects.toThrowError(
+        /The gateway subgraphs health check failed\. Updating to the provided `supergraphSdl` will likely result in future request failures to subgraphs\. The following error occurred during the health check/,
+      );
+    });
+
+    it('throws an error when `update` is called after gateway fails to load', async () => {
+      let updateCallback: SupergraphSdlUpdateFunction;
+      const supergraphSdl = getTestingSupergraphSdl();
+      gateway = new ApolloGateway({
+        async supergraphSdl({ update }) {
+          updateCallback = update;
+          return {
+            supergraphSdl: 'invalid SDL',
+          };
+        },
+      });
+
+      try {
+        await gateway.load();
+      } catch {}
+
+      expect(() =>
+        updateCallback!(supergraphSdl),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `"Can't call \`update\` callback after gateway failed to load."`,
+      );
+
+      // gateway failed to load, so we don't want the `afterEach` to call `gateway.stop()`
+      gateway = null;
+    });
+
+    it('throws an error when `update` is called while an update is in progress', async () => {
+      let updateCallback: SupergraphSdlUpdateFunction;
+      const supergraphSdl = getTestingSupergraphSdl();
+      gateway = new ApolloGateway({
+        async supergraphSdl({ update }) {
+          updateCallback = update;
+          return {
+            supergraphSdl,
+          };
+        },
+        experimental_didUpdateSupergraph() {
+          updateCallback(getTestingSupergraphSdl(fixturesWithUpdate));
+        },
+      });
+
+      await expect(gateway.load()).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Can't call \`update\` callback while supergraph update is in progress."`,
+      );
+
+      // gateway failed to load, so we don't want the `afterEach` to call `gateway.stop()`
+      gateway = null;
+    });
+
+    it('throws an error when `update` is called after gateway is stopped', async () => {
+      let updateCallback: SupergraphSdlUpdateFunction;
+      const supergraphSdl = getTestingSupergraphSdl();
+      gateway = new ApolloGateway({
+        async supergraphSdl({ update }) {
+          updateCallback = update;
+          return {
+            supergraphSdl,
+          };
+        },
+      });
+
+      await gateway.load();
+      await gateway.stop();
+
+      expect(() =>
+        updateCallback!(getTestingSupergraphSdl(fixturesWithUpdate)),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `"Can't call \`update\` callback after gateway has been stopped."`,
+      );
+    });
+
+    it('throws an error when `update` is called with an invalid supergraph', async () => {
+      let updateCallback: SupergraphSdlUpdateFunction;
+      const supergraphSdl = getTestingSupergraphSdl();
+      gateway = new ApolloGateway({
+        async supergraphSdl({ update }) {
+          updateCallback = update;
+          return {
+            supergraphSdl,
+          };
+        },
+      });
+
+      await gateway.load();
+
+      expect(() =>
+        updateCallback!('invalid SDL'),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `"Syntax Error: Unexpected Name \\"invalid\\"."`,
+      );
+    });
+  });
+});

package/src/__tests__/integration/aliases.test.ts

@@ -141,11 +141,17 @@ it('supports aliases of nested fields on subservices', async () => {
 
 // TODO after we remove GraphQLExtensions from ApolloServer, this can go away
 it('supports aliases when using ApolloServer', 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];
     },
   });
 

package/src/__tests__/integration/configuration.test.ts

@@ -12,11 +12,11 @@ import {
   mockCloudConfigUrl3,
 } from './nockMocks';
 import { getTestingSupergraphSdl } from '../execution-utils';
-import { MockService } from './networkRequests.test';
+import { fixtures, Fixture } from 'apollo-federation-integration-testsuite';
 
 let logger: Logger;
 
-const service: MockService = {
+const service: Fixture = {
   name: 'accounts',
   url: 'http://localhost:4001',
   typeDefs: gql`
@@ -326,14 +326,17 @@ describe('gateway config / env behavior', () => {
         APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT: 'env-config',
       });
 
-      gateway = new ApolloGateway({
+      const config = {
         logger,
         uplinkEndpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2, mockCloudConfigUrl3],
-      });
+      };
+      gateway = new ApolloGateway(config);
 
-      expect(gateway['uplinkEndpoints']).toEqual(
-        [mockCloudConfigUrl1, mockCloudConfigUrl2, mockCloudConfigUrl3],
-      );
+      expect(gateway['getUplinkEndpoints'](config)).toEqual([
+        mockCloudConfigUrl1,
+        mockCloudConfigUrl2,
+        mockCloudConfigUrl3,
+      ]);
 
       gateway = null;
     });
@@ -345,16 +348,110 @@ describe('gateway config / env behavior', () => {
         APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT: 'env-config',
       });
 
-      gateway = new ApolloGateway({
+      const config = {
         logger,
         schemaConfigDeliveryEndpoint: 'code-config',
-      });
+      };
+      gateway = new ApolloGateway(config);
 
-      expect(gateway['uplinkEndpoints']).toEqual(
-        ['code-config'],
-      );
+      expect(gateway['getUplinkEndpoints'](config)).toEqual(['code-config']);
 
       gateway = null;
     });
   });
 });
+
+describe('deprecation warnings', () => {
+  it('warns with `experimental_updateSupergraphSdl` option set', async () => {
+    const gateway = new ApolloGateway({
+      async experimental_updateSupergraphSdl() {
+        return {
+          id: 'supergraph',
+          supergraphSdl: getTestingSupergraphSdl(),
+        };
+      },
+      logger,
+    });
+
+    await gateway.load();
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      'The `experimental_updateSupergraphSdl` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to the function form of the `supergraphSdl` configuration option.',
+    );
+
+    await gateway.stop();
+  });
+
+  it('warns with `experimental_updateServiceDefinitions` option set', async () => {
+    const gateway = new ApolloGateway({
+      async experimental_updateServiceDefinitions() {
+        return {
+          isNewSchema: false,
+        };
+      },
+      logger,
+    });
+
+    try {
+      await gateway.load();
+    // gateway will throw since we're not providing an actual service list, disregard
+    } catch {}
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      'The `experimental_updateServiceDefinitions` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to the function form of the `supergraphSdl` configuration option.',
+    );
+  });
+
+  it('warns with `serviceList` option set', async () => {
+    const gateway = new ApolloGateway({
+      serviceList: [{ name: 'accounts', url: 'http://localhost:4001' }],
+      logger,
+    });
+
+    try {
+      await gateway.load();
+      // gateway will throw since we haven't mocked these requests, unimportant for this test
+    } catch {}
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      'The `serviceList` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to its replacement `IntrospectAndCompose`. More information on `IntrospectAndCompose` can be found in the documentation.',
+    );
+  });
+
+  it('warns with `localServiceList` option set', async () => {
+    const gateway = new ApolloGateway({
+      localServiceList: fixtures,
+      logger,
+    });
+
+    await gateway.load();
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      'The `localServiceList` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to the `LocalCompose` supergraph manager exported by `@apollo/gateway`.',
+    );
+
+    await gateway.stop();
+  });
+
+  it('warns with `schemaConfigDeliveryEndpoint` option set', async () => {
+    new ApolloGateway({
+      schemaConfigDeliveryEndpoint: 'test',
+      logger,
+    });
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      'The `schemaConfigDeliveryEndpoint` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to the equivalent (array form) `uplinkEndpoints` configuration option.',
+    );
+  });
+
+  it('warns with `experimental_pollInterval` option set', async () => {
+    new ApolloGateway({
+      experimental_pollInterval: 10000,
+      logger,
+    });
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      'The `experimental_pollInterval` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to the equivalent `pollIntervalInMs` configuration option.',
+    );
+  });
+});

package/src/__tests__/integration/logger.test.ts

@@ -10,7 +10,7 @@ import * as log4js from "log4js";
 
 const LOWEST_LOG_LEVEL = "debug";
 
-const KNOWN_DEBUG_MESSAGE = "Checking for composition updates...";
+const KNOWN_DEBUG_MESSAGE = "Gateway successfully initialized (but not yet loaded)";
 
 async function triggerKnownDebugMessage(logger: Logger) {
   // Trigger a known error.