@apollo/gateway 0.50.2 → 0.52.1

package/src/index.ts

@@ -1,11 +1,6 @@
 import { deprecate } from 'util';
-import { GraphQLService, Unsubscriber } from 'apollo-server-core';
-import {
-  GraphQLExecutionResult,
-  GraphQLRequestContextExecutionDidStart,
-} from 'apollo-server-types';
 import type { Logger } from '@apollo/utils.logger';
-import { InMemoryLRUCache } from 'apollo-server-caching';
+import LRUCache from 'lru-cache';
 import {
   isObjectType,
   isIntrospectionType,
@@ -31,8 +26,6 @@ import {
 import { RemoteGraphQLDataSource } from './datasources/RemoteGraphQLDataSource';
 import { getVariableValues } from 'graphql/execution/values';
 import fetcher from 'make-fetch-happen';
-import { HttpRequestCache } from './cache';
-import { fetch } from 'apollo-server-env';
 import {
   QueryPlanner,
   QueryPlan,
@@ -69,6 +62,8 @@ import {
   LegacyFetcher,
   LocalCompose,
 } from './supergraphManagers';
+import { Fetcher } from '@apollo/utils.fetcher';
+import {GatewayInterface, GatewayUnsubscriber, GatewayGraphQLRequestContext, GatewayExecutionResult} from '@apollo/server-gateway-interface';
 
 type DataSourceMap = {
   [serviceName: string]: { url?: string; dataSource: GraphQLDataSource };
@@ -83,30 +78,6 @@ type WarnedStates = {
   remoteWithLocalConfig?: boolean;
 };
 
-export function getDefaultFetcher() {
-  const { name, version } = require('../package.json');
-  return fetcher.defaults({
-    cacheManager: new HttpRequestCache(),
-    // All headers should be lower-cased here, as `make-fetch-happen`
-    // treats differently cased headers as unique (unlike the `Headers` object).
-    // @see: https://git.io/JvRUa
-    headers: {
-      'apollographql-client-name': name,
-      'apollographql-client-version': version,
-      'user-agent': `${name}/${version}`,
-      'content-type': 'application/json',
-    },
-    retry: {
-      retries: 5,
-      // The default factor: expected attempts at 0, 1, 3, 7, 15, and 31 seconds elapsed
-      factor: 2,
-      // 1 second
-      minTimeout: 1000,
-      randomize: true,
-    },
-  });
-}
-
 export const HEALTH_CHECK_QUERY =
   'query __ApolloServiceHealthCheck__ { __typename }';
 export const SERVICE_DEFINITION_QUERY =
@@ -148,12 +119,12 @@ interface GraphQLServiceEngineConfig {
   graphVariant?: string;
 }
 
-export class ApolloGateway implements GraphQLService {
+export class ApolloGateway implements GatewayInterface {
   public schema?: GraphQLSchema;
   private serviceMap: DataSourceMap = Object.create(null);
   private config: GatewayConfig;
   private logger: Logger;
-  private queryPlanStore: InMemoryLRUCache<QueryPlan>;
+  private queryPlanStore: LRUCache<string, QueryPlan>;
   private apolloConfig?: ApolloConfigFromAS3;
   private onSchemaChangeListeners = new Set<(schema: GraphQLSchema) => void>();
   private onSchemaLoadOrUpdateListeners = new Set<
@@ -166,7 +137,7 @@ export class ApolloGateway implements GraphQLService {
   private queryPlanner?: QueryPlanner;
   private supergraphSdl?: string;
   private parsedSupergraphSdl?: DocumentNode;
-  private fetcher: typeof fetch;
+  private fetcher: Fetcher;
   private compositionId?: string;
   private state: GatewayState;
 
@@ -194,7 +165,7 @@ export class ApolloGateway implements GraphQLService {
     this.queryPlanStore = this.initQueryPlanStore(
       config?.experimental_approximateQueryPlanStoreMiB,
     );
-    this.fetcher = config?.fetcher || getDefaultFetcher();
+    this.fetcher = config?.fetcher || fetcher;
 
     // set up experimental observability callbacks and config settings
     this.experimental_didResolveQueryPlan =
@@ -235,14 +206,14 @@ export class ApolloGateway implements GraphQLService {
   }
 
   private initQueryPlanStore(approximateQueryPlanStoreMiB?: number) {
-    return new InMemoryLRUCache<QueryPlan>({
+    return new LRUCache<string, QueryPlan>({
       // Create ~about~ a 30MiB InMemoryLRUCache.  This is less than precise
       // since the technique to calculate the size of a DocumentNode is
       // only using JSON.stringify on the DocumentNode (and thus doesn't account
       // for unicode characters, etc.), but it should do a reasonable job at
       // providing a caching document store for most operations.
       maxSize: Math.pow(2, 20) * (approximateQueryPlanStoreMiB || 30),
-      sizeCalculator: approximateObjectSize,
+      sizeCalculation: approximateObjectSize,
     });
   }
 
@@ -632,7 +603,7 @@ export class ApolloGateway implements GraphQLService {
     // Once we remove the deprecated onSchemaChange() method, we can remove this.
     legacyDontNotifyOnSchemaChangeListeners: boolean = false,
   ): void {
-    if (this.queryPlanStore) this.queryPlanStore.flush();
+    this.queryPlanStore.clear();
     this.schema = toAPISchema(coreSchema);
     this.queryPlanner = new QueryPlanner(coreSchema);
 
@@ -743,7 +714,7 @@ export class ApolloGateway implements GraphQLService {
    */
   public onSchemaChange(
     callback: (schema: GraphQLSchema) => void,
-  ): Unsubscriber {
+  ): GatewayUnsubscriber {
     this.onSchemaChangeListeners.add(callback);
 
     return () => {
@@ -756,7 +727,7 @@ export class ApolloGateway implements GraphQLService {
       apiSchema: GraphQLSchema;
       coreSupergraphSdl: string;
     }) => void,
-  ): Unsubscriber {
+  ): GatewayUnsubscriber {
     this.onSchemaLoadOrUpdateListeners.add(callback);
 
     return () => {
@@ -836,9 +807,9 @@ export class ApolloGateway implements GraphQLService {
   // ApolloServerPluginUsageReporting) assumes that. In fact, errors talking to backends
   // are unlikely to show up as GraphQLErrors. Do we need to use
   // formatApolloErrors or something?
-  public executor = async <TContext>(
-    requestContext: GraphQLRequestContextExecutionDidStart<TContext>,
-  ): Promise<GraphQLExecutionResult> => {
+  public executor = async (
+    requestContext: GatewayGraphQLRequestContext,
+  ): Promise<GatewayExecutionResult> => {
     const spanAttributes = requestContext.operationName
       ? { operationName: requestContext.operationName }
       : {};
@@ -868,10 +839,7 @@ export class ApolloGateway implements GraphQLService {
             return { errors: validationErrors };
           }
 
-          let queryPlan: QueryPlan | undefined;
-          if (this.queryPlanStore) {
-            queryPlan = await this.queryPlanStore.get(queryPlanStoreKey);
-          }
+          let queryPlan = this.queryPlanStore.get(queryPlanStoreKey);
 
           if (!queryPlan) {
             queryPlan = tracer.startActiveSpan(
@@ -893,25 +861,11 @@ export class ApolloGateway implements GraphQLService {
               },
             );
 
-            if (this.queryPlanStore) {
-              // The underlying cache store behind the `documentStore` returns a
-              // `Promise` which is resolved (or rejected), eventually, based on the
-              // success or failure (respectively) of the cache save attempt.  While
-              // it's certainly possible to `await` this `Promise`, we don't care about
-              // whether or not it's successful at this point.  We'll instead proceed
-              // to serve the rest of the request and just hope that this works out.
-              // If it doesn't work, the next request will have another opportunity to
-              // try again.  Errors will surface as warnings, as appropriate.
-              //
-              // While it shouldn't normally be necessary to wrap this `Promise` in a
-              // `Promise.resolve` invocation, it seems that the underlying cache store
-              // is returning a non-native `Promise` (e.g. Bluebird, etc.).
-              Promise.resolve(
-                this.queryPlanStore.set(queryPlanStoreKey, queryPlan),
-              ).catch((err) =>
-                this.logger.warn(
-                  'Could not store queryPlan' + ((err && err.message) || err),
-                ),
+            try {
+              this.queryPlanStore.set(queryPlanStoreKey, queryPlan);
+            } catch (err) {
+              this.logger.warn(
+                'Could not store queryPlan' + ((err && err.message) || err),
               );
             }
           }
@@ -933,7 +887,7 @@ export class ApolloGateway implements GraphQLService {
             });
           }
 
-          const response = await executeQueryPlan<TContext>(
+          const response = await executeQueryPlan(
             queryPlan,
             serviceMap,
             requestContext,
@@ -990,8 +944,8 @@ export class ApolloGateway implements GraphQLService {
     );
   };
 
-  private validateIncomingRequest<TContext>(
-    requestContext: GraphQLRequestContextExecutionDidStart<TContext>,
+  private validateIncomingRequest(
+    requestContext: GatewayGraphQLRequestContext,
     operationContext: OperationContext,
   ) {
     return tracer.startActiveSpan(OpenTelemetrySpanNames.VALIDATE, (span) => {

package/src/supergraphManagers/IntrospectAndCompose/__tests__/IntrospectAndCompose.test.ts

@@ -119,11 +119,6 @@ describe('IntrospectAndCompose', () => {
 
   // TODO: useFakeTimers (though I'm struggling to get this to work as expected)
   it("doesn't call `update` when there's no change to the supergraph", async () => {
-    const fetcher =
-      jest.requireActual<typeof import('apollo-server-env')>(
-        'apollo-server-env',
-      ).fetch;
-
     // mock for initial load and a few polls against an unchanging schema
     mockAllServicesSdlQuerySuccess();
     mockAllServicesSdlQuerySuccess();
@@ -144,7 +139,6 @@ describe('IntrospectAndCompose', () => {
       getDataSource({ url }) {
         return new RemoteGraphQLDataSource({
           url,
-          fetcher,
         });
       },
     });

package/src/supergraphManagers/IntrospectAndCompose/loadServicesFromRemoteEndpoint.ts

@@ -1,10 +1,10 @@
-import { GraphQLRequest } from 'apollo-server-types';
 import { parse } from 'graphql';
 import { Headers, HeadersInit } from 'node-fetch';
 import { GraphQLDataSource, GraphQLDataSourceRequestKind } from '../../datasources/types';
 import { SERVICE_DEFINITION_QUERY } from '../..';
 import { ServiceDefinitionUpdate, ServiceEndpointDefinition } from '../../config';
 import { ServiceDefinition } from '@apollo/federation';
+import { GatewayGraphQLRequest } from '@apollo/server-gateway-interface';
 
 export type Service = ServiceEndpointDefinition & {
   dataSource: GraphQLDataSource;
@@ -35,7 +35,7 @@ export async function loadServicesFromRemoteEndpoint({
         `Tried to load schema for '${name}' but no 'url' was specified.`);
     }
 
-    const request: GraphQLRequest = {
+    const request: GatewayGraphQLRequest = {
       query: SERVICE_DEFINITION_QUERY,
       http: {
         url,

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

@@ -3,7 +3,7 @@ import {
   loadSupergraphSdlFromUplinks,
   UplinkFetcherError,
 } from '../loadSupergraphSdlFromStorage';
-import { getDefaultFetcher } from '../../..';
+import fetcher from 'make-fetch-happen';
 import {
   graphRef,
   apiKey,
@@ -14,10 +14,13 @@ import {
   mockOutOfBandReportRequestSuccess,
   mockSupergraphSdlRequestSuccess,
   mockSupergraphSdlRequestIfAfterUnchanged,
-  mockSupergraphSdlRequestIfAfter
+  mockSupergraphSdlRequestIfAfter,
 } from '../../../__tests__/integration/nockMocks';
-import { getTestingSupergraphSdl } from "../../../__tests__/execution-utils";
-import { nockAfterEach, nockBeforeEach } from '../../../__tests__/nockAssertions';
+import { getTestingSupergraphSdl } from '../../../__tests__/execution-utils';
+import {
+  nockAfterEach,
+  nockBeforeEach,
+} from '../../../__tests__/nockAssertions';
 
 describe('loadSupergraphSdlFromStorage', () => {
   beforeEach(nockBeforeEach);
@@ -25,7 +28,6 @@ describe('loadSupergraphSdlFromStorage', () => {
 
   it('fetches Supergraph SDL as expected', async () => {
     mockSupergraphSdlRequestSuccess();
-    const fetcher = getDefaultFetcher();
     const result = await loadSupergraphSdlFromStorage({
       graphRef,
       apiKey,
@@ -42,27 +44,29 @@ describe('loadSupergraphSdlFromStorage', () => {
 
   it('Queries alternate Uplink URL if first one fails', async () => {
     mockSupergraphSdlRequest('originalId-1234', mockCloudConfigUrl1).reply(500);
-    mockSupergraphSdlRequestIfAfter('originalId-1234', mockCloudConfigUrl2).reply(
+    mockSupergraphSdlRequestIfAfter(
+      'originalId-1234',
+      mockCloudConfigUrl2,
+    ).reply(
       200,
       JSON.stringify({
         data: {
           routerConfig: {
             __typename: 'RouterConfigResult',
             id: 'originalId-1234',
-            supergraphSdl: getTestingSupergraphSdl()
+            supergraphSdl: getTestingSupergraphSdl(),
           },
         },
       }),
     );
 
-    const fetcher = getDefaultFetcher();
     const result = await loadSupergraphSdlFromUplinks({
       graphRef,
       apiKey,
       endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
       errorReportingEndpoint: undefined,
       fetcher,
-      compositionId: "originalId-1234",
+      compositionId: 'originalId-1234',
       maxRetries: 1,
       roundRobinSeed: 0,
       earliestFetchTime: null,
@@ -75,10 +79,12 @@ describe('loadSupergraphSdlFromStorage', () => {
   });
 
   it('Throws error if all Uplink URLs fail', async () => {
-    mockSupergraphSdlRequest("originalId-1234", mockCloudConfigUrl1).reply(500);
-    mockSupergraphSdlRequestIfAfter("originalId-1234", mockCloudConfigUrl2).reply(500);
+    mockSupergraphSdlRequest('originalId-1234', mockCloudConfigUrl1).reply(500);
+    mockSupergraphSdlRequestIfAfter(
+      'originalId-1234',
+      mockCloudConfigUrl2,
+    ).reply(500);
 
-    const fetcher = getDefaultFetcher();
     await expect(
       loadSupergraphSdlFromUplinks({
         graphRef,
@@ -86,23 +92,22 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
         errorReportingEndpoint: undefined,
         fetcher,
-        compositionId: "originalId-1234",
+        compositionId: 'originalId-1234',
         maxRetries: 1,
         roundRobinSeed: 0,
         earliestFetchTime: null,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
-        "An error occurred while fetching your schema from Apollo: 500 Internal Server Error",
-      )
+        '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,
@@ -114,8 +119,8 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).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"
-        )
+          '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',
+        ),
       );
     });
 
@@ -128,7 +133,6 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       );
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -139,7 +143,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           compositionId: null,
         }),
       ).rejects.toThrowError(
-        new UplinkFetcherError(`An error occurred while fetching your schema from Apollo: \n${message}`)
+        new UplinkFetcherError(
+          `An error occurred while fetching your schema from Apollo: \n${message}`,
+        ),
       );
     });
 
@@ -147,7 +153,6 @@ describe('loadSupergraphSdlFromStorage', () => {
       mockSupergraphSdlRequest().reply(500);
       mockOutOfBandReportRequestSuccess();
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -159,8 +164,8 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
-          "An error occurred while fetching your schema from Apollo: 500 Internal Server Error"
-        )
+          'An error occurred while fetching your schema from Apollo: 500 Internal Server Error',
+        ),
       );
     });
 
@@ -169,7 +174,6 @@ describe('loadSupergraphSdlFromStorage', () => {
     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,
@@ -181,16 +185,14 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).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",
-        )
+          '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,
@@ -202,8 +204,8 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).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",
-        )
+          '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',
+        ),
       );
     });
 
@@ -211,7 +213,6 @@ describe('loadSupergraphSdlFromStorage', () => {
       mockSupergraphSdlRequest().reply(413);
       mockOutOfBandReportRequestSuccess();
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -223,8 +224,8 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
-          "An error occurred while fetching your schema from Apollo: 413 Payload Too Large",
-        )
+          'An error occurred while fetching your schema from Apollo: 413 Payload Too Large',
+        ),
       );
     });
 
@@ -232,7 +233,6 @@ describe('loadSupergraphSdlFromStorage', () => {
       mockSupergraphSdlRequest().reply(422);
       mockOutOfBandReportRequestSuccess();
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -244,8 +244,8 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
-          "An error occurred while fetching your schema from Apollo: 422 Unprocessable Entity",
-        )
+          'An error occurred while fetching your schema from Apollo: 422 Unprocessable Entity',
+        ),
       );
     });
 
@@ -253,7 +253,6 @@ describe('loadSupergraphSdlFromStorage', () => {
       mockSupergraphSdlRequest().reply(408);
       mockOutOfBandReportRequestSuccess();
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -265,18 +264,16 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
-          "An error occurred while fetching your schema from Apollo: 408 Request Timeout",
-        )
+          '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,
@@ -288,8 +285,8 @@ describe('loadSupergraphSdlFromStorage', () => {
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
-        "An error occurred while fetching your schema from Apollo: 504 Gateway Timeout",
-      )
+        'An error occurred while fetching your schema from Apollo: 504 Gateway Timeout',
+      ),
     );
   });
 
@@ -297,7 +294,6 @@ describe('loadSupergraphSdlFromStorage', () => {
     mockSupergraphSdlRequest().replyWithError('no response');
     mockOutOfBandReportRequestSuccess();
 
-    const fetcher = getDefaultFetcher();
     await expect(
       loadSupergraphSdlFromStorage({
         graphRef,
@@ -309,8 +305,8 @@ describe('loadSupergraphSdlFromStorage', () => {
       }),
     ).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",
-      )
+        'An error occurred while fetching your schema from Apollo: request to https://example1.cloud-config-url.com/cloudconfig/ failed, reason: no response',
+      ),
     );
   });
 
@@ -318,7 +314,6 @@ describe('loadSupergraphSdlFromStorage', () => {
     mockSupergraphSdlRequest().reply(502);
     mockOutOfBandReportRequestSuccess();
 
-    const fetcher = getDefaultFetcher();
     await expect(
       loadSupergraphSdlFromStorage({
         graphRef,
@@ -330,8 +325,8 @@ describe('loadSupergraphSdlFromStorage', () => {
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
-        "An error occurred while fetching your schema from Apollo: 502 Bad Gateway",
-      )
+        'An error occurred while fetching your schema from Apollo: 502 Bad Gateway',
+      ),
     );
   });
 
@@ -339,7 +334,6 @@ describe('loadSupergraphSdlFromStorage', () => {
     mockSupergraphSdlRequest().reply(503);
     mockOutOfBandReportRequestSuccess();
 
-    const fetcher = getDefaultFetcher();
     await expect(
       loadSupergraphSdlFromStorage({
         graphRef,
@@ -351,69 +345,72 @@ describe('loadSupergraphSdlFromStorage', () => {
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
-        "An error occurred while fetching your schema from Apollo: 503 Service Unavailable",
-      )
+        '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");
+    mockSupergraphSdlRequestIfAfterUnchanged('id-1234');
 
-    const fetcher = getDefaultFetcher();
     const result = await loadSupergraphSdlFromStorage({
-        graphRef,
-        apiKey,
-        endpoint: mockCloudConfigUrl1,
-        errorReportingEndpoint: mockOutOfBandReporterUrl,
-        fetcher,
-        compositionId: "id-1234",
+      graphRef,
+      apiKey,
+      endpoint: mockCloudConfigUrl1,
+      errorReportingEndpoint: mockOutOfBandReporterUrl,
+      fetcher,
+      compositionId: 'id-1234',
     });
     expect(result).toBeNull();
   });
 });
 
-
-describe("loadSupergraphSdlFromUplinks", () => {
+describe('loadSupergraphSdlFromUplinks', () => {
   beforeEach(nockBeforeEach);
   afterEach(nockAfterEach);
 
   it("doesn't retry in the unchanged / null case", async () => {
-    mockSupergraphSdlRequestIfAfterUnchanged("id-1234", mockCloudConfigUrl1);
+    mockSupergraphSdlRequestIfAfterUnchanged('id-1234', mockCloudConfigUrl1);
 
-    const fetcher = jest.fn(getDefaultFetcher());
+    let calls = 0;
     const result = await loadSupergraphSdlFromUplinks({
       graphRef,
       apiKey,
       endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
       errorReportingEndpoint: mockOutOfBandReporterUrl,
-      fetcher: fetcher as any,
-      compositionId: "id-1234",
+      fetcher: (...args) => {
+        calls++;
+        return fetcher(...args);
+      },
+      compositionId: 'id-1234',
       maxRetries: 5,
       roundRobinSeed: 0,
       earliestFetchTime: null,
     });
 
     expect(result).toBeNull();
-    expect(fetcher).toHaveBeenCalledTimes(1);
+    expect(calls).toBe(1);
   });
 
-  it("Waits the correct time before retrying", async () => {
+  it('Waits the correct time before retrying', async () => {
     const timeoutSpy = jest.spyOn(global, 'setTimeout');
 
     mockSupergraphSdlRequest('originalId-1234', mockCloudConfigUrl1).reply(500);
-    mockSupergraphSdlRequestIfAfter('originalId-1234', mockCloudConfigUrl2).reply(
+    mockSupergraphSdlRequestIfAfter(
+      'originalId-1234',
+      mockCloudConfigUrl2,
+    ).reply(
       200,
       JSON.stringify({
         data: {
           routerConfig: {
             __typename: 'RouterConfigResult',
             id: 'originalId-1234',
-            supergraphSdl: getTestingSupergraphSdl()
+            supergraphSdl: getTestingSupergraphSdl(),
           },
         },
       }),
     );
-    const fetcher = getDefaultFetcher();
 
     await loadSupergraphSdlFromUplinks({
       graphRef,
@@ -421,7 +418,7 @@ describe("loadSupergraphSdlFromUplinks", () => {
       endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
       errorReportingEndpoint: undefined,
       fetcher: fetcher,
-      compositionId: "originalId-1234",
+      compositionId: 'originalId-1234',
       maxRetries: 1,
       roundRobinSeed: 0,
       earliestFetchTime: new Date(Date.now() + 1000),
@@ -435,4 +432,3 @@ describe("loadSupergraphSdlFromUplinks", () => {
     timeoutSpy.mockRestore();
   });
 });
-