@apollo/gateway 2.0.0-alpha.2 → 2.0.0-alpha.6

package/src/supergraphManagers/UplinkFetcher/__tests__/loadSupergraphSdlFromStorage.test.ts

@@ -0,0 +1,397 @@
+import {
+  loadSupergraphSdlFromStorage,
+  loadSupergraphSdlFromUplinks,
+  UplinkFetcherError,
+} from '../loadSupergraphSdlFromStorage';
+import { getDefaultFetcher } from '../../..';
+import {
+  graphRef,
+  apiKey,
+  mockCloudConfigUrl1,
+  mockCloudConfigUrl2,
+  mockOutOfBandReporterUrl,
+  mockSupergraphSdlRequest,
+  mockOutOfBandReportRequestSuccess,
+  mockSupergraphSdlRequestSuccess,
+  mockSupergraphSdlRequestIfAfterUnchanged,
+  mockSupergraphSdlRequestIfAfter
+} from '../../../__tests__/integration/nockMocks';
+import { getTestingSupergraphSdl } from "../../../__tests__/execution-utils";
+import { nockAfterEach, nockBeforeEach } from '../../../__tests__/nockAssertions';
+
+describe('loadSupergraphSdlFromStorage', () => {
+  beforeEach(nockBeforeEach);
+  afterEach(nockAfterEach);
+
+  it('fetches Supergraph SDL as expected', async () => {
+    mockSupergraphSdlRequestSuccess();
+    const fetcher = getDefaultFetcher();
+    const result = await loadSupergraphSdlFromStorage({
+      graphRef,
+      apiKey,
+      endpoint: mockCloudConfigUrl1,
+      errorReportingEndpoint: undefined,
+      fetcher,
+      compositionId: null,
+    });
+    expect(result).toMatchObject({
+      id: 'originalId-1234',
+      supergraphSdl: getTestingSupergraphSdl(),
+    });
+  });
+
+  it('Queries alternate Uplink URL if first one fails', async () => {
+    mockSupergraphSdlRequest('originalId-1234', mockCloudConfigUrl1).reply(500);
+    mockSupergraphSdlRequestIfAfter('originalId-1234', mockCloudConfigUrl2).reply(
+      200,
+      JSON.stringify({
+        data: {
+          routerConfig: {
+            __typename: 'RouterConfigResult',
+            id: 'originalId-1234',
+            supergraphSdl: getTestingSupergraphSdl()
+          },
+        },
+      }),
+    );
+
+    const fetcher = getDefaultFetcher();
+    const result = await loadSupergraphSdlFromUplinks({
+      graphRef,
+      apiKey,
+      endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
+      errorReportingEndpoint: undefined,
+      fetcher,
+      compositionId: "originalId-1234",
+      maxRetries: 1,
+      roundRobinSeed: 0,
+    });
+
+    expect(result).toMatchObject({
+      id: 'originalId-1234',
+      supergraphSdl: getTestingSupergraphSdl(),
+    });
+  });
+
+  it('Throws error if all Uplink URLs fail', async () => {
+    mockSupergraphSdlRequest("originalId-1234", mockCloudConfigUrl1).reply(500);
+    mockSupergraphSdlRequestIfAfter("originalId-1234", mockCloudConfigUrl2).reply(500);
+
+    const fetcher = getDefaultFetcher();
+    await expect(
+      loadSupergraphSdlFromUplinks({
+        graphRef,
+        apiKey,
+        endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
+        errorReportingEndpoint: undefined,
+        fetcher,
+        compositionId: "originalId-1234",
+        maxRetries: 1,
+        roundRobinSeed: 0,
+      }),
+    ).rejects.toThrowError(
+      new UplinkFetcherError(
+        "An error occurred while fetching your schema from Apollo: 500 Internal Server Error",
+      )
+    );
+  })
+
+  describe('errors', () => {
+    it('throws on a malformed response', async () => {
+      mockSupergraphSdlRequest().reply(200, 'Invalid JSON');
+
+      const fetcher = getDefaultFetcher();
+      await expect(
+        loadSupergraphSdlFromStorage({
+          graphRef,
+          apiKey,
+          endpoint: mockCloudConfigUrl1,
+          errorReportingEndpoint: mockOutOfBandReporterUrl,
+          fetcher,
+          compositionId: null,
+        }),
+      ).rejects.toThrowError(
+        new UplinkFetcherError(
+          "An error occurred while fetching your schema from Apollo: 200 invalid json response body at https://example1.cloud-config-url.com/cloudconfig/ reason: Unexpected token I in JSON at position 0"
+        )
+      );
+    });
+
+    it('throws errors from JSON on 400', async () => {
+      const message = 'Query syntax error';
+      mockSupergraphSdlRequest().reply(
+        400,
+        JSON.stringify({
+          errors: [{ message }],
+        }),
+      );
+
+      const fetcher = getDefaultFetcher();
+      await expect(
+        loadSupergraphSdlFromStorage({
+          graphRef,
+          apiKey,
+          endpoint: mockCloudConfigUrl1,
+          errorReportingEndpoint: mockOutOfBandReporterUrl,
+          fetcher,
+          compositionId: null,
+        }),
+      ).rejects.toThrowError(
+        new UplinkFetcherError(`An error occurred while fetching your schema from Apollo: \n${message}`)
+      );
+    });
+
+    it("throws on non-OK status codes when `errors` isn't present in a JSON response", async () => {
+      mockSupergraphSdlRequest().reply(500);
+      mockOutOfBandReportRequestSuccess();
+
+      const fetcher = getDefaultFetcher();
+      await expect(
+        loadSupergraphSdlFromStorage({
+          graphRef,
+          apiKey,
+          endpoint: mockCloudConfigUrl1,
+          errorReportingEndpoint: mockOutOfBandReporterUrl,
+          fetcher,
+          compositionId: null,
+        }),
+      ).rejects.toThrowError(
+        new UplinkFetcherError(
+          "An error occurred while fetching your schema from Apollo: 500 Internal Server Error"
+        )
+      );
+    });
+
+    // if an additional request were made by the out of band reporter, nock would throw since it's unmocked
+    // and this test would fail
+    it("Out of band reporting doesn't submit reports when endpoint is not configured", async () => {
+      mockSupergraphSdlRequest().reply(400);
+
+      const fetcher = getDefaultFetcher();
+      await expect(
+        loadSupergraphSdlFromStorage({
+          graphRef,
+          apiKey,
+          endpoint: mockCloudConfigUrl1,
+          errorReportingEndpoint: mockOutOfBandReporterUrl,
+          fetcher,
+          compositionId: null,
+        }),
+      ).rejects.toThrowError(
+        new UplinkFetcherError(
+          "An error occurred while fetching your schema from Apollo: 400 invalid json response body at https://example1.cloud-config-url.com/cloudconfig/ reason: Unexpected end of JSON input",
+        )
+      );
+    });
+
+    it('throws on 400 status response and does not submit an out of band error', async () => {
+
+      mockSupergraphSdlRequest().reply(400);
+
+      const fetcher = getDefaultFetcher();
+      await expect(
+        loadSupergraphSdlFromStorage({
+          graphRef,
+          apiKey,
+          endpoint: mockCloudConfigUrl1,
+          errorReportingEndpoint: mockOutOfBandReporterUrl,
+          fetcher,
+          compositionId: null,
+        }),
+      ).rejects.toThrowError(
+        new UplinkFetcherError(
+          "An error occurred while fetching your schema from Apollo: 400 invalid json response body at https://example1.cloud-config-url.com/cloudconfig/ reason: Unexpected end of JSON input",
+        )
+      );
+    });
+
+    it('throws on 413 status response and successfully submits an out of band error', async () => {
+      mockSupergraphSdlRequest().reply(413);
+      mockOutOfBandReportRequestSuccess();
+
+      const fetcher = getDefaultFetcher();
+      await expect(
+        loadSupergraphSdlFromStorage({
+          graphRef,
+          apiKey,
+          endpoint: mockCloudConfigUrl1,
+          errorReportingEndpoint: mockOutOfBandReporterUrl,
+          fetcher,
+          compositionId: null,
+        }),
+      ).rejects.toThrowError(
+        new UplinkFetcherError(
+          "An error occurred while fetching your schema from Apollo: 413 Payload Too Large",
+        )
+      );
+    });
+
+    it('throws on 422 status response and successfully submits an out of band error', async () => {
+      mockSupergraphSdlRequest().reply(422);
+      mockOutOfBandReportRequestSuccess();
+
+      const fetcher = getDefaultFetcher();
+      await expect(
+        loadSupergraphSdlFromStorage({
+          graphRef,
+          apiKey,
+          endpoint: mockCloudConfigUrl1,
+          errorReportingEndpoint: mockOutOfBandReporterUrl,
+          fetcher,
+          compositionId: null,
+        }),
+      ).rejects.toThrowError(
+        new UplinkFetcherError(
+          "An error occurred while fetching your schema from Apollo: 422 Unprocessable Entity",
+        )
+      );
+    });
+
+    it('throws on 408 status response and successfully submits an out of band error', async () => {
+      mockSupergraphSdlRequest().reply(408);
+      mockOutOfBandReportRequestSuccess();
+
+      const fetcher = getDefaultFetcher();
+      await expect(
+        loadSupergraphSdlFromStorage({
+          graphRef,
+          apiKey,
+          endpoint: mockCloudConfigUrl1,
+          errorReportingEndpoint: mockOutOfBandReporterUrl,
+          fetcher,
+          compositionId: null,
+        }),
+      ).rejects.toThrowError(
+        new UplinkFetcherError(
+          "An error occurred while fetching your schema from Apollo: 408 Request Timeout",
+        )
+      );
+    });
+  });
+
+  it('throws on 504 status response and successfully submits an out of band error', async () => {
+
+    mockSupergraphSdlRequest().reply(504);
+    mockOutOfBandReportRequestSuccess();
+
+    const fetcher = getDefaultFetcher();
+    await expect(
+      loadSupergraphSdlFromStorage({
+        graphRef,
+        apiKey,
+        endpoint: mockCloudConfigUrl1,
+        errorReportingEndpoint: mockOutOfBandReporterUrl,
+        fetcher,
+        compositionId: null,
+      }),
+    ).rejects.toThrowError(
+      new UplinkFetcherError(
+        "An error occurred while fetching your schema from Apollo: 504 Gateway Timeout",
+      )
+    );
+  });
+
+  it('throws when there is no response and successfully submits an out of band error', async () => {
+    mockSupergraphSdlRequest().replyWithError('no response');
+    mockOutOfBandReportRequestSuccess();
+
+    const fetcher = getDefaultFetcher();
+    await expect(
+      loadSupergraphSdlFromStorage({
+        graphRef,
+        apiKey,
+        endpoint: mockCloudConfigUrl1,
+        errorReportingEndpoint: mockOutOfBandReporterUrl,
+        fetcher,
+        compositionId: null,
+      }),
+    ).rejects.toThrowError(
+      new UplinkFetcherError(
+        "An error occurred while fetching your schema from Apollo: request to https://example1.cloud-config-url.com/cloudconfig/ failed, reason: no response",
+      )
+    );
+  });
+
+  it('throws on 502 status response and successfully submits an out of band error', async () => {
+    mockSupergraphSdlRequest().reply(502);
+    mockOutOfBandReportRequestSuccess();
+
+    const fetcher = getDefaultFetcher();
+    await expect(
+      loadSupergraphSdlFromStorage({
+        graphRef,
+        apiKey,
+        endpoint: mockCloudConfigUrl1,
+        errorReportingEndpoint: mockOutOfBandReporterUrl,
+        fetcher,
+        compositionId: null,
+      }),
+    ).rejects.toThrowError(
+      new UplinkFetcherError(
+        "An error occurred while fetching your schema from Apollo: 502 Bad Gateway",
+      )
+    );
+  });
+
+  it('throws on 503 status response and successfully submits an out of band error', async () => {
+    mockSupergraphSdlRequest().reply(503);
+    mockOutOfBandReportRequestSuccess();
+
+    const fetcher = getDefaultFetcher();
+    await expect(
+      loadSupergraphSdlFromStorage({
+        graphRef,
+        apiKey,
+        endpoint: mockCloudConfigUrl1,
+        errorReportingEndpoint: mockOutOfBandReporterUrl,
+        fetcher,
+        compositionId: null,
+      }),
+    ).rejects.toThrowError(
+      new UplinkFetcherError(
+        "An error occurred while fetching your schema from Apollo: 503 Service Unavailable",
+      )
+    );
+  });
+
+  it('successfully responds to SDL unchanged by returning null', async () => {
+    mockSupergraphSdlRequestIfAfterUnchanged("id-1234");
+
+    const fetcher = getDefaultFetcher();
+    const result = await loadSupergraphSdlFromStorage({
+        graphRef,
+        apiKey,
+        endpoint: mockCloudConfigUrl1,
+        errorReportingEndpoint: mockOutOfBandReporterUrl,
+        fetcher,
+        compositionId: "id-1234",
+    });
+    expect(result).toBeNull();
+  });
+});
+
+
+describe("loadSupergraphSdlFromUplinks", () => {
+  beforeEach(nockBeforeEach);
+  afterEach(nockAfterEach);
+
+  it("doesn't retry in the unchanged / null case", async () => {
+    mockSupergraphSdlRequestIfAfterUnchanged("id-1234", mockCloudConfigUrl1);
+
+    const fetcher = jest.fn(getDefaultFetcher());
+    const result = await loadSupergraphSdlFromUplinks({
+      graphRef,
+      apiKey,
+      endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
+      errorReportingEndpoint: mockOutOfBandReporterUrl,
+      fetcher: fetcher as any,
+      compositionId: "id-1234",
+      maxRetries: 5,
+      roundRobinSeed: 0,
+    });
+
+    expect(result).toBeNull();
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+});
+

package/src/supergraphManagers/UplinkFetcher/__tests__/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../../../tsconfig.test",
+  "include": ["**/*"],
+  "references": [
+    { "path": "../../../../" },
+    { "path": "../../../../../federation-integration-testsuite-js" },
+  ]
+}

package/src/supergraphManagers/UplinkFetcher/index.ts

@@ -0,0 +1,130 @@
+import { fetch } from 'apollo-server-env';
+import { Logger } from 'apollo-server-types';
+import resolvable from '@josephg/resolvable';
+import { SupergraphManager, SupergraphSdlHookOptions } from '../../config';
+import { SubgraphHealthCheckFunction, SupergraphSdlUpdateFunction } from '../..';
+import { loadSupergraphSdlFromUplinks } from './loadSupergraphSdlFromStorage';
+
+export interface UplinkFetcherOptions {
+  pollIntervalInMs: number;
+  subgraphHealthCheck?: boolean;
+  graphRef: string;
+  apiKey: string;
+  fetcher: typeof fetch;
+  maxRetries: number;
+  uplinkEndpoints: string[];
+  logger?: Logger;
+}
+
+type State =
+  | { phase: 'initialized' }
+  | { phase: 'polling'; pollingPromise?: Promise<void> }
+  | { phase: 'stopped' };
+
+export class UplinkFetcher implements SupergraphManager {
+  private config: UplinkFetcherOptions;
+  private update?: SupergraphSdlUpdateFunction;
+  private healthCheck?: SubgraphHealthCheckFunction;
+  private timerRef: NodeJS.Timeout | null = null;
+  private state: State;
+  private errorReportingEndpoint: string | undefined =
+    process.env.APOLLO_OUT_OF_BAND_REPORTER_ENDPOINT ?? undefined;
+  private compositionId?: string;
+  private fetchCount: number = 0;
+
+  constructor(options: UplinkFetcherOptions) {
+    this.config = options;
+    this.state = { phase: 'initialized' };
+  }
+
+  public async initialize({ update, healthCheck }: SupergraphSdlHookOptions) {
+    this.update = update;
+
+    if (this.config.subgraphHealthCheck) {
+      this.healthCheck = healthCheck;
+    }
+
+    let initialSupergraphSdl: string | null = null;
+    try {
+      initialSupergraphSdl = await this.updateSupergraphSdl();
+    } catch (e) {
+      this.logUpdateFailure(e);
+      throw e;
+    }
+
+    // Start polling after we resolve the first supergraph
+    this.beginPolling();
+
+    return {
+      // on init, this supergraphSdl should never actually be `null`.
+      // `this.updateSupergraphSdl()` will only return null if the schema hasn't
+      // changed over the course of an _update_.
+      supergraphSdl: initialSupergraphSdl!,
+      cleanup: async () => {
+        if (this.state.phase === 'polling') {
+          await this.state.pollingPromise;
+        }
+        this.state = { phase: 'stopped' };
+        if (this.timerRef) {
+          clearTimeout(this.timerRef);
+          this.timerRef = null;
+        }
+      },
+    };
+  }
+
+  private async updateSupergraphSdl() {
+    const result = await loadSupergraphSdlFromUplinks({
+      graphRef: this.config.graphRef,
+      apiKey: this.config.apiKey,
+      endpoints: this.config.uplinkEndpoints,
+      errorReportingEndpoint: this.errorReportingEndpoint,
+      fetcher: this.config.fetcher,
+      compositionId: this.compositionId ?? null,
+      maxRetries: this.config.maxRetries,
+      roundRobinSeed: this.fetchCount++,
+    });
+
+    if (!result) {
+      return null;
+    } else {
+      this.compositionId = result.id;
+      // the healthCheck fn is only assigned if it's enabled in the config
+      await this.healthCheck?.(result.supergraphSdl);
+      return result.supergraphSdl;
+    }
+  }
+
+  private beginPolling() {
+    this.state = { phase: 'polling' };
+    this.poll();
+  }
+
+  private poll() {
+    this.timerRef = setTimeout(async () => {
+      if (this.state.phase === 'polling') {
+        const pollingPromise = resolvable();
+
+        this.state.pollingPromise = pollingPromise;
+        try {
+          const maybeNewSupergraphSdl = await this.updateSupergraphSdl();
+          if (maybeNewSupergraphSdl) {
+            this.update?.(maybeNewSupergraphSdl);
+          }
+        } catch (e) {
+          this.logUpdateFailure(e);
+        }
+        pollingPromise.resolve();
+      }
+
+      this.poll();
+    }, this.config.pollIntervalInMs);
+  }
+
+  private logUpdateFailure(e: any) {
+    this.config.logger?.error(
+      'UplinkFetcher failed to update supergraph with the following error: ' +
+        (e.message ?? e),
+    );
+  }
+}

package/src/{loadSupergraphSdlFromStorage.ts → supergraphManagers/UplinkFetcher/loadSupergraphSdlFromStorage.ts}

@@ -1,7 +1,9 @@
 import { fetch, Response, Request } from 'apollo-server-env';
 import { GraphQLError } from 'graphql';
-import { OutOfBandReporter } from './outOfBandReporter';
-import { SupergraphSdlQuery } from './__generated__/graphqlTypes';
+import retry from 'async-retry';
+import { SupergraphSdlUpdate } from '../../config';
+import { submitOutOfBandReportIfConfigured } from './outOfBandReporter';
+import { SupergraphSdlQuery } from '../../__generated__/graphqlTypes';
 
 // Magic /* GraphQL */ comment below is for codegen, do not remove
 export const SUPERGRAPH_SDL_QUERY = /* GraphQL */`#graphql
@@ -34,23 +36,71 @@ interface SupergraphSdlQueryFailure {
   errors: GraphQLError[];
 }
 
-const { name, version } = require('../package.json');
+const { name, version } = require('../../../package.json');
 
 const fetchErrorMsg = "An error occurred while fetching your schema from Apollo: ";
 
+export class UplinkFetcherError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'UplinkFetcherError';
+  }
+}
+
+export async function loadSupergraphSdlFromUplinks({
+  graphRef,
+  apiKey,
+  endpoints,
+  errorReportingEndpoint,
+  fetcher,
+  compositionId,
+  maxRetries,
+  roundRobinSeed,
+}: {
+  graphRef: string;
+  apiKey: string;
+  endpoints: string[];
+  errorReportingEndpoint: string | undefined,
+  fetcher: typeof fetch;
+  compositionId: string | null;
+  maxRetries: number,
+  roundRobinSeed: number,
+}) : Promise<SupergraphSdlUpdate | null> {
+  // This Promise resolves with either an updated supergraph or null if no change.
+  // This Promise can reject in the case that none of the retries are successful,
+  // in which case it will reject with the most frequently encountered error.
+  return retry(
+    () =>
+      loadSupergraphSdlFromStorage({
+        graphRef,
+        apiKey,
+        endpoint: endpoints[roundRobinSeed++ % endpoints.length],
+        errorReportingEndpoint,
+        fetcher,
+        compositionId,
+      }),
+    {
+      retries: maxRetries,
+    },
+  );
+
+}
+
 export async function loadSupergraphSdlFromStorage({
   graphRef,
   apiKey,
   endpoint,
+  errorReportingEndpoint,
   fetcher,
   compositionId,
 }: {
   graphRef: string;
   apiKey: string;
   endpoint: string;
+  errorReportingEndpoint?: string;
   fetcher: typeof fetch;
   compositionId: string | null;
-}) {
+}) : Promise<SupergraphSdlUpdate | null> {
   let result: Response;
   const requestDetails = {
     method: 'POST',
@@ -72,22 +122,22 @@ export async function loadSupergraphSdlFromStorage({
 
   const request: Request = new Request(endpoint, requestDetails);
 
-  const OOBReport = new OutOfBandReporter();
-  const startTime = new Date()
+  const startTime = new Date();
   try {
     result = await fetcher(endpoint, requestDetails);
   } catch (e) {
     const endTime = new Date();
 
-    await OOBReport.submitOutOfBandReportIfConfigured({
+    await submitOutOfBandReportIfConfigured({
       error: e,
       request,
+      endpoint: errorReportingEndpoint,
       startedAt: startTime,
       endedAt: endTime,
-      fetcher
+      fetcher,
     });
 
-    throw new Error(fetchErrorMsg + (e.message ?? e));
+    throw new UplinkFetcherError(fetchErrorMsg + (e.message ?? e));
   }
 
   const endTime = new Date();
@@ -98,26 +148,27 @@ export async function loadSupergraphSdlFromStorage({
       response = await result.json();
     } catch (e) {
       // Bad response
-      throw new Error(fetchErrorMsg + result.status + ' ' + e.message ?? e);
+      throw new UplinkFetcherError(fetchErrorMsg + result.status + ' ' + e.message ?? e);
     }
 
     if ('errors' in response) {
-      throw new Error(
+      throw new UplinkFetcherError(
         [fetchErrorMsg, ...response.errors.map((error) => error.message)].join(
           '\n',
         ),
       );
     }
   } else {
-    await OOBReport.submitOutOfBandReportIfConfigured({
-      error: new Error(fetchErrorMsg + result.status + ' ' + result.statusText),
+    await submitOutOfBandReportIfConfigured({
+      error: new UplinkFetcherError(fetchErrorMsg + result.status + ' ' + result.statusText),
       request,
+      endpoint: errorReportingEndpoint,
       response: result,
       startedAt: startTime,
       endedAt: endTime,
-      fetcher
+      fetcher,
     });
-    throw new Error(fetchErrorMsg + result.status + ' ' + result.statusText);
+    throw new UplinkFetcherError(fetchErrorMsg + result.status + ' ' + result.statusText);
   }
 
   const { routerConfig } = response.data;
@@ -131,10 +182,10 @@ export async function loadSupergraphSdlFromStorage({
   } else if (routerConfig.__typename === 'FetchError') {
     // FetchError case
     const { code, message } = routerConfig;
-    throw new Error(`${code}: ${message}`);
+    throw new UplinkFetcherError(`${code}: ${message}`);
   } else if (routerConfig.__typename === 'Unchanged') {
     return null;
   } else {
-    throw new Error('Programming error: unhandled response failure');
+    throw new UplinkFetcherError('Programming error: unhandled response failure');
   }
 }