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

package/src/__tests__/nockAssertions.ts

@@ -0,0 +1,20 @@
+import nock from 'nock';
+
+// Ensures an active and clean nock before every test
+export function nockBeforeEach() {
+  if (!nock.isActive()) {
+    nock.activate();
+  }
+  // Cleaning _before_ each test ensures that any mocks from a previous test
+  // which failed don't affect the current test.
+  nock.cleanAll();
+}
+
+// Ensures a test is complete (all expected requests were run) and a clean
+// global state after each test.
+export function nockAfterEach() {
+  // unmock HTTP interceptor
+  nock.restore();
+  // effectively nock.isDone() but with more helpful messages in test failures
+  expect(nock.activeMocks()).toEqual([]);
+};

package/src/config.ts

@@ -140,7 +140,9 @@ export interface ManagedGatewayConfig extends GatewayConfigBase {
    * This configuration option shouldn't be used unless by recommendation from
    * Apollo staff.
    */
-  schemaConfigDeliveryEndpoint?: string;
+  schemaConfigDeliveryEndpoint?: string; // deprecated
+  uplinkEndpoints?: string[];
+  uplinkMaxRetries?: number;
 }
 
 interface ManuallyManagedServiceDefsGatewayConfig extends GatewayConfigBase {

package/src/datasources/RemoteGraphQLDataSource.ts

@@ -17,18 +17,24 @@ import { isObject } from '../utilities/predicates';
 import { GraphQLDataSource, GraphQLDataSourceProcessOptions, GraphQLDataSourceRequestKind } from './types';
 import createSHA from 'apollo-server-core/dist/utils/createSHA';
 import { parseCacheControlHeader } from './parseCacheControlHeader';
-
+import fetcher from 'make-fetch-happen';
 export class RemoteGraphQLDataSource<
   TContext extends Record<string, any> = Record<string, any>,
 > implements GraphQLDataSource<TContext>
 {
-  fetcher: typeof fetch = fetch;
+  fetcher: typeof fetch;
 
   constructor(
     config?: Partial<RemoteGraphQLDataSource<TContext>> &
       object &
       ThisType<RemoteGraphQLDataSource<TContext>>,
   ) {
+    this.fetcher = fetcher.defaults({
+      // although this is the default, we want to take extra care and be very
+      // explicity to ensure that mutations cannot be retried. please leave this
+      // intact.
+      retry: false,
+    });
     if (config) {
       return Object.assign(this, config);
     }

package/src/datasources/__tests__/RemoteGraphQLDataSource.test.ts

@@ -1,5 +1,5 @@
-import { fetch } from '../../__mocks__/apollo-server-env';
-import { makeFetchHappenFetcher } from '../../__mocks__/make-fetch-happen-fetcher';
+import { fetch as customFetcher } from '../../__mocks__/apollo-server-env';
+import { fetch } from '../../__mocks__/make-fetch-happen-fetcher';
 
 import {
   ApolloError,
@@ -263,8 +263,8 @@ describe('fetcher', () => {
     expect(data).toEqual({ injected: true });
   });
 
-  it('supports a custom fetcher, like `make-fetch-happen`', async () => {
-    const injectedFetch = makeFetchHappenFetcher.mockJSONResponseOnce({
+  it('supports a custom fetcher, like `node-fetch`', async () => {
+    const injectedFetch = customFetcher.mockJSONResponseOnce({
       data: { me: 'james' },
     });
     const DataSource = new RemoteGraphQLDataSource({

package/src/executeQueryPlan.ts

@@ -489,7 +489,17 @@ function executeSelectionSet(
         const selections = (selection as QueryPlanFieldNode).selections;
 
         if (typeof source[responseName] === 'undefined') {
-          throw new Error(`Field "${responseName}" was not found in response.`);
+          // This method is called to collect the inputs/requires of a fetch. So, assuming query plans are correct
+          // (and we have not reason to assume otherwise here), all inputs should be fetched beforehand and the
+          // only reason for not finding one of the inputs is that we had an error fetching it _and_ that field
+          // is non-nullable (it it was nullable, error fetching the input would have make that input `null`; not
+          // having the input means the field is non-nullable so the whole entity had to be nullified/ignored,
+          // leading use to not have the field at all).
+          // In any case, we don't have all the necessary inputs for this particular entity and should ignore it.
+          // Note that an error has already been logged for whichever issue happen while fetching the inputs we're
+          // missing here, and that error had much more context, so no reason to log a duplicate (less useful) error
+          // here.
+          return null;
         }
         if (Array.isArray(source[responseName])) {
           result[responseName] = source[responseName].map((value: any) =>

package/src/index.ts

@@ -57,7 +57,7 @@ import {
   SupergraphSdlUpdate,
   CompositionUpdate,
 } from './config';
-import { loadSupergraphSdlFromStorage } from './loadSupergraphSdlFromStorage';
+import {loadSupergraphSdlFromUplinks} from './loadSupergraphSdlFromStorage';
 import { SpanStatusCode } from '@opentelemetry/api';
 import { OpenTelemetrySpanNames, tracer } from './utilities/opentelemetry';
 
@@ -184,6 +184,8 @@ export class ApolloGateway implements GraphQLService {
   private fetcher: typeof fetch;
   private compositionId?: string;
   private state: GatewayState;
+  private errorReportingEndpoint: string | undefined =
+    process.env.APOLLO_OUT_OF_BAND_REPORTER_ENDPOINT ?? undefined;
 
   // Observe query plan, service info, and operation info prior to execution.
   // The information made available here will give insight into the resulting
@@ -201,10 +203,11 @@ export class ApolloGateway implements GraphQLService {
   private updateServiceDefinitions: Experimental_UpdateComposition;
   // how often service defs should be loaded/updated (in ms)
   private experimental_pollInterval?: number;
-  // Configure the endpoint by which gateway will access its precomposed schema.
-  // * `string` means use that endpoint
+  // Configure the endpoints by which gateway will access its precomposed schema.
+  // * An array of URLs means use these endpoints to obtain schema, if one is unavailable then try the next.
   // * `undefined` means the gateway is not using managed federation
-  private schemaConfigDeliveryEndpoint?: string;
+  private uplinkEndpoints?: string[];
+  private uplinkMaxRetries?: number;
 
   constructor(config?: GatewayConfig) {
     this.config = {
@@ -233,13 +236,22 @@ export class ApolloGateway implements GraphQLService {
 
     // 1. If config is set to a `string`, use it
     // 2. If the env var is set, use that
-    // 3. If config is `undefined`, use the default uplink URL
+    // 3. If config is `undefined`, use the default uplink URLs
     if (isManagedConfig(this.config)) {
-      const envEndpoint = process.env.APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT;
-      this.schemaConfigDeliveryEndpoint =
-        this.config.schemaConfigDeliveryEndpoint ??
-        envEndpoint ??
-        'https://uplink.api.apollographql.com/';
+      const rawEndpointsString = process.env.APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT;
+      const envEndpoints = rawEndpointsString?.split(",") ?? null;
+
+      if (this.config.schemaConfigDeliveryEndpoint && !this.config.uplinkEndpoints) {
+        this.uplinkEndpoints = [this.config.schemaConfigDeliveryEndpoint];
+      } else {
+        this.uplinkEndpoints = this.config.uplinkEndpoints ??
+          envEndpoints ?? [
+              'https://uplink.api.apollographql.com/',
+              'https://aws.uplink.api.apollographql.com/'
+            ];
+      }
+
+      this.uplinkMaxRetries = this.config.uplinkMaxRetries ?? this.uplinkEndpoints.length * 3;
     }
 
     if (isManuallyManagedConfig(this.config)) {
@@ -916,12 +928,14 @@ export class ApolloGateway implements GraphQLService {
       );
     }
 
-    const result = await loadSupergraphSdlFromStorage({
+    const result = await loadSupergraphSdlFromUplinks({
       graphRef: this.apolloConfig!.graphRef!,
       apiKey: this.apolloConfig!.key!,
-      endpoint: this.schemaConfigDeliveryEndpoint!,
+      endpoints: this.uplinkEndpoints!,
+      errorReportingEndpoint: this.errorReportingEndpoint,
       fetcher: this.fetcher,
       compositionId: this.compositionId ?? null,
+      maxRetries: this.uplinkMaxRetries!,
     });
 
     return (

package/src/loadSupergraphSdlFromStorage.ts

@@ -1,6 +1,7 @@
 import { fetch, Response, Request } from 'apollo-server-env';
 import { GraphQLError } from 'graphql';
-import { OutOfBandReporter } from './outOfBandReporter';
+import { SupergraphSdlUpdate } from './config';
+import { submitOutOfBandReportIfConfigured } from './outOfBandReporter';
 import { SupergraphSdlQuery } from './__generated__/graphqlTypes';
 
 // Magic /* GraphQL */ comment below is for codegen, do not remove
@@ -38,19 +39,63 @@ 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',
@@ -72,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));
@@ -109,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);
   }

package/src/outOfBandReporter.ts

@@ -27,102 +27,100 @@ interface OobReportMutationFailure {
   data?: OobReportMutation;
   errors: GraphQLError[];
 }
-export class OutOfBandReporter {
-  static endpoint: string | null = process.env.APOLLO_OUT_OF_BAND_REPORTER_ENDPOINT || null;
 
-  async submitOutOfBandReportIfConfigured({
-    error,
-    request,
-    response,
-    startedAt,
-    endedAt,
-    tags,
-    fetcher,
-  }: {
-    error: Error;
-    request: Request;
-    response?: Response;
-    startedAt: Date;
-    endedAt: Date;
-    tags?: string[];
-    fetcher: typeof fetch;
-  }) {
-
-    // don't send report if the endpoint url is not configured
-    if (!OutOfBandReporter.endpoint) {
-      return;
-    }
+export async function submitOutOfBandReportIfConfigured({
+  error,
+  request,
+  endpoint,
+  response,
+  startedAt,
+  endedAt,
+  tags,
+  fetcher,
+}: {
+  error: Error;
+  request: Request;
+  endpoint: string | undefined;
+  response?: Response;
+  startedAt: Date;
+  endedAt: Date;
+  tags?: string[];
+  fetcher: typeof fetch;
+}) {
+  // don't send report if the endpoint url is not configured
+  if (!endpoint) {
+    return;
+  }
 
-    let errorCode: ErrorCode;
-    if (!response) {
-      errorCode = ErrorCode.ConnectionFailed;
-    } else {
-      // possible error situations to check against
-      switch (response.status) {
-        case 400:
-        case 413:
-        case 422:
-          errorCode = ErrorCode.InvalidBody;
-          break;
-        case 408:
-        case 504:
-          errorCode = ErrorCode.Timeout;
-          break;
-        case 502:
-        case 503:
-          errorCode = ErrorCode.ConnectionFailed;
-          break;
-        default:
-          errorCode = ErrorCode.Other;
-      }
+  let errorCode: ErrorCode;
+  if (!response) {
+    errorCode = ErrorCode.ConnectionFailed;
+  } else {
+    // possible error situations to check against
+    switch (response.status) {
+      case 400:
+      case 413:
+      case 422:
+        errorCode = ErrorCode.InvalidBody;
+        break;
+      case 408:
+      case 504:
+        errorCode = ErrorCode.Timeout;
+        break;
+      case 502:
+      case 503:
+        errorCode = ErrorCode.ConnectionFailed;
+        break;
+      default:
+        errorCode = ErrorCode.Other;
     }
+  }
 
-    const responseBody: string | undefined = await response?.text();
+  const responseBody: string | undefined = await response?.text();
 
-    const variables: OobReportMutationVariables = {
-      input: {
-        error: {
-          code: errorCode,
-          message: error.message,
-        },
-        request: {
-          url: request.url,
-          body: await request.text(),
-        },
-        response: response
-          ? {
-              httpStatusCode: response.status,
-              body: responseBody,
-            }
-          : null,
-        startedAt: startedAt.toISOString(),
-        endedAt: endedAt.toISOString(),
-        tags: tags,
+  const variables: OobReportMutationVariables = {
+    input: {
+      error: {
+        code: errorCode,
+        message: error.message,
+      },
+      request: {
+        url: request.url,
+        body: await request.text(),
       },
-    };
+      response: response
+        ? {
+            httpStatusCode: response.status,
+            body: responseBody,
+          }
+        : null,
+      startedAt: startedAt.toISOString(),
+      endedAt: endedAt.toISOString(),
+      tags: tags,
+    },
+  };
 
-    try {
-      const oobResponse = await fetcher(OutOfBandReporter.endpoint, {
-        method: 'POST',
-        body: JSON.stringify({
-          query: OUT_OF_BAND_REPORTER_QUERY,
-          variables,
-        }),
-        headers: {
-          'apollographql-client-name': name,
-          'apollographql-client-version': version,
-          'user-agent': `${name}/${version}`,
-          'content-type': 'application/json',
-        },
-      });
-      const parsedResponse: OobReportMutationResult = await oobResponse.json();
-      if (!parsedResponse?.data?.reportError) {
-        throw new Error(
-          `Out-of-band error reporting failed: ${oobResponse.status} ${oobResponse.statusText}`,
-        );
-      }
-    } catch (e) {
-      throw new Error(`Out-of-band error reporting failed: ${e.message ?? e}`);
+  try {
+    const oobResponse = await fetcher(endpoint, {
+      method: 'POST',
+      body: JSON.stringify({
+        query: OUT_OF_BAND_REPORTER_QUERY,
+        variables,
+      }),
+      headers: {
+        'apollographql-client-name': name,
+        'apollographql-client-version': version,
+        'user-agent': `${name}/${version}`,
+        'content-type': 'application/json',
+      },
+    });
+    const parsedResponse: OobReportMutationResult = await oobResponse.json();
+    if (!parsedResponse?.data?.reportError) {
+      throw new Error(
+        `Out-of-band error reporting failed: ${oobResponse.status} ${oobResponse.statusText}`,
+      );
     }
+  } catch (e) {
+    throw new Error(`Out-of-band error reporting failed: ${e.message ?? e}`);
   }
 }