@apollo/gateway 2.1.0-alpha.0 → 2.1.0-alpha.3

package/src/supergraphManagers/UplinkSupergraphManager/index.ts

@@ -8,23 +8,7 @@ import {
 } from '../..';
 import { getDefaultLogger } from '../../logger';
 import { loadSupergraphSdlFromUplinks } from './loadSupergraphSdlFromStorage';
-import { Fetcher } from '@apollo/utils.fetcher';
-
-export const DEFAULT_UPLINK_ENDPOINTS = [
-  'https://uplink.api.apollographql.com/',
-  'https://aws.uplink.api.apollographql.com/',
-];
-
-function getUplinkEndpoints(): string[] {
-  /**
-   * Configuration priority order:
-   * 1. APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT environment variable
-   * 2. default (GCP and AWS)
-   */
-  const envEndpoints =
-    process.env.APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT?.split(',');
-  return envEndpoints ?? DEFAULT_UPLINK_ENDPOINTS;
-}
+import type { AbortableFetcher } from './types';
 
 export type FailureToFetchSupergraphSdlFunctionParams = {
   error: Error;
@@ -47,8 +31,9 @@ export type FailureToFetchSupergraphSdlAfterInit = ({
   fetchCount,
   mostRecentSuccessfulFetchAt,
 }:
-  | FailureToFetchSupergraphSdlFunctionParams
-  & { mostRecentSuccessfulFetchAt?: Date }) => Promise<string | null>;
+  | FailureToFetchSupergraphSdlFunctionParams & {
+      mostRecentSuccessfulFetchAt?: Date;
+    }) => Promise<string | null>;
 
 type State =
   | { phase: 'constructed' }
@@ -61,13 +46,24 @@ type State =
   | { phase: 'stopped' };
 
 export class UplinkSupergraphManager implements SupergraphManager {
-  public readonly uplinkEndpoints: string[] = getUplinkEndpoints();
+  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: Fetcher = makeFetchHappen.defaults();
+  private fetcher: AbortableFetcher = makeFetchHappen.defaults();
   private maxRetries: number;
+  private requestTimeoutMs: number =
+    UplinkSupergraphManager.DEFAULT_REQUEST_TIMEOUT_MS;
   private initialMaxRetries: number;
-  private fallbackPollIntervalMs: number = 10_000;
+  private pollIntervalMs: number = UplinkSupergraphManager.MIN_POLL_INTERVAL_MS;
   private logger: Logger;
   private update?: SupergraphSdlUpdateFunction;
   private shouldRunSubgraphHealthcheck: boolean = false;
@@ -80,8 +76,6 @@ export class UplinkSupergraphManager implements SupergraphManager {
     process.env.APOLLO_OUT_OF_BAND_REPORTER_ENDPOINT ?? undefined;
   private compositionId?: string;
   private fetchCount: number = 0;
-  private minDelayMs: number | null = null;
-  private earliestFetchTime: Date | null = null;
   private mostRecentSuccessfulFetchAt?: Date;
 
   constructor({
@@ -89,11 +83,11 @@ export class UplinkSupergraphManager implements SupergraphManager {
     graphRef,
     debug,
     logger,
-    fetcher,
     uplinkEndpoints,
     fallbackPollIntervalInMs,
     maxRetries,
     initialMaxRetries,
+    fetcher,
     shouldRunSubgraphHealthcheck,
     onFailureToFetchSupergraphSdlDuringInit,
     onFailureToFetchSupergraphSdlAfterInit,
@@ -102,11 +96,11 @@ export class UplinkSupergraphManager implements SupergraphManager {
     graphRef: string;
     debug?: boolean;
     logger?: Logger;
-    fetcher?: Fetcher;
     uplinkEndpoints?: string[];
     fallbackPollIntervalInMs?: number;
     maxRetries?: number;
     initialMaxRetries?: number;
+    fetcher?: AbortableFetcher;
     shouldRunSubgraphHealthcheck?: boolean;
     onFailureToFetchSupergraphSdlDuringInit?: FailureToFetchSupergraphSdlDuringInit;
     onFailureToFetchSupergraphSdlAfterInit?: FailureToFetchSupergraphSdlAfterInit;
@@ -122,9 +116,16 @@ export class UplinkSupergraphManager implements SupergraphManager {
     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.fetcher = fetcher ?? this.fetcher;
-    this.fallbackPollIntervalMs =
-      fallbackPollIntervalInMs ?? this.fallbackPollIntervalMs;
+
     this.shouldRunSubgraphHealthcheck =
       shouldRunSubgraphHealthcheck ?? this.shouldRunSubgraphHealthcheck;
     this.onFailureToFetchSupergraphSdlDuringInit =
@@ -142,19 +143,16 @@ export class UplinkSupergraphManager implements SupergraphManager {
       this.healthCheck = healthCheck;
     }
 
-    let initialSupergraphSdl: string | undefined = undefined;
+    let initialSupergraphSdl: string | null = null;
     try {
-      const result = await this.updateSupergraphSdl(this.initialMaxRetries);
-      if (!result) {
+      initialSupergraphSdl = await this.updateSupergraphSdl(
+        this.initialMaxRetries,
+      );
+      if (!initialSupergraphSdl) {
         throw new Error(
           'Invalid supergraph schema supplied during initialization.',
         );
       }
-      initialSupergraphSdl = result.supergraphSdl;
-      if (result.minDelaySeconds) {
-        this.minDelayMs = 1000 * result.minDelaySeconds;
-        this.earliestFetchTime = new Date(Date.now() + this.minDelayMs);
-      }
     } catch (e) {
       this.logUpdateFailure(e);
       throw e;
@@ -187,12 +185,21 @@ export class UplinkSupergraphManager implements SupergraphManager {
     return this.state.nextFetchPromise;
   }
 
-  private async updateSupergraphSdl(maxRetries: number): Promise<{
-    supergraphSdl: string;
-    minDelaySeconds: number;
-  } | null> {
+  /**
+   * 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;
-    let minDelaySeconds = this.fallbackPollIntervalMs / 1000;
 
     try {
       const result = await loadSupergraphSdlFromUplinks({
@@ -203,10 +210,15 @@ export class UplinkSupergraphManager implements SupergraphManager {
         fetcher: this.fetcher,
         compositionId: this.compositionId ?? null,
         maxRetries,
+        requestTimeoutMs: this.requestTimeoutMs,
         roundRobinSeed: this.fetchCount++,
-        earliestFetchTime: this.earliestFetchTime,
         logger: this.logger,
       });
+      this.mostRecentSuccessfulFetchAt = new Date();
+
+      this.logger.debug(
+        `Received Uplink response. Has updated SDL? ${!!result?.supergraphSdl}`,
+      );
 
       if (!result) {
         return null;
@@ -214,8 +226,10 @@ export class UplinkSupergraphManager implements SupergraphManager {
 
       this.compositionId = result.id;
 
-      ({ supergraphSdl, minDelaySeconds } = result);
-      this.mostRecentSuccessfulFetchAt = new Date();
+      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}'`,
@@ -254,7 +268,7 @@ export class UplinkSupergraphManager implements SupergraphManager {
 
     // the healthCheck fn is only assigned if it's enabled in the config
     await this.healthCheck?.(supergraphSdl);
-    return { supergraphSdl, minDelaySeconds };
+    return supergraphSdl;
   }
 
   private beginPolling() {
@@ -263,28 +277,24 @@ export class UplinkSupergraphManager implements SupergraphManager {
   }
 
   private poll() {
-    const delay = this.minDelayMs
-      ? Math.max(this.minDelayMs, this.fallbackPollIntervalMs)
-      : this.fallbackPollIntervalMs;
-
     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 result = await this.updateSupergraphSdl(this.maxRetries);
-          if (result?.minDelaySeconds) {
-            this.minDelayMs = 1000 * result.minDelaySeconds;
-            this.earliestFetchTime = new Date(Date.now() + this.minDelayMs);
-          }
-          if (result?.supergraphSdl) {
-            this.update?.(result.supergraphSdl);
+          const supergraphSdl = await this.updateSupergraphSdl(this.maxRetries);
+          if (supergraphSdl) {
+            this.update?.(supergraphSdl);
           }
         } catch (e) {
           this.logUpdateFailure(e);
@@ -294,7 +304,7 @@ export class UplinkSupergraphManager implements SupergraphManager {
       }
 
       this.poll();
-    }, delay);
+    }, this.pollIntervalMs);
   }
 
   private logUpdateFailure(e: any) {

package/src/supergraphManagers/UplinkSupergraphManager/loadSupergraphSdlFromStorage.ts

@@ -1,14 +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 {
-  Fetcher,
-  FetcherResponse,
-  FetcherRequestInit,
-} from '@apollo/utils.fetcher';
+import type { FetcherResponse } from '@apollo/utils.fetcher';
 import type { Logger } from '@apollo/utils.logger';
+import type {
+  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
@@ -61,8 +62,8 @@ export async function loadSupergraphSdlFromUplinks({
   fetcher,
   compositionId,
   maxRetries,
+  requestTimeoutMs,
   roundRobinSeed,
-  earliestFetchTime,
   logger,
 }: {
   graphRef: string;
@@ -72,10 +73,10 @@ export async function loadSupergraphSdlFromUplinks({
   fetcher: Fetcher;
   compositionId: string | null;
   maxRetries: number,
+  requestTimeoutMs: number,
   roundRobinSeed: number,
-  earliestFetchTime: Date | null,
-  logger?: Logger | undefined,
-}) : Promise<Required<SupergraphSdlUpdate> | 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,
   // in which case it will reject with the most frequently encountered error.
@@ -87,19 +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;
-        logger?.debug(`Waiting ${delayMS}ms before retrying (earliest fetch time ${earliestFetchTime})...`);
-        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({
@@ -108,6 +108,7 @@ export async function loadSupergraphSdlFromStorage({
   endpoint,
   errorReportingEndpoint,
   fetcher,
+  requestTimeoutMs,
   compositionId,
   logger,
 }: {
@@ -116,9 +117,10 @@ export async function loadSupergraphSdlFromStorage({
   endpoint: string;
   errorReportingEndpoint?: string;
   fetcher: Fetcher;
+  requestTimeoutMs: number;
   compositionId: string | null;
-  logger?: Logger | undefined;
-}) : Promise<Required<SupergraphSdlUpdate> | null> {
+  logger: Logger;
+}) : Promise<SupergraphSdlUpdate | null> {
   const requestBody = JSON.stringify({
     query: SUPERGRAPH_SDL_QUERY,
     variables: {
@@ -128,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,
@@ -137,12 +145,14 @@ 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 {
-    logger?.debug(`🔧 Fetching supergraph schema from ${endpoint}`);
     result = await fetcher(endpoint, requestDetails);
   } catch (e) {
     const endTime = new Date();
@@ -158,6 +168,8 @@ export async function loadSupergraphSdlFromStorage({
     });
 
     throw new UplinkFetcherError(fetchErrorMsg + (e.message ?? e));
+  } finally {
+    clearTimeout(signal);
   }
 
   const endTime = new Date();
@@ -200,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/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;
+};