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

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

@@ -0,0 +1,343 @@
+import {
+  loadSupergraphSdlFromStorage,
+  loadSupergraphSdlFromUplinks
+} 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
+    });
+
+    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
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `"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.toThrowErrorMatchingInlineSnapshot(
+        `"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(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.toThrowErrorMatchingInlineSnapshot(
+        `"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.toThrowErrorMatchingInlineSnapshot(
+        `"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.toThrowErrorMatchingInlineSnapshot(
+        `"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.toThrowErrorMatchingInlineSnapshot(
+        `"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.toThrowErrorMatchingInlineSnapshot(
+        `"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.toThrowErrorMatchingInlineSnapshot(
+        `"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.toThrowErrorMatchingInlineSnapshot(
+      `"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.toThrowErrorMatchingInlineSnapshot(
+      `"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.toThrowErrorMatchingInlineSnapshot(
+      `"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.toThrowErrorMatchingInlineSnapshot(
+      `"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();
+  });
+});
+

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,128 @@
+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;
+
+  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,
+    });
+
+    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,12 +1,13 @@
 import { fetch, Response, Request } from 'apollo-server-env';
 import { GraphQLError } from 'graphql';
-import { OutOfBandReporter } from './outOfBandReporter';
-import { SupergraphSdlQuery } from './__generated__/graphqlTypes';
+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
-  query SupergraphSdl($apiKey: String!, $ref: String!) {
-    routerConfig(ref: $ref, apiKey: $apiKey) {
+  query SupergraphSdl($apiKey: String!, $ref: String!, $ifAfterId: ID) {
+    routerConfig(ref: $ref, apiKey: $apiKey, ifAfterId: $ifAfterId) {
       __typename
       ... on RouterConfigResult {
         id
@@ -34,21 +35,67 @@ 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: ";
 
+let fetchCounter = 0;
+
+export async function loadSupergraphSdlFromUplinks({
+  graphRef,
+  apiKey,
+  endpoints,
+  errorReportingEndpoint,
+  fetcher,
+  compositionId,
+  maxRetries,
+}: {
+  graphRef: string;
+  apiKey: string;
+  endpoints: string[];
+  errorReportingEndpoint: string | undefined,
+  fetcher: typeof fetch;
+  compositionId: string | null;
+  maxRetries: number
+}) : Promise<SupergraphSdlUpdate | null> {
+  let retries = 0;
+  let lastException = null;
+  let result: SupergraphSdlUpdate | null = null;
+  while (retries++ <= maxRetries && result == null) {
+    try {
+      result = await loadSupergraphSdlFromStorage({
+        graphRef,
+        apiKey,
+        endpoint: endpoints[fetchCounter++ % endpoints.length],
+        errorReportingEndpoint,
+        fetcher,
+        compositionId
+      });
+    } catch (e) {
+      lastException = e;
+    }
+  }
+  if (result === null && lastException !== null) {
+    throw lastException;
+  }
+  return result;
+}
+
 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',
@@ -57,6 +104,7 @@ export async function loadSupergraphSdlFromStorage({
       variables: {
         ref: graphRef,
         apiKey,
+        ifAfterId: compositionId,
       },
     }),
     headers: {
@@ -69,19 +117,19 @@ 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));
@@ -106,13 +154,14 @@ export async function loadSupergraphSdlFromStorage({
       );
     }
   } else {
-    await OOBReport.submitOutOfBandReportIfConfigured({
+    await submitOutOfBandReportIfConfigured({
       error: new Error(fetchErrorMsg + result.status + ' ' + result.statusText),
       request,
+      endpoint: errorReportingEndpoint,
       response: result,
       startedAt: startTime,
       endedAt: endTime,
-      fetcher
+      fetcher,
     });
     throw new Error(fetchErrorMsg + result.status + ' ' + result.statusText);
   }
@@ -124,13 +173,13 @@ export async function loadSupergraphSdlFromStorage({
       supergraphSdl,
       // messages,
     } = routerConfig;
-
-    // `supergraphSdl` should not be nullable in the schema, but it currently is
     return { id, supergraphSdl: supergraphSdl! };
   } else if (routerConfig.__typename === 'FetchError') {
     // FetchError case
     const { code, message } = routerConfig;
     throw new Error(`${code}: ${message}`);
+  } else if (routerConfig.__typename === 'Unchanged') {
+    return null;
   } else {
     throw new Error('Programming error: unhandled response failure');
   }