@apollo/gateway 2.0.6-rc.0 → 2.1.0-alpha.1

package/src/supergraphManagers/{UplinkFetcher → UplinkSupergraphManager}/__tests__/loadSupergraphSdlFromStorage.test.ts

@@ -22,6 +22,15 @@ import {
   nockBeforeEach,
 } from '../../../__tests__/nockAssertions';
 
+const logger = {
+  warn: jest.fn(),
+  debug: jest.fn(),
+  error: jest.fn(),
+  info: jest.fn(),
+};
+
+const requestTimeoutMs = 100;
+
 describe('loadSupergraphSdlFromStorage', () => {
   beforeEach(nockBeforeEach);
   afterEach(nockAfterEach);
@@ -34,7 +43,9 @@ describe('loadSupergraphSdlFromStorage', () => {
       endpoint: mockCloudConfigUrl1,
       errorReportingEndpoint: undefined,
       fetcher,
+      requestTimeoutMs,
       compositionId: null,
+      logger,
     });
     expect(result).toMatchObject({
       id: 'originalId-1234',
@@ -66,10 +77,11 @@ describe('loadSupergraphSdlFromStorage', () => {
       endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
       errorReportingEndpoint: undefined,
       fetcher,
+      requestTimeoutMs,
       compositionId: 'originalId-1234',
       maxRetries: 1,
       roundRobinSeed: 0,
-      earliestFetchTime: null,
+      logger,
     });
 
     expect(result).toMatchObject({
@@ -92,10 +104,11 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
         errorReportingEndpoint: undefined,
         fetcher,
+        requestTimeoutMs,
         compositionId: 'originalId-1234',
         maxRetries: 1,
         roundRobinSeed: 0,
-        earliestFetchTime: null,
+        logger,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
@@ -115,7 +128,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -140,7 +155,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -160,7 +177,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -181,7 +200,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -200,7 +221,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -220,7 +243,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -240,7 +265,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -260,7 +287,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -281,7 +310,9 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoint: mockCloudConfigUrl1,
         errorReportingEndpoint: mockOutOfBandReporterUrl,
         fetcher,
+        requestTimeoutMs,
         compositionId: null,
+        logger,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
@@ -301,7 +332,9 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoint: mockCloudConfigUrl1,
         errorReportingEndpoint: mockOutOfBandReporterUrl,
         fetcher,
+        requestTimeoutMs,
         compositionId: null,
+        logger,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
@@ -321,7 +354,9 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoint: mockCloudConfigUrl1,
         errorReportingEndpoint: mockOutOfBandReporterUrl,
         fetcher,
+        requestTimeoutMs,
         compositionId: null,
+        logger,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
@@ -341,7 +376,9 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoint: mockCloudConfigUrl1,
         errorReportingEndpoint: mockOutOfBandReporterUrl,
         fetcher,
+        requestTimeoutMs,
         compositionId: null,
+        logger,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
@@ -359,7 +396,9 @@ describe('loadSupergraphSdlFromStorage', () => {
       endpoint: mockCloudConfigUrl1,
       errorReportingEndpoint: mockOutOfBandReporterUrl,
       fetcher,
+      requestTimeoutMs,
       compositionId: 'id-1234',
+      logger,
     });
     expect(result).toBeNull();
   });
@@ -382,20 +421,20 @@ describe('loadSupergraphSdlFromUplinks', () => {
         calls++;
         return fetcher(...args);
       },
+      requestTimeoutMs,
       compositionId: 'id-1234',
       maxRetries: 5,
       roundRobinSeed: 0,
-      earliestFetchTime: null,
+      logger,
     });
 
     expect(result).toBeNull();
     expect(calls).toBe(1);
   });
 
-  it('Waits the correct time before retrying', async () => {
-    const timeoutSpy = jest.spyOn(global, 'setTimeout');
-
+  it('Retries on error', async () => {
     mockSupergraphSdlRequest('originalId-1234', mockCloudConfigUrl1).reply(500);
+    const supergraphSdl = getTestingSupergraphSdl();
     mockSupergraphSdlRequestIfAfter(
       'originalId-1234',
       mockCloudConfigUrl2,
@@ -406,29 +445,25 @@ describe('loadSupergraphSdlFromUplinks', () => {
           routerConfig: {
             __typename: 'RouterConfigResult',
             id: 'originalId-1234',
-            supergraphSdl: getTestingSupergraphSdl(),
+            supergraphSdl,
           },
         },
       }),
     );
 
-    await loadSupergraphSdlFromUplinks({
+    const result = await loadSupergraphSdlFromUplinks({
       graphRef,
       apiKey,
       endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
       errorReportingEndpoint: undefined,
-      fetcher: fetcher,
+      fetcher,
+      requestTimeoutMs,
       compositionId: 'originalId-1234',
       maxRetries: 1,
       roundRobinSeed: 0,
-      earliestFetchTime: new Date(Date.now() + 1000),
+      logger,
     });
 
-    // test if setTimeout was called with a value in range to deal with time jitter
-    const setTimeoutCall = timeoutSpy.mock.calls[1][1];
-    expect(setTimeoutCall).toBeLessThanOrEqual(1000);
-    expect(setTimeoutCall).toBeGreaterThanOrEqual(900);
-
-    timeoutSpy.mockRestore();
+    expect(result?.supergraphSdl).toEqual(supergraphSdl);
   });
 });

package/src/supergraphManagers/UplinkSupergraphManager/index.ts

@@ -0,0 +1,312 @@
+import * as makeFetchHappen from 'make-fetch-happen';
+import type { Logger } from '@apollo/utils.logger';
+import resolvable, { Resolvable } from '@josephg/resolvable';
+import { SupergraphManager, SupergraphSdlHookOptions } from '../../config';
+import {
+  SubgraphHealthCheckFunction,
+  SupergraphSdlUpdateFunction,
+} from '../..';
+import { getDefaultLogger } from '../../logger';
+import { loadSupergraphSdlFromUplinks } from './loadSupergraphSdlFromStorage';
+import type { AbortableFetcher } from './types';
+
+export type FailureToFetchSupergraphSdlFunctionParams = {
+  error: Error;
+  graphRef: string;
+  logger: Logger;
+  fetchCount: number;
+};
+
+export type FailureToFetchSupergraphSdlDuringInit = ({
+  error,
+  graphRef,
+  logger,
+  fetchCount,
+}: FailureToFetchSupergraphSdlFunctionParams) => Promise<string>;
+
+export type FailureToFetchSupergraphSdlAfterInit = ({
+  error,
+  graphRef,
+  logger,
+  fetchCount,
+  mostRecentSuccessfulFetchAt,
+}:
+  | FailureToFetchSupergraphSdlFunctionParams & {
+      mostRecentSuccessfulFetchAt?: Date;
+    }) => Promise<string | null>;
+
+type State =
+  | { phase: 'constructed' }
+  | { phase: 'initialized' }
+  | {
+      phase: 'polling';
+      pollingPromise?: Promise<void>;
+      nextFetchPromise?: Resolvable<void>;
+    }
+  | { phase: 'stopped' };
+
+export class UplinkSupergraphManager implements SupergraphManager {
+  public static readonly DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+  public static readonly MIN_POLL_INTERVAL_MS = 10_000;
+
+  public static readonly DEFAULT_UPLINK_ENDPOINTS = [
+    'https://uplink.api.apollographql.com/',
+    'https://aws.uplink.api.apollographql.com/',
+  ];
+
+  public readonly uplinkEndpoints: string[] =
+    UplinkSupergraphManager.getUplinkEndpoints();
+  private apiKey: string;
+  private graphRef: string;
+  private fetcher: AbortableFetcher = makeFetchHappen.defaults();
+  private maxRetries: number;
+  private requestTimeoutMs: number =
+    UplinkSupergraphManager.DEFAULT_REQUEST_TIMEOUT_MS;
+  private initialMaxRetries: number;
+  private pollIntervalMs: number = UplinkSupergraphManager.MIN_POLL_INTERVAL_MS;
+  private logger: Logger;
+  private update?: SupergraphSdlUpdateFunction;
+  private shouldRunSubgraphHealthcheck: boolean = false;
+  private healthCheck?: SubgraphHealthCheckFunction;
+  private onFailureToFetchSupergraphSdlDuringInit?: FailureToFetchSupergraphSdlDuringInit;
+  private onFailureToFetchSupergraphSdlAfterInit?: FailureToFetchSupergraphSdlAfterInit;
+  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;
+  private mostRecentSuccessfulFetchAt?: Date;
+
+  constructor({
+    apiKey,
+    graphRef,
+    debug,
+    logger,
+    uplinkEndpoints,
+    fallbackPollIntervalInMs,
+    maxRetries,
+    initialMaxRetries,
+    shouldRunSubgraphHealthcheck,
+    onFailureToFetchSupergraphSdlDuringInit,
+    onFailureToFetchSupergraphSdlAfterInit,
+  }: {
+    apiKey: string;
+    graphRef: string;
+    debug?: boolean;
+    logger?: Logger;
+    uplinkEndpoints?: string[];
+    fallbackPollIntervalInMs?: number;
+    maxRetries?: number;
+    initialMaxRetries?: number;
+    shouldRunSubgraphHealthcheck?: boolean;
+    onFailureToFetchSupergraphSdlDuringInit?: FailureToFetchSupergraphSdlDuringInit;
+    onFailureToFetchSupergraphSdlAfterInit?: FailureToFetchSupergraphSdlAfterInit;
+  }) {
+    this.apiKey = apiKey;
+    this.graphRef = graphRef;
+    this.logger = logger ?? getDefaultLogger(debug);
+
+    this.uplinkEndpoints = uplinkEndpoints ?? this.uplinkEndpoints;
+    // If the user didn't pass a `maxRetries`, default to trying each endpoint
+    // 3 times (minus 1 for the initial request) since we round-robin through
+    // each URL on failure
+    this.maxRetries = maxRetries ?? this.uplinkEndpoints.length * 3 - 1;
+    this.initialMaxRetries = initialMaxRetries ?? this.maxRetries;
+
+    this.pollIntervalMs = fallbackPollIntervalInMs ?? this.pollIntervalMs;
+    if (this.pollIntervalMs < UplinkSupergraphManager.MIN_POLL_INTERVAL_MS) {
+      this.logger.warn(
+        'Polling Apollo services at a frequency of less than once per 10 seconds (10000) is disallowed. Instead, the minimum allowed pollInterval of 10000 will be used. Please reconfigure your `fallbackPollIntervalInMs` accordingly. If this is problematic for your team, please contact support.',
+      );
+      this.pollIntervalMs = UplinkSupergraphManager.MIN_POLL_INTERVAL_MS;
+    }
+
+    this.shouldRunSubgraphHealthcheck =
+      shouldRunSubgraphHealthcheck ?? this.shouldRunSubgraphHealthcheck;
+    this.onFailureToFetchSupergraphSdlDuringInit =
+      onFailureToFetchSupergraphSdlDuringInit;
+    this.onFailureToFetchSupergraphSdlAfterInit =
+      onFailureToFetchSupergraphSdlAfterInit;
+
+    this.state = { phase: 'constructed' };
+  }
+
+  public async initialize({ update, healthCheck }: SupergraphSdlHookOptions) {
+    this.update = update;
+
+    if (this.shouldRunSubgraphHealthcheck) {
+      this.healthCheck = healthCheck;
+    }
+
+    let initialSupergraphSdl: string | null = null;
+    try {
+      initialSupergraphSdl = await this.updateSupergraphSdl(
+        this.initialMaxRetries,
+      );
+      if (!initialSupergraphSdl) {
+        throw new Error(
+          'Invalid supergraph schema supplied during initialization.',
+        );
+      }
+    } catch (e) {
+      this.logUpdateFailure(e);
+      throw e;
+    }
+
+    this.state = { phase: 'initialized' };
+
+    // Start polling after we resolve the first supergraph
+    this.beginPolling();
+
+    return {
+      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;
+        }
+      },
+    };
+  }
+
+  public async nextFetch(): Promise<void | null> {
+    if (this.state.phase !== 'polling') {
+      return;
+    }
+    return this.state.nextFetchPromise;
+  }
+
+  /**
+   * Configuration priority order:
+   * 1. APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT environment variable
+   * 2. default (GCP and AWS)
+   */
+  public static getUplinkEndpoints(): string[] {
+    const envEndpoints =
+      process.env.APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT?.split(',');
+    return envEndpoints ?? UplinkSupergraphManager.DEFAULT_UPLINK_ENDPOINTS;
+  }
+
+  private async updateSupergraphSdl(
+    maxRetries: number,
+  ): Promise<string | null> {
+    let supergraphSdl;
+
+    try {
+      const result = await loadSupergraphSdlFromUplinks({
+        graphRef: this.graphRef,
+        apiKey: this.apiKey,
+        endpoints: this.uplinkEndpoints,
+        errorReportingEndpoint: this.errorReportingEndpoint,
+        fetcher: this.fetcher,
+        compositionId: this.compositionId ?? null,
+        maxRetries,
+        requestTimeoutMs: this.requestTimeoutMs,
+        roundRobinSeed: this.fetchCount++,
+        logger: this.logger,
+      });
+      this.mostRecentSuccessfulFetchAt = new Date();
+
+      this.logger.debug(
+        `Received Uplink response. Has updated SDL? ${!!result?.supergraphSdl}`,
+      );
+
+      if (!result) {
+        return null;
+      }
+
+      this.compositionId = result.id;
+
+      supergraphSdl = result.supergraphSdl;
+      if (result?.minDelaySeconds) {
+        this.pollIntervalMs = result.minDelaySeconds * 1000;
+      }
+    } catch (e) {
+      this.logger.debug(
+        `Error fetching supergraphSdl from Uplink during phase '${this.state.phase}'`,
+      );
+
+      if (
+        this.state.phase === 'constructed' &&
+        this.onFailureToFetchSupergraphSdlDuringInit
+      ) {
+        supergraphSdl = await this.onFailureToFetchSupergraphSdlDuringInit({
+          error: e,
+          graphRef: this.graphRef,
+          logger: this.logger,
+          fetchCount: this.fetchCount,
+        });
+      } else if (
+        this.state.phase === 'polling' &&
+        this.onFailureToFetchSupergraphSdlAfterInit
+      ) {
+        supergraphSdl = await this.onFailureToFetchSupergraphSdlAfterInit({
+          error: e,
+          graphRef: this.graphRef,
+          logger: this.logger,
+          fetchCount: this.fetchCount,
+          mostRecentSuccessfulFetchAt: this.mostRecentSuccessfulFetchAt,
+        });
+
+        // This is really an error, but we'll let the caller decide what to do with it
+        if (!supergraphSdl) {
+          return null;
+        }
+      } else {
+        throw e;
+      }
+    }
+
+    // the healthCheck fn is only assigned if it's enabled in the config
+    await this.healthCheck?.(supergraphSdl);
+    return supergraphSdl;
+  }
+
+  private beginPolling() {
+    this.state = { phase: 'polling' };
+    this.poll();
+  }
+
+  private poll() {
+    if (this.state.phase !== 'polling') {
+      this.logger.debug(`Stopped polling Uplink [phase: ${this.state.phase}]`);
+      return;
+    }
+
+    this.state.nextFetchPromise = resolvable();
+
+    this.logger.debug(
+      `Will poll Uplink after ${this.pollIntervalMs}ms [phase: ${this.state.phase}]`,
+    );
+    this.timerRef = setTimeout(async () => {
+      if (this.state.phase === 'polling') {
+        const pollingPromise = resolvable();
+        this.state.pollingPromise = pollingPromise;
+        try {
+          const supergraphSdl = await this.updateSupergraphSdl(this.maxRetries);
+          if (supergraphSdl) {
+            this.update?.(supergraphSdl);
+          }
+        } catch (e) {
+          this.logUpdateFailure(e);
+        }
+        pollingPromise.resolve();
+        this.state.nextFetchPromise?.resolve();
+      }
+
+      this.poll();
+    }, this.pollIntervalMs);
+  }
+
+  private logUpdateFailure(e: any) {
+    this.logger.error(
+      'UplinkSupergraphManager failed to update supergraph with the following error: ' +
+        (e.message ?? e),
+    );
+  }
+}

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

@@ -1,13 +1,15 @@
 import { GraphQLError } from 'graphql';
 import retry from 'async-retry';
+import { AbortController } from "node-abort-controller";
 import { SupergraphSdlUpdate } from '../../config';
 import { submitOutOfBandReportIfConfigured } from './outOfBandReporter';
 import { SupergraphSdlQuery } from '../../__generated__/graphqlTypes';
+import type { FetcherResponse } from '@apollo/utils.fetcher';
+import type { Logger } from '@apollo/utils.logger';
 import type {
-  Fetcher,
-  FetcherResponse,
-  FetcherRequestInit,
-} from '@apollo/utils.fetcher';
+  AbortableFetcher as Fetcher,
+  AbortableFetcherRequestInit as FetcherRequestInit,
+} from './types';
 
 // Magic /* GraphQL */ comment below is for codegen, do not remove
 export const SUPERGRAPH_SDL_QUERY = /* GraphQL */`#graphql
@@ -60,8 +62,9 @@ export async function loadSupergraphSdlFromUplinks({
   fetcher,
   compositionId,
   maxRetries,
+  requestTimeoutMs,
   roundRobinSeed,
-  earliestFetchTime,
+  logger,
 }: {
   graphRef: string;
   apiKey: string;
@@ -70,8 +73,9 @@ export async function loadSupergraphSdlFromUplinks({
   fetcher: Fetcher;
   compositionId: string | null;
   maxRetries: number,
+  requestTimeoutMs: number,
   roundRobinSeed: number,
-  earliestFetchTime: Date | null
+  logger: Logger,
 }) : 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,
@@ -84,17 +88,18 @@ export async function loadSupergraphSdlFromUplinks({
         endpoint: endpoints[roundRobinSeed++ % endpoints.length],
         errorReportingEndpoint,
         fetcher,
+        requestTimeoutMs,
         compositionId,
+        logger,
       }),
     {
       retries: maxRetries,
-      onRetry: async () => {
-        const delayMS = earliestFetchTime ? earliestFetchTime.getTime() - Date.now(): 0;
-        if (delayMS > 0) await new Promise(resolve => setTimeout(resolve, delayMS));
-      }
+      maxTimeout: 60_000,
+      onRetry(e, attempt) {
+        logger.debug(`Unable to fetch supergraph SDL (attempt ${attempt}), waiting before retry: ${e}`);
+      },
     },
   );
-
 }
 
 export async function loadSupergraphSdlFromStorage({
@@ -103,14 +108,18 @@ export async function loadSupergraphSdlFromStorage({
   endpoint,
   errorReportingEndpoint,
   fetcher,
+  requestTimeoutMs,
   compositionId,
+  logger,
 }: {
   graphRef: string;
   apiKey: string;
   endpoint: string;
   errorReportingEndpoint?: string;
   fetcher: Fetcher;
+  requestTimeoutMs: number;
   compositionId: string | null;
+  logger: Logger;
 }) : Promise<SupergraphSdlUpdate | null> {
   const requestBody = JSON.stringify({
     query: SUPERGRAPH_SDL_QUERY,
@@ -121,6 +130,12 @@ export async function loadSupergraphSdlFromStorage({
     },
   })
 
+  const controller = new AbortController();
+  const signal = setTimeout(() => {
+    logger.debug(`Aborting request due to timeout`);
+    controller.abort();
+  }, requestTimeoutMs);
+
   const requestDetails: FetcherRequestInit = {
     method: 'POST',
     body: requestBody,
@@ -130,8 +145,11 @@ export async function loadSupergraphSdlFromStorage({
       'user-agent': `${name}/${version}`,
       'content-type': 'application/json',
     },
+    signal: controller.signal,
   };
 
+  logger.debug(`🔧 Fetching ${graphRef} supergraph schema from ${endpoint} ifAfterId ${compositionId}`);
+
   const startTime = new Date();
   let result: FetcherResponse;
   try {
@@ -150,6 +168,8 @@ export async function loadSupergraphSdlFromStorage({
     });
 
     throw new UplinkFetcherError(fetchErrorMsg + (e.message ?? e));
+  } finally {
+    clearTimeout(signal);
   }
 
   const endTime = new Date();
@@ -192,7 +212,7 @@ export async function loadSupergraphSdlFromStorage({
       minDelaySeconds,
       // messages,
     } = routerConfig;
-    return { id, supergraphSdl: supergraphSdl!, minDelaySeconds };
+    return { id, supergraphSdl, minDelaySeconds };
   } else if (routerConfig.__typename === 'FetchError') {
     // FetchError case
     const { code, message } = routerConfig;

package/src/supergraphManagers/{UplinkFetcher → UplinkSupergraphManager}/outOfBandReporter.ts

@@ -1,10 +1,11 @@
-import { Fetcher, FetcherResponse } from '@apollo/utils.fetcher';
+import { FetcherResponse } from '@apollo/utils.fetcher';
 import { GraphQLError } from 'graphql';
 import {
   ErrorCode,
   OobReportMutation,
   OobReportMutationVariables,
 } from '../../__generated__/graphqlTypes';
+import { type AbortableFetcher as Fetcher } from './types';
 
 // Magic /* GraphQL */ comment below is for codegen, do not remove
 export const OUT_OF_BAND_REPORTER_QUERY = /* GraphQL */`#graphql

package/src/supergraphManagers/UplinkSupergraphManager/types.ts

@@ -0,0 +1,10 @@
+import type { AbortSignal } from 'node-abort-controller';
+import type { Fetcher, FetcherRequestInit } from '@apollo/utils.fetcher';
+
+export interface AbortableFetcherRequestInit extends FetcherRequestInit {
+  signal?: AbortSignal | null | undefined;
+};
+
+export interface AbortableFetcher extends Fetcher {
+  init?: AbortableFetcherRequestInit;
+};