Add callback when fetching a supergraph from Apollo Uplink fails

.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# Run prettier
+f2f1d6041cd67c67fdacabe0570fe2ce642c052c

codegen.yml

@@ -4,8 +4,8 @@ schema: [
   "https://outofbandreporter.api.apollographql.com/",
 ]
 documents:
-  - gateway-js/src/supergraphManagers/UplinkFetcher/loadSupergraphSdlFromStorage.ts
-  - gateway-js/src/supergraphManagers/UplinkFetcher/outOfBandReporter.ts
+  - gateway-js/src/supergraphManagers/UplinkSupergraphManager/loadSupergraphSdlFromStorage.ts
+  - gateway-js/src/supergraphManagers/UplinkSupergraphManager/outOfBandReporter.ts
 generates:
   gateway-js/src/__generated__/graphqlTypes.ts:
     plugins:

gateway-js/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 This CHANGELOG pertains only to Apollo Federation packages in the 2.x range. The Federation v0.x equivalent for this package can be found [here](https://github.com/apollographql/federation/blob/version-0.x/gateway-js/CHANGELOG.md) on the `version-0.x` branch of this repo.
 
+## vNext
+
+- Add callback when fetching a supergraph from Apollo Uplink fails [PR #1812](https://github.com/apollographql/federation/pull/1812).
+
 ## 2.0.5
 
 - Fix bug with unsatisfiable query branch when handling federation 1 supergraph [PR #1908](https://github.com/apollographql/federation/pull/1908).

gateway-js/src/__tests__/integration/configuration.test.ts

@@ -1,15 +1,12 @@
 import gql from 'graphql-tag';
 import http from 'http';
-import mockedEnv from 'mocked-env';
 import type { Logger } from '@apollo/utils.logger';
 import { ApolloGateway } from '../..';
 import {
   mockSdlQuerySuccess,
   mockSupergraphSdlRequestSuccess,
   mockApolloConfig,
   mockCloudConfigUrl1,
-  mockCloudConfigUrl2,
-  mockCloudConfigUrl3,
 } from './nockMocks';
 import { getTestingSupergraphSdl } from '../execution-utils';
 import { fixtures, Fixture } from 'apollo-federation-integration-testsuite';
@@ -320,46 +317,6 @@ describe('gateway config / env behavior', () => {
       );
     });
   });
-
-  describe('schema config delivery endpoint configuration', () => {
-    it('A code config overrides the env variable', async () => {
-      cleanUp = mockedEnv({
-        APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT: 'env-config',
-      });
-
-      const config = {
-        logger,
-        uplinkEndpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2, mockCloudConfigUrl3],
-      };
-      gateway = new ApolloGateway(config);
-
-      expect(gateway['getUplinkEndpoints'](config)).toEqual([
-        mockCloudConfigUrl1,
-        mockCloudConfigUrl2,
-        mockCloudConfigUrl3,
-      ]);
-
-      gateway = null;
-    });
-  });
-
-  describe('deprecated schema config delivery endpoint configuration', () => {
-    it('A code config overrides the env variable', async () => {
-      cleanUp = mockedEnv({
-        APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT: 'env-config',
-      });
-
-      const config = {
-        logger,
-        schemaConfigDeliveryEndpoint: 'code-config',
-      };
-      gateway = new ApolloGateway(config);
-
-      expect(gateway['getUplinkEndpoints'](config)).toEqual(['code-config']);
-
-      gateway = null;
-    });
-  });
 });
 
 describe('deprecation warnings', () => {

gateway-js/src/__tests__/integration/managed.test.ts

@@ -0,0 +1,289 @@
+import mockedEnv from 'mocked-env';
+
+import { ApolloGateway, UplinkSupergraphManager } from '@apollo/gateway';
+import { ApolloServer } from 'apollo-server';
+import { ApolloServerPluginUsageReportingDisabled } from 'apollo-server-core';
+
+import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
+import {
+  mockSupergraphSdlRequestSuccess,
+  graphRef,
+  apiKey,
+  mockSupergraphSdlRequest,
+} from '../integration/nockMocks';
+import { getTestingSupergraphSdl } from '../execution-utils';
+
+let gateway: ApolloGateway | undefined;
+let server: ApolloServer | undefined;
+let cleanUp: (() => void) | undefined;
+
+beforeEach(() => {
+  nockBeforeEach();
+});
+
+afterEach(async () => {
+  nockAfterEach();
+
+  if (server) {
+    await server.stop();
+    server = undefined;
+  }
+
+  if (gateway) {
+    await gateway.stop();
+    gateway = undefined;
+  }
+
+  if (cleanUp) {
+    cleanUp();
+    cleanUp = undefined;
+  }
+});
+
+const logger = {
+  warn: jest.fn(),
+  debug: jest.fn(),
+  error: jest.fn(),
+  info: jest.fn(),
+};
+
+describe('minimal gateway', () => {
+  it('uses managed federation', async () => {
+    cleanUp = mockedEnv({
+      APOLLO_KEY: apiKey,
+      APOLLO_GRAPH_REF: graphRef,
+    });
+    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ });
+
+    gateway = new ApolloGateway({ logger });
+    server = new ApolloServer({
+      gateway,
+      plugins: [ApolloServerPluginUsageReportingDisabled()],
+    });
+    await server.listen({ port: 0 });
+    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
+  });
+
+  it('fetches from provided `uplinkEndpoints`', async () => {
+    cleanUp = mockedEnv({
+      APOLLO_KEY: apiKey,
+      APOLLO_GRAPH_REF: graphRef,
+    });
+
+    const uplinkEndpoint = 'https://example.com';
+    mockSupergraphSdlRequestSuccess({ url: uplinkEndpoint });
+
+    gateway = new ApolloGateway({ logger, uplinkEndpoints: [uplinkEndpoint] });
+    server = new ApolloServer({
+      gateway,
+      plugins: [ApolloServerPluginUsageReportingDisabled()],
+    });
+    await server.listen({ port: 0 });
+    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
+    const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
+    expect(uplinkManager.uplinkEndpoints).toEqual([uplinkEndpoint]);
+  });
+
+  it('fetches from (deprecated) provided `schemaConfigDeliveryEndpoint`', async () => {
+    cleanUp = mockedEnv({
+      APOLLO_KEY: apiKey,
+      APOLLO_GRAPH_REF: graphRef,
+    });
+
+    const schemaConfigDeliveryEndpoint = 'https://example.com';
+    mockSupergraphSdlRequestSuccess({ url: schemaConfigDeliveryEndpoint });
+
+    gateway = new ApolloGateway({ logger, schemaConfigDeliveryEndpoint });
+    server = new ApolloServer({
+      gateway,
+      plugins: [ApolloServerPluginUsageReportingDisabled()],
+    });
+    await server.listen({ port: 0 });
+    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
+    const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
+    expect(uplinkManager.uplinkEndpoints).toEqual([
+      schemaConfigDeliveryEndpoint,
+    ]);
+  });
+});
+
+describe('Managed gateway with explicit UplinkSupergraphManager', () => {
+  it('waits for supergraph schema to load', async () => {
+    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ });
+
+    gateway = new ApolloGateway({
+      logger,
+      supergraphSdl: new UplinkSupergraphManager({
+        apiKey,
+        graphRef,
+        logger,
+      }),
+    });
+    await expect(gateway.load()).resolves.not.toThrow();
+  });
+
+  it('invokes callback if uplink throws an error during init', async () => {
+    mockSupergraphSdlRequest(null, /.*?apollographql.com/).reply(500);
+
+    const supergraphSchema = getTestingSupergraphSdl();
+    let hasFired;
+    gateway = new ApolloGateway({
+      logger,
+      supergraphSdl: new UplinkSupergraphManager({
+        apiKey,
+        graphRef,
+        logger,
+        maxRetries: 0,
+        fallbackPollIntervalInMs: 0,
+        async onFailureToFetchSupergraphSdlDuringInit() {
+          hasFired = true;
+          return supergraphSchema;
+        },
+      }),
+    });
+
+    await expect(gateway.load()).resolves.not.toThrow();
+    expect(gateway.__testing().supergraphSdl).toBe(supergraphSchema);
+    expect(hasFired).toBeTruthy();
+  });
+
+  it('invokes callback if uplink throws an error after init', async () => {
+    // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
+    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
+      .post('/')
+      .reply(500);
+
+    const supergraphSchema = getTestingSupergraphSdl();
+    let hasFired;
+    gateway = new ApolloGateway({
+      logger,
+      supergraphSdl: new UplinkSupergraphManager({
+        apiKey,
+        graphRef,
+        logger,
+        maxRetries: 0,
+        fallbackPollIntervalInMs: 0,
+        async onFailureToFetchSupergraphSdlAfterInit() {
+          hasFired = true;
+          return supergraphSchema;
+        },
+      }),
+    });
+
+    await expect(gateway.load()).resolves.not.toThrow();
+    expect(hasFired).toBeFalsy();
+
+    const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
+    await uplinkManager.nextFetch();
+
+    expect(hasFired).toBeTruthy();
+  });
+
+  it.each([
+    ['x', 'Syntax Error: Unexpected Name "x".'],
+    ['', 'Syntax Error: Unexpected <EOF>.'],
+    [' ', 'Syntax Error: Unexpected <EOF>.'],
+    ['type Query {hi: String}', 'Invalid supergraph: must be a core schema'],
+  ])(
+    'throws if invalid supergraph schema returned from callback during init: %p',
+    async (schemaText, expectedMessage) => {
+      mockSupergraphSdlRequest(null, /.*?apollographql.com/).reply(500);
+
+      gateway = new ApolloGateway({
+        logger,
+        supergraphSdl: new UplinkSupergraphManager({
+          apiKey,
+          graphRef,
+          logger,
+          maxRetries: 0,
+          fallbackPollIntervalInMs: 0,
+          async onFailureToFetchSupergraphSdlDuringInit() {
+            return schemaText;
+          },
+        }),
+      });
+
+      await expect(gateway.load()).rejects.toThrowError(expectedMessage);
+    },
+  );
+
+  it.each([
+    ['x', 'Syntax Error: Unexpected Name "x".'],
+    [' ', 'Syntax Error: Unexpected <EOF>.'],
+    ['type Query {hi: String}', 'Invalid supergraph: must be a core schema'],
+  ])(
+    'throws if invalid supergraph schema returned from callback after init: %p',
+    async (schemaText, expectedMessage) => {
+      // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
+      mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
+        .post('/')
+        .reply(500);
+
+      let hasFired;
+      gateway = new ApolloGateway({
+        logger,
+        supergraphSdl: new UplinkSupergraphManager({
+          apiKey,
+          graphRef,
+          logger,
+          maxRetries: 0,
+          fallbackPollIntervalInMs: 0,
+          async onFailureToFetchSupergraphSdlAfterInit() {
+            hasFired = true;
+            return schemaText;
+          },
+        }),
+      });
+
+      await expect(gateway.load()).resolves.not.toThrow();
+      expect(hasFired).toBeFalsy();
+
+      const uplinkManager =
+        gateway.supergraphManager as UplinkSupergraphManager;
+      await uplinkManager.nextFetch();
+
+      expect(hasFired).toBeTruthy();
+      expect(logger.error).toBeCalledWith(
+        `UplinkSupergraphManager failed to update supergraph with the following error: ${expectedMessage}`,
+      );
+    },
+  );
+
+  it.each([null, ''])(
+    'uses existing supergraph schema is false-y value returned from callback after init: %p',
+    async (schemaText) => {
+      // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
+      mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
+        .post('/')
+        .reply(500);
+
+      let hasFired;
+      gateway = new ApolloGateway({
+        logger,
+        supergraphSdl: new UplinkSupergraphManager({
+          apiKey,
+          graphRef,
+          logger,
+          maxRetries: 0,
+          fallbackPollIntervalInMs: 0,
+          async onFailureToFetchSupergraphSdlAfterInit() {
+            hasFired = true;
+            return schemaText;
+          },
+        }),
+      });
+
+      await expect(gateway.load()).resolves.not.toThrow();
+      expect(hasFired).toBeFalsy();
+
+      const uplinkManager =
+        gateway.supergraphManager as UplinkSupergraphManager;
+      await uplinkManager.nextFetch();
+
+      expect(hasFired).toBeTruthy();
+
+      const supergraphSchema = getTestingSupergraphSdl();
+      expect(gateway.__testing().supergraphSdl).toBe(supergraphSchema);
+    },
+  );
+});