@apollo/gateway 0.46.0-alpha.0 → 0.48.1

package/src/schema-helper/resolverMap.ts

@@ -0,0 +1,23 @@
+import { GraphQLFieldResolver, GraphQLScalarType, DocumentNode } from 'graphql';
+
+export interface GraphQLSchemaModule {
+  typeDefs: DocumentNode;
+  resolvers?: GraphQLResolverMap<any>;
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export interface GraphQLResolverMap<TContext = {}> {
+  [typeName: string]:
+    | {
+        [fieldName: string]:
+          | GraphQLFieldResolver<any, TContext, any>
+          | {
+              requires?: string;
+              resolve: GraphQLFieldResolver<any, TContext, any>;
+            };
+      }
+    | GraphQLScalarType
+    | {
+        [enumValue: string]: string | number;
+      };
+}

package/src/supergraphManagers/LegacyFetcher/index.ts

@@ -222,7 +222,7 @@ export class LegacyFetcher implements SupergraphManager {
 
   private logUpdateFailure(e: any) {
     this.config.logger?.error(
-      'UplinkFetcher failed to update supergraph with the following error: ' +
+      'LegacyFetcher failed to update supergraph with the following error: ' +
         (e.message ?? e),
     );
   }

package/src/supergraphManagers/LocalCompose/index.ts

@@ -76,7 +76,7 @@ export class LocalCompose implements SupergraphManager {
 
   private logUpdateFailure(e: any) {
     this.config.logger?.error(
-      'UplinkFetcher failed to update supergraph with the following error: ' +
+      'LocalCompose failed to update supergraph with the following error: ' +
         (e.message ?? e),
     );
   }

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

@@ -1,6 +1,7 @@
 import {
   loadSupergraphSdlFromStorage,
-  loadSupergraphSdlFromUplinks
+  loadSupergraphSdlFromUplinks,
+  UplinkFetcherError,
 } from '../loadSupergraphSdlFromStorage';
 import { getDefaultFetcher } from '../../..';
 import {
@@ -62,7 +63,8 @@ describe('loadSupergraphSdlFromStorage', () => {
       errorReportingEndpoint: undefined,
       fetcher,
       compositionId: "originalId-1234",
-      maxRetries: 1
+      maxRetries: 1,
+      roundRobinSeed: 0,
     });
 
     expect(result).toMatchObject({
@@ -84,10 +86,13 @@ describe('loadSupergraphSdlFromStorage', () => {
         errorReportingEndpoint: undefined,
         fetcher,
         compositionId: "originalId-1234",
-        maxRetries: 1
+        maxRetries: 1,
+        roundRobinSeed: 0,
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `"An error occurred while fetching your schema from Apollo: 500 Internal Server Error"`,
+    ).rejects.toThrowError(
+      new UplinkFetcherError(
+        "An error occurred while fetching your schema from Apollo: 500 Internal Server Error",
+      )
     );
   })
 
@@ -105,8 +110,10 @@ describe('loadSupergraphSdlFromStorage', () => {
           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"`,
+      ).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"
+        )
       );
     });
 
@@ -129,7 +136,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           fetcher,
           compositionId: null,
         }),
-      ).rejects.toThrowError(message);
+      ).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 () => {
@@ -146,8 +155,10 @@ describe('loadSupergraphSdlFromStorage', () => {
           fetcher,
           compositionId: null,
         }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"An error occurred while fetching your schema from Apollo: 500 Internal Server Error"`,
+      ).rejects.toThrowError(
+        new UplinkFetcherError(
+          "An error occurred while fetching your schema from Apollo: 500 Internal Server Error"
+        )
       );
     });
 
@@ -166,8 +177,10 @@ describe('loadSupergraphSdlFromStorage', () => {
           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"`,
+      ).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",
+        )
       );
     });
 
@@ -185,8 +198,10 @@ describe('loadSupergraphSdlFromStorage', () => {
           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"`,
+      ).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",
+        )
       );
     });
 
@@ -204,8 +219,10 @@ describe('loadSupergraphSdlFromStorage', () => {
           fetcher,
           compositionId: null,
         }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"An error occurred while fetching your schema from Apollo: 413 Payload Too Large"`,
+      ).rejects.toThrowError(
+        new UplinkFetcherError(
+          "An error occurred while fetching your schema from Apollo: 413 Payload Too Large",
+        )
       );
     });
 
@@ -223,8 +240,10 @@ describe('loadSupergraphSdlFromStorage', () => {
           fetcher,
           compositionId: null,
         }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"An error occurred while fetching your schema from Apollo: 422 Unprocessable Entity"`,
+      ).rejects.toThrowError(
+        new UplinkFetcherError(
+          "An error occurred while fetching your schema from Apollo: 422 Unprocessable Entity",
+        )
       );
     });
 
@@ -242,8 +261,10 @@ describe('loadSupergraphSdlFromStorage', () => {
           fetcher,
           compositionId: null,
         }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"An error occurred while fetching your schema from Apollo: 408 Request Timeout"`,
+      ).rejects.toThrowError(
+        new UplinkFetcherError(
+          "An error occurred while fetching your schema from Apollo: 408 Request Timeout",
+        )
       );
     });
   });
@@ -263,8 +284,10 @@ describe('loadSupergraphSdlFromStorage', () => {
         fetcher,
         compositionId: null,
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `"An error occurred while fetching your schema from Apollo: 504 Gateway Timeout"`,
+    ).rejects.toThrowError(
+      new UplinkFetcherError(
+        "An error occurred while fetching your schema from Apollo: 504 Gateway Timeout",
+      )
     );
   });
 
@@ -282,8 +305,10 @@ describe('loadSupergraphSdlFromStorage', () => {
         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"`,
+    ).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",
+      )
     );
   });
 
@@ -301,8 +326,10 @@ describe('loadSupergraphSdlFromStorage', () => {
         fetcher,
         compositionId: null,
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `"An error occurred while fetching your schema from Apollo: 502 Bad Gateway"`,
+    ).rejects.toThrowError(
+      new UplinkFetcherError(
+        "An error occurred while fetching your schema from Apollo: 502 Bad Gateway",
+      )
     );
   });
 
@@ -320,8 +347,10 @@ describe('loadSupergraphSdlFromStorage', () => {
         fetcher,
         compositionId: null,
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `"An error occurred while fetching your schema from Apollo: 503 Service Unavailable"`,
+    ).rejects.toThrowError(
+      new UplinkFetcherError(
+        "An error occurred while fetching your schema from Apollo: 503 Service Unavailable",
+      )
     );
   });
 
@@ -341,3 +370,28 @@ describe('loadSupergraphSdlFromStorage', () => {
   });
 });
 
+
+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/index.ts

@@ -30,6 +30,7 @@ export class UplinkFetcher implements SupergraphManager {
   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;
@@ -81,6 +82,7 @@ export class UplinkFetcher implements SupergraphManager {
       fetcher: this.config.fetcher,
       compositionId: this.compositionId ?? null,
       maxRetries: this.config.maxRetries,
+      roundRobinSeed: this.fetchCount++,
     });
 
     if (!result) {

package/src/supergraphManagers/UplinkFetcher/loadSupergraphSdlFromStorage.ts

@@ -1,5 +1,6 @@
 import { fetch, Response, Request } from 'apollo-server-env';
 import { GraphQLError } from 'graphql';
+import retry from 'async-retry';
 import { SupergraphSdlUpdate } from '../../config';
 import { submitOutOfBandReportIfConfigured } from './outOfBandReporter';
 import { SupergraphSdlQuery } from '../../__generated__/graphqlTypes';
@@ -39,7 +40,12 @@ const { name, version } = require('../../../package.json');
 
 const fetchErrorMsg = "An error occurred while fetching your schema from Apollo: ";
 
-let fetchCounter = 0;
+export class UplinkFetcherError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'UplinkFetcherError';
+  }
+}
 
 export async function loadSupergraphSdlFromUplinks({
   graphRef,
@@ -49,6 +55,7 @@ export async function loadSupergraphSdlFromUplinks({
   fetcher,
   compositionId,
   maxRetries,
+  roundRobinSeed,
 }: {
   graphRef: string;
   apiKey: string;
@@ -56,29 +63,27 @@ export async function loadSupergraphSdlFromUplinks({
   errorReportingEndpoint: string | undefined,
   fetcher: typeof fetch;
   compositionId: string | null;
-  maxRetries: number
+  maxRetries: number,
+  roundRobinSeed: number,
 }) : Promise<SupergraphSdlUpdate | null> {
-  let retries = 0;
-  let lastException = null;
-  let result: SupergraphSdlUpdate | null = null;
-  while (retries++ <= maxRetries && result == null) {
-    try {
-      result = await loadSupergraphSdlFromStorage({
+  // 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[fetchCounter++ % endpoints.length],
+        endpoint: endpoints[roundRobinSeed++ % endpoints.length],
         errorReportingEndpoint,
         fetcher,
-        compositionId
-      });
-    } catch (e) {
-      lastException = e;
-    }
-  }
-  if (result === null && lastException !== null) {
-    throw lastException;
-  }
-  return result;
+        compositionId,
+      }),
+    {
+      retries: maxRetries,
+    },
+  );
+
 }
 
 export async function loadSupergraphSdlFromStorage({
@@ -132,7 +137,7 @@ export async function loadSupergraphSdlFromStorage({
       fetcher,
     });
 
-    throw new Error(fetchErrorMsg + (e.message ?? e));
+    throw new UplinkFetcherError(fetchErrorMsg + (e.message ?? e));
   }
 
   const endTime = new Date();
@@ -143,11 +148,11 @@ 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',
         ),
@@ -155,7 +160,7 @@ export async function loadSupergraphSdlFromStorage({
     }
   } else {
     await submitOutOfBandReportIfConfigured({
-      error: new Error(fetchErrorMsg + result.status + ' ' + result.statusText),
+      error: new UplinkFetcherError(fetchErrorMsg + result.status + ' ' + result.statusText),
       request,
       endpoint: errorReportingEndpoint,
       response: result,
@@ -163,7 +168,7 @@ export async function loadSupergraphSdlFromStorage({
       endedAt: endTime,
       fetcher,
     });
-    throw new Error(fetchErrorMsg + result.status + ' ' + result.statusText);
+    throw new UplinkFetcherError(fetchErrorMsg + result.status + ' ' + result.statusText);
   }
 
   const { routerConfig } = response.data;
@@ -177,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');
   }
 }

package/src/supergraphManagers/index.ts

@@ -2,3 +2,4 @@ export { LocalCompose } from './LocalCompose';
 export { LegacyFetcher } from './LegacyFetcher';
 export { IntrospectAndCompose } from './IntrospectAndCompose';
 export { UplinkFetcher } from './UplinkFetcher';
+export { UplinkFetcherError } from './UplinkFetcher/loadSupergraphSdlFromStorage'

package/src/utilities/__tests__/cleanErrorOfInaccessibleElements.test.ts

@@ -49,17 +49,17 @@ describe('cleanErrorOfInaccessibleNames', () => {
   schema = toAPISchema(schema);
 
   it('removes inaccessible type names from error messages', async () => {
-    const result = await execute(schema, parse('{fooField{someField}}'), {
+    const result = await execute({ schema, document: parse('{fooField{someField}}'), rootValue: {
       fooField: {
         __typename: 'Bar',
         someField: 'test',
       },
-    });
+    }});
 
     const cleaned = cleanErrorOfInaccessibleNames(schema, result.errors?.[0]!);
-    expect(cleaned.message).toMatchInlineSnapshot(
-      `"Abstract type \\"Foo\\" was resolve to a type [inaccessible type] that does not exist inside schema."`,
-    );
+    // graphql 15 and 16 changed the error message just a bit, but this is sufficient and will pass for both
+    expect(cleaned.message).toContain('Abstract type "Foo" was resolve');
+    expect(cleaned.message).toContain("to a type [inaccessible type] that does not exist");
   });
 
   it('removes multiple/repeated inaccessible type names from error messages', async () => {