@apollo/gateway 0.43.0 → 0.45.0-alpha.0

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

@@ -135,31 +135,16 @@ export interface RemoteGatewayConfig extends GatewayConfigBase {
     | ((service: ServiceEndpointDefinition) => Promise<HeadersInit> | HeadersInit);
 }
 
-// TODO(trevor:cloudconfig): This type goes away
-export interface LegacyManagedGatewayConfig extends GatewayConfigBase {
-  federationVersion?: number;
-  /**
-   * Setting this to null will cause the gateway to use the old mechanism for
-   * managed federation via GCS + composition.
-   */
-  schemaConfigDeliveryEndpoint: null;
-}
-
-// TODO(trevor:cloudconfig): This type becomes the only managed config
-export interface PrecomposedManagedGatewayConfig extends GatewayConfigBase {
+export interface ManagedGatewayConfig extends GatewayConfigBase {
   /**
    * This configuration option shouldn't be used unless by recommendation from
-   * Apollo staff. This can also be set to `null` (see above) in order to revert
-   * to the previous mechanism for managed federation.
+   * Apollo staff.
    */
-  schemaConfigDeliveryEndpoint?: string;
+  schemaConfigDeliveryEndpoint?: string; // deprecated
+  uplinkEndpoints?: string[];
+  uplinkMaxRetries?: number;
 }
 
-// TODO(trevor:cloudconfig): This union is no longer needed
-export type ManagedGatewayConfig =
-  | LegacyManagedGatewayConfig
-  | PrecomposedManagedGatewayConfig;
-
 interface ManuallyManagedServiceDefsGatewayConfig extends GatewayConfigBase {
   experimental_updateServiceDefinitions: Experimental_UpdateServiceDefinitions;
 }
@@ -216,30 +201,12 @@ export function isManuallyManagedConfig(
 export function isManagedConfig(
   config: GatewayConfig,
 ): config is ManagedGatewayConfig {
-  return isPrecomposedManagedConfig(config) || isLegacyManagedConfig(config);
-}
-
-// TODO(trevor:cloudconfig): This merges with `isManagedConfig`
-export function isPrecomposedManagedConfig(
-  config: GatewayConfig,
-): config is PrecomposedManagedGatewayConfig {
-  return (
-    !isLegacyManagedConfig(config) &&
-    (('schemaConfigDeliveryEndpoint' in config &&
-      typeof config.schemaConfigDeliveryEndpoint === 'string') ||
-      (!isRemoteConfig(config) &&
-        !isLocalConfig(config) &&
-        !isSupergraphSdlConfig(config) &&
-        !isManuallyManagedConfig(config)))
-  );
-}
-
-export function isLegacyManagedConfig(
-  config: GatewayConfig,
-): config is LegacyManagedGatewayConfig {
   return (
-    'schemaConfigDeliveryEndpoint' in config &&
-    config.schemaConfigDeliveryEndpoint === null
+    'schemaConfigDeliveryEndpoint' in config ||
+    (!isRemoteConfig(config) &&
+      !isLocalConfig(config) &&
+      !isSupergraphSdlConfig(config) &&
+      !isManuallyManagedConfig(config))
   );
 }
 

package/src/index.ts

@@ -66,12 +66,9 @@ import {
   ServiceDefinitionUpdate,
   SupergraphSdlUpdate,
   CompositionUpdate,
-  isPrecomposedManagedConfig,
-  isLegacyManagedConfig,
 } from './config';
-import { loadSupergraphSdlFromStorage } from './loadSupergraphSdlFromStorage';
-import { getServiceDefinitionsFromStorage } from './legacyLoadServicesFromStorage';
 import { buildComposedSchema } from '@apollo/query-planner';
+import { loadSupergraphSdlFromUplinks } from './loadSupergraphSdlFromStorage';
 import { SpanStatusCode } from '@opentelemetry/api';
 import { OpenTelemetrySpanNames, tracer } from './utilities/opentelemetry';
 import { CoreSchema } from '@apollo/core-schema';
@@ -114,20 +111,6 @@ export function getDefaultFetcher() {
   });
 }
 
-/**
- * TODO(trevor:cloudconfig): Stop exporting this
- * @deprecated This will be removed in a future version of @apollo/gateway
- */
-export const getDefaultGcsFetcher = deprecate(
-  getDefaultFetcher,
-  `'getDefaultGcsFetcher' is deprecated. Use 'getDefaultFetcher' instead.`,
-);
-/**
- * TODO(trevor:cloudconfig): Stop exporting this
- * @deprecated This will be removed in a future version of @apollo/gateway
- */
-export const GCS_RETRY_COUNT = 5;
-
 export const HEALTH_CHECK_QUERY =
   'query __ApolloServiceHealthCheck__ { __typename }';
 export const SERVICE_DEFINITION_QUERY =
@@ -193,10 +176,13 @@ export class ApolloGateway implements GraphQLService {
   private serviceSdlCache = new Map<string, string>();
   private warnedStates: WarnedStates = Object.create(null);
   private queryPlanner?: QueryPlanner;
+  private supergraphSdl?: string;
   private parsedSupergraphSdl?: DocumentNode;
   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
@@ -214,12 +200,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
-  // * `null` will revert the gateway to legacy mode (polling GCS and composing the schema itself).
+  // 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
-  // TODO(trevor:cloudconfig): `null` should be disallowed in the future.
-  private schemaConfigDeliveryEndpoint?: string | null;
+  private uplinkEndpoints?: string[];
+  private uplinkMaxRetries?: number;
 
   constructor(config?: GatewayConfig) {
     this.config = {
@@ -247,19 +232,23 @@ export class ApolloGateway implements GraphQLService {
     this.experimental_pollInterval = config?.experimental_pollInterval;
 
     // 1. If config is set to a `string`, use it
-    // 2. If config is explicitly set to `null`, fallback to GCS
-    // 3. If the env var is set, use that
-    // 4. If config is `undefined`, use the default uplink URL
-
-    // This if case unobviously handles 1, 2, and 4.
-    if (isPrecomposedManagedConfig(this.config)) {
-      const envEndpoint = process.env.APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT;
-      this.schemaConfigDeliveryEndpoint =
-        this.config.schemaConfigDeliveryEndpoint ??
-        envEndpoint ??
-        'https://uplink.api.apollographql.com/';
-    } else if (isLegacyManagedConfig(this.config)) {
-      this.schemaConfigDeliveryEndpoint = null;
+    // 2. If the env var is set, use that
+    // 3. If config is `undefined`, use the default uplink URLs
+    if (isManagedConfig(this.config)) {
+      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)) {
@@ -447,6 +436,7 @@ export class ApolloGateway implements GraphQLService {
         : this.createSchemaFromSupergraphSdl(config.supergraphSdl));
       // TODO(trevor): #580 redundant parse
       this.parsedSupergraphSdl = parse(supergraphSdl);
+      this.supergraphSdl = supergraphSdl;
       this.updateWithSchemaAndNotify(schema, supergraphSdl, true);
     } catch (e) {
       this.state = { phase: 'failed to load' };
@@ -576,6 +566,7 @@ export class ApolloGateway implements GraphQLService {
     await this.maybePerformServiceHealthCheck(result);
 
     this.compositionId = result.id;
+    this.supergraphSdl = result.supergraphSdl;
     this.parsedSupergraphSdl = parsedSupergraphSdl;
 
     const { schema, supergraphSdl } = this.createSchemaFromSupergraphSdl(
@@ -977,24 +968,22 @@ export class ApolloGateway implements GraphQLService {
       );
     }
 
-    // TODO(trevor:cloudconfig): This condition goes away completely
-    if (isPrecomposedManagedConfig(config)) {
-      return loadSupergraphSdlFromStorage({
-        graphRef: this.apolloConfig!.graphRef!,
-        apiKey: this.apolloConfig!.key!,
-        endpoint: this.schemaConfigDeliveryEndpoint!,
-        fetcher: this.fetcher,
-      });
-    } else if (isLegacyManagedConfig(config)) {
-      return getServiceDefinitionsFromStorage({
-        graphRef: this.apolloConfig!.graphRef!,
-        apiKeyHash: this.apolloConfig!.keyHash!,
-        federationVersion: config.federationVersion || 1,
-        fetcher: this.fetcher,
-      });
-    } else {
-      throw new Error('Programming error: unhandled configuration');
-    }
+    const result = await loadSupergraphSdlFromUplinks({
+      graphRef: this.apolloConfig!.graphRef!,
+      apiKey: this.apolloConfig!.key!,
+      endpoints: this.uplinkEndpoints!,
+      errorReportingEndpoint: this.errorReportingEndpoint,
+      fetcher: this.fetcher,
+      compositionId: this.compositionId ?? null,
+      maxRetries: this.uplinkMaxRetries!,
+    });
+
+    return (
+      result ?? {
+        id: this.compositionId!,
+        supergraphSdl: this.supergraphSdl!,
+      }
+    );
   }
 
   private maybeWarnOnConflictingConfig() {

package/src/loadSupergraphSdlFromStorage.ts

@@ -1,12 +1,13 @@
 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
 export const SUPERGRAPH_SDL_QUERY = /* GraphQL */`#graphql
-  query SupergraphSdl($apiKey: String!, $ref: String!) {
-    routerConfig(ref: $ref, apiKey: $apiKey) {
+  query SupergraphSdl($apiKey: String!, $ref: String!, $ifAfterId: ID) {
+    routerConfig(ref: $ref, apiKey: $apiKey, ifAfterId: $ifAfterId) {
       __typename
       ... on RouterConfigResult {
         id
@@ -38,17 +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',
@@ -57,6 +104,7 @@ export async function loadSupergraphSdlFromStorage({
       variables: {
         ref: graphRef,
         apiKey,
+        ifAfterId: compositionId,
       },
     }),
     headers: {
@@ -69,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));
@@ -106,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);
   }
@@ -124,13 +173,13 @@ export async function loadSupergraphSdlFromStorage({
       supergraphSdl,
       // messages,
     } = routerConfig;
-
-    // `supergraphSdl` should not be nullable in the schema, but it currently is
     return { id, supergraphSdl: supergraphSdl! };
   } else if (routerConfig.__typename === 'FetchError') {
     // FetchError case
     const { code, message } = routerConfig;
     throw new Error(`${code}: ${message}`);
+  } else if (routerConfig.__typename === 'Unchanged') {
+    return null;
   } else {
     throw new Error('Programming error: unhandled response failure');
   }

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}`);
   }
 }

package/dist/legacyLoadServicesFromStorage.d.ts

@@ -1,20 +0,0 @@
-import { fetch } from 'apollo-server-env';
-import { ServiceDefinitionUpdate } from './config';
-interface ImplementingServiceLocation {
-    name: string;
-    path: string;
-}
-export interface CompositionMetadata {
-    formatVersion: number;
-    id: string;
-    implementingServiceLocations: ImplementingServiceLocation[];
-    schemaHash: string;
-}
-export declare function getServiceDefinitionsFromStorage({ graphRef, apiKeyHash, federationVersion, fetcher, }: {
-    graphRef: string;
-    apiKeyHash: string;
-    federationVersion: number;
-    fetcher: typeof fetch;
-}): Promise<ServiceDefinitionUpdate>;
-export {};
-//# sourceMappingURL=legacyLoadServicesFromStorage.d.ts.map

package/dist/legacyLoadServicesFromStorage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacyLoadServicesFromStorage.d.ts","sourceRoot":"","sources":["../src/legacyLoadServicesFromStorage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAiBnD,UAAU,2BAA2B;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,4BAA4B,EAAE,2BAA2B,EAAE,CAAC;IAC5D,UAAU,EAAE,MAAM,CAAC;CACpB;AAsED,wBAAsB,gCAAgC,CAAC,EACrD,QAAQ,EACR,UAAU,EACV,iBAAiB,EACjB,OAAO,GACR,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,OAAO,KAAK,CAAC;CACvB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CA4DnC"}

package/dist/legacyLoadServicesFromStorage.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getServiceDefinitionsFromStorage = void 0;
-const graphql_1 = require("graphql");
-const envOverridePartialSchemaBaseUrl = 'APOLLO_PARTIAL_SCHEMA_BASE_URL';
-const envOverrideStorageSecretBaseUrl = 'APOLLO_STORAGE_SECRET_BASE_URL';
-const urlFromEnvOrDefault = (envKey, fallback) => (process.env[envKey] || fallback).replace(/\/$/, '');
-const urlPartialSchemaBase = urlFromEnvOrDefault(envOverridePartialSchemaBaseUrl, 'https://federation.api.apollographql.com/');
-const urlStorageSecretBase = urlFromEnvOrDefault(envOverrideStorageSecretBaseUrl, 'https://storage-secrets.api.apollographql.com/');
-function getStorageSecretUrl(graphId, apiKeyHash) {
-    return `${urlStorageSecretBase}/${graphId}/storage-secret/${apiKeyHash}.json`;
-}
-function fetchApolloGcs(fetcher, ...args) {
-    const [input, init] = args;
-    const url = (typeof input === 'object' && input.url) || input;
-    return fetcher(input, init)
-        .catch((fetchError) => {
-        throw new Error('Cannot access Apollo storage: ' + fetchError);
-    })
-        .then(async (response) => {
-        if (response.ok || response.status === 304) {
-            return response;
-        }
-        const body = await response.text();
-        if (response.status === 403 && body.includes('AccessDenied')) {
-            throw new Error('Unable to authenticate with Apollo storage ' +
-                'while fetching ' +
-                url +
-                '.  Ensure that the API key is ' +
-                'configured properly and that a federated service has been ' +
-                'pushed.  For details, see ' +
-                'https://go.apollo.dev/g/resolve-access-denied.');
-        }
-        throw new Error('Could not communicate with Apollo storage: ' + body);
-    });
-}
-async function getServiceDefinitionsFromStorage({ graphRef, apiKeyHash, federationVersion, fetcher, }) {
-    const at = graphRef.indexOf('@');
-    const graphId = at === -1 ? graphRef : graphRef.substring(0, at);
-    const graphVariant = at === -1 ? 'current' : graphRef.substring(at + 1);
-    const storageSecretUrl = getStorageSecretUrl(graphId, apiKeyHash);
-    const secret = await fetchApolloGcs(fetcher, storageSecretUrl).then((res) => res.json());
-    const baseUrl = `${urlPartialSchemaBase}/${secret}/${graphVariant}/v${federationVersion}`;
-    const compositionConfigResponse = await fetchApolloGcs(fetcher, `${baseUrl}/composition-config-link`);
-    if (compositionConfigResponse.status === 304) {
-        return { isNewSchema: false };
-    }
-    const linkFileResult = await compositionConfigResponse.json();
-    const compositionMetadata = await fetchApolloGcs(fetcher, `${urlPartialSchemaBase}/${linkFileResult.configPath}`).then((res) => res.json());
-    const serviceDefinitions = await Promise.all(compositionMetadata.implementingServiceLocations.map(async ({ name, path }) => {
-        const { url, partialSchemaPath } = await fetcher(`${urlPartialSchemaBase}/${path}`).then((response) => response.json());
-        const sdl = await fetcher(`${urlPartialSchemaBase}/${partialSchemaPath}`).then((response) => response.text());
-        return { name, url, typeDefs: (0, graphql_1.parse)(sdl) };
-    }));
-    return {
-        serviceDefinitions,
-        compositionMetadata,
-        isNewSchema: true,
-    };
-}
-exports.getServiceDefinitionsFromStorage = getServiceDefinitionsFromStorage;
-//# sourceMappingURL=legacyLoadServicesFromStorage.js.map