@apollo/gateway 2.0.5 → 2.1.0-alpha.0

package/src/__tests__/integration/managed.test.ts

@@ -0,0 +1,289 @@
+import mockedEnv from 'mocked-env';
+
+import { ApolloGateway, UplinkSupergraphManager } from '@apollo/gateway';
+import { ApolloServer } from 'apollo-server';
+import { ApolloServerPluginUsageReportingDisabled } from 'apollo-server-core';
+
+import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
+import {
+  mockSupergraphSdlRequestSuccess,
+  graphRef,
+  apiKey,
+  mockSupergraphSdlRequest,
+} from '../integration/nockMocks';
+import { getTestingSupergraphSdl } from '../execution-utils';
+
+let gateway: ApolloGateway | undefined;
+let server: ApolloServer | undefined;
+let cleanUp: (() => void) | undefined;
+
+beforeEach(() => {
+  nockBeforeEach();
+});
+
+afterEach(async () => {
+  nockAfterEach();
+
+  if (server) {
+    await server.stop();
+    server = undefined;
+  }
+
+  if (gateway) {
+    await gateway.stop();
+    gateway = undefined;
+  }
+
+  if (cleanUp) {
+    cleanUp();
+    cleanUp = undefined;
+  }
+});
+
+const logger = {
+  warn: jest.fn(),
+  debug: jest.fn(),
+  error: jest.fn(),
+  info: jest.fn(),
+};
+
+describe('minimal gateway', () => {
+  it('uses managed federation', async () => {
+    cleanUp = mockedEnv({
+      APOLLO_KEY: apiKey,
+      APOLLO_GRAPH_REF: graphRef,
+    });
+    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ });
+
+    gateway = new ApolloGateway({ logger });
+    server = new ApolloServer({
+      gateway,
+      plugins: [ApolloServerPluginUsageReportingDisabled()],
+    });
+    await server.listen({ port: 0 });
+    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
+  });
+
+  it('fetches from provided `uplinkEndpoints`', async () => {
+    cleanUp = mockedEnv({
+      APOLLO_KEY: apiKey,
+      APOLLO_GRAPH_REF: graphRef,
+    });
+
+    const uplinkEndpoint = 'https://example.com';
+    mockSupergraphSdlRequestSuccess({ url: uplinkEndpoint });
+
+    gateway = new ApolloGateway({ logger, uplinkEndpoints: [uplinkEndpoint] });
+    server = new ApolloServer({
+      gateway,
+      plugins: [ApolloServerPluginUsageReportingDisabled()],
+    });
+    await server.listen({ port: 0 });
+    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
+    const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
+    expect(uplinkManager.uplinkEndpoints).toEqual([uplinkEndpoint]);
+  });
+
+  it('fetches from (deprecated) provided `schemaConfigDeliveryEndpoint`', async () => {
+    cleanUp = mockedEnv({
+      APOLLO_KEY: apiKey,
+      APOLLO_GRAPH_REF: graphRef,
+    });
+
+    const schemaConfigDeliveryEndpoint = 'https://example.com';
+    mockSupergraphSdlRequestSuccess({ url: schemaConfigDeliveryEndpoint });
+
+    gateway = new ApolloGateway({ logger, schemaConfigDeliveryEndpoint });
+    server = new ApolloServer({
+      gateway,
+      plugins: [ApolloServerPluginUsageReportingDisabled()],
+    });
+    await server.listen({ port: 0 });
+    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
+    const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
+    expect(uplinkManager.uplinkEndpoints).toEqual([
+      schemaConfigDeliveryEndpoint,
+    ]);
+  });
+});
+
+describe('Managed gateway with explicit UplinkSupergraphManager', () => {
+  it('waits for supergraph schema to load', async () => {
+    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ });
+
+    gateway = new ApolloGateway({
+      logger,
+      supergraphSdl: new UplinkSupergraphManager({
+        apiKey,
+        graphRef,
+        logger,
+      }),
+    });
+    await expect(gateway.load()).resolves.not.toThrow();
+  });
+
+  it('invokes callback if uplink throws an error during init', async () => {
+    mockSupergraphSdlRequest(null, /.*?apollographql.com/).reply(500);
+
+    const supergraphSchema = getTestingSupergraphSdl();
+    let hasFired;
+    gateway = new ApolloGateway({
+      logger,
+      supergraphSdl: new UplinkSupergraphManager({
+        apiKey,
+        graphRef,
+        logger,
+        maxRetries: 0,
+        fallbackPollIntervalInMs: 0,
+        async onFailureToFetchSupergraphSdlDuringInit() {
+          hasFired = true;
+          return supergraphSchema;
+        },
+      }),
+    });
+
+    await expect(gateway.load()).resolves.not.toThrow();
+    expect(gateway.__testing().supergraphSdl).toBe(supergraphSchema);
+    expect(hasFired).toBeTruthy();
+  });
+
+  it('invokes callback if uplink throws an error after init', async () => {
+    // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
+    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
+      .post('/')
+      .reply(500);
+
+    const supergraphSchema = getTestingSupergraphSdl();
+    let hasFired;
+    gateway = new ApolloGateway({
+      logger,
+      supergraphSdl: new UplinkSupergraphManager({
+        apiKey,
+        graphRef,
+        logger,
+        maxRetries: 0,
+        fallbackPollIntervalInMs: 0,
+        async onFailureToFetchSupergraphSdlAfterInit() {
+          hasFired = true;
+          return supergraphSchema;
+        },
+      }),
+    });
+
+    await expect(gateway.load()).resolves.not.toThrow();
+    expect(hasFired).toBeFalsy();
+
+    const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
+    await uplinkManager.nextFetch();
+
+    expect(hasFired).toBeTruthy();
+  });
+
+  it.each([
+    ['x', 'Syntax Error: Unexpected Name "x".'],
+    ['', 'Syntax Error: Unexpected <EOF>.'],
+    [' ', 'Syntax Error: Unexpected <EOF>.'],
+    ['type Query {hi: String}', 'Invalid supergraph: must be a core schema'],
+  ])(
+    'throws if invalid supergraph schema returned from callback during init: %p',
+    async (schemaText, expectedMessage) => {
+      mockSupergraphSdlRequest(null, /.*?apollographql.com/).reply(500);
+
+      gateway = new ApolloGateway({
+        logger,
+        supergraphSdl: new UplinkSupergraphManager({
+          apiKey,
+          graphRef,
+          logger,
+          maxRetries: 0,
+          fallbackPollIntervalInMs: 0,
+          async onFailureToFetchSupergraphSdlDuringInit() {
+            return schemaText;
+          },
+        }),
+      });
+
+      await expect(gateway.load()).rejects.toThrowError(expectedMessage);
+    },
+  );
+
+  it.each([
+    ['x', 'Syntax Error: Unexpected Name "x".'],
+    [' ', 'Syntax Error: Unexpected <EOF>.'],
+    ['type Query {hi: String}', 'Invalid supergraph: must be a core schema'],
+  ])(
+    'throws if invalid supergraph schema returned from callback after init: %p',
+    async (schemaText, expectedMessage) => {
+      // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
+      mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
+        .post('/')
+        .reply(500);
+
+      let hasFired;
+      gateway = new ApolloGateway({
+        logger,
+        supergraphSdl: new UplinkSupergraphManager({
+          apiKey,
+          graphRef,
+          logger,
+          maxRetries: 0,
+          fallbackPollIntervalInMs: 0,
+          async onFailureToFetchSupergraphSdlAfterInit() {
+            hasFired = true;
+            return schemaText;
+          },
+        }),
+      });
+
+      await expect(gateway.load()).resolves.not.toThrow();
+      expect(hasFired).toBeFalsy();
+
+      const uplinkManager =
+        gateway.supergraphManager as UplinkSupergraphManager;
+      await uplinkManager.nextFetch();
+
+      expect(hasFired).toBeTruthy();
+      expect(logger.error).toBeCalledWith(
+        `UplinkSupergraphManager failed to update supergraph with the following error: ${expectedMessage}`,
+      );
+    },
+  );
+
+  it.each([null, ''])(
+    'uses existing supergraph schema is false-y value returned from callback after init: %p',
+    async (schemaText) => {
+      // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
+      mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
+        .post('/')
+        .reply(500);
+
+      let hasFired;
+      gateway = new ApolloGateway({
+        logger,
+        supergraphSdl: new UplinkSupergraphManager({
+          apiKey,
+          graphRef,
+          logger,
+          maxRetries: 0,
+          fallbackPollIntervalInMs: 0,
+          async onFailureToFetchSupergraphSdlAfterInit() {
+            hasFired = true;
+            return schemaText;
+          },
+        }),
+      });
+
+      await expect(gateway.load()).resolves.not.toThrow();
+      expect(hasFired).toBeFalsy();
+
+      const uplinkManager =
+        gateway.supergraphManager as UplinkSupergraphManager;
+      await uplinkManager.nextFetch();
+
+      expect(hasFired).toBeTruthy();
+
+      const supergraphSchema = getTestingSupergraphSdl();
+      expect(gateway.__testing().supergraphSdl).toBe(supergraphSchema);
+    },
+  );
+});

package/src/__tests__/integration/networkRequests.test.ts

@@ -183,13 +183,6 @@ describe('Supergraph SDL update failures', () => {
     ).rejects.toThrowErrorMatchingInlineSnapshot(
       `"An error occurred while fetching your schema from Apollo: 401 Unauthorized"`,
     );
-
-    await expect(gateway.stop()).rejects.toThrowErrorMatchingInlineSnapshot(
-      `"ApolloGateway.stop does not need to be called before ApolloGateway.load is called successfully"`,
-    );
-    // Set to `null` so we don't try to call `stop` on it in the `afterEach`,
-    // which triggers a different error that we're not testing for here.
-    gateway = null;
   });
 
   it('Handles arbitrary fetch failures (non 200 response)', async () => {
@@ -213,7 +206,7 @@ describe('Supergraph SDL update failures', () => {
     await errorLoggedPromise;
 
     expect(logger.error).toHaveBeenCalledWith(
-      'UplinkFetcher failed to update supergraph with the following error: An error occurred while fetching your schema from Apollo: 500 Internal Server Error',
+      'UplinkSupergraphManager failed to update supergraph with the following error: An error occurred while fetching your schema from Apollo: 500 Internal Server Error',
     );
   });
 
@@ -245,7 +238,7 @@ describe('Supergraph SDL update failures', () => {
     await errorLoggedPromise;
 
     expect(logger.error).toHaveBeenCalledWith(
-      `UplinkFetcher failed to update supergraph with the following error: An error occurred while fetching your schema from Apollo: \nCannot query field "fail" on type "Query".`,
+      `UplinkSupergraphManager failed to update supergraph with the following error: An error occurred while fetching your schema from Apollo: \nCannot query field "fail" on type "Query".`,
     );
   });
 
@@ -279,7 +272,7 @@ describe('Supergraph SDL update failures', () => {
     await errorLoggedPromise;
 
     expect(logger.error).toHaveBeenCalledWith(
-      'UplinkFetcher failed to update supergraph with the following error: Syntax Error: Unexpected Name "Syntax".',
+      'UplinkSupergraphManager failed to update supergraph with the following error: Syntax Error: Unexpected Name "Syntax".',
     );
     expect(gateway.schema).toBeTruthy();
   });
@@ -312,10 +305,6 @@ describe('Supergraph SDL update failures', () => {
     );
 
     expect(gateway['state'].phase).toEqual('failed to load');
-
-    // Set to `null` so we don't try to call `stop` on it in the `afterEach`,
-    // which triggers a different error that we're not testing for here.
-    gateway = null;
   });
 });
 
@@ -406,14 +395,6 @@ describe('Downstream service health checks', () => {
         "The gateway subgraphs health check failed. Updating to the provided \`supergraphSdl\` will likely result in future request failures to subgraphs. The following error occurred during the health check:
         [accounts]: 500: Internal Server Error"
       `);
-
-      await expect(gateway.stop()).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"ApolloGateway.stop does not need to be called before ApolloGateway.load is called successfully"`,
-      );
-
-      // Set to `null` so we don't try to call `stop` on it in the `afterEach`,
-      // which triggers a different error that we're not testing for here.
-      gateway = null;
     });
   });
 
@@ -471,14 +452,6 @@ describe('Downstream service health checks', () => {
         "The gateway subgraphs health check failed. Updating to the provided \`supergraphSdl\` will likely result in future request failures to subgraphs. The following error occurred during the health check:
         [accounts]: 500: Internal Server Error"
       `);
-
-      await expect(gateway.stop()).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"ApolloGateway.stop does not need to be called before ApolloGateway.load is called successfully"`,
-      );
-
-      // Set to `null` so we don't try to call `stop` on it in the `afterEach`,
-      // which triggers a different error that we're not testing for here.
-      gateway = null;
     });
 
     // This test has been flaky for a long time, and fails consistently after changes
@@ -568,7 +541,7 @@ describe('Downstream service health checks', () => {
 
       await errorLoggedPromise;
       expect(logger.error).toHaveBeenCalledWith(
-        `UplinkFetcher failed to update supergraph with the following error: The gateway subgraphs health check failed. Updating to the provided \`supergraphSdl\` will likely result in future request failures to subgraphs. The following error occurred during the health check:\n[accounts]: 500: Internal Server Error`,
+        `UplinkSupergraphManager failed to update supergraph with the following error: The gateway subgraphs health check failed. Updating to the provided \`supergraphSdl\` will likely result in future request failures to subgraphs. The following error occurred during the health check:\n[accounts]: 500: Internal Server Error`,
       );
 
       // At this point, the mock update should have been called but the schema

package/src/__tests__/integration/nockMocks.ts

@@ -1,6 +1,6 @@
 import nock from 'nock';
 import { HEALTH_CHECK_QUERY, SERVICE_DEFINITION_QUERY } from '../..';
-import { SUPERGRAPH_SDL_QUERY } from '../../supergraphManagers/UplinkFetcher/loadSupergraphSdlFromStorage';
+import { SUPERGRAPH_SDL_QUERY } from '../../supergraphManagers/UplinkSupergraphManager/loadSupergraphSdlFromStorage';
 import { getTestingSupergraphSdl } from '../../__tests__/execution-utils';
 import { print } from 'graphql';
 import { Fixture, fixtures as testingFixtures } from 'apollo-federation-integration-testsuite';
@@ -83,7 +83,7 @@ export const mockCloudConfigUrl3 =
 export const mockOutOfBandReporterUrl =
   'https://example.outofbandreporter.com/monitoring/';
 
-export function mockSupergraphSdlRequestIfAfter(ifAfter: string | null, url: string = mockCloudConfigUrl1) {
+export function mockSupergraphSdlRequestIfAfter(ifAfter: string | null, url: string | RegExp = mockCloudConfigUrl1) {
   return gatewayNock(url).post('/', {
     query: SUPERGRAPH_SDL_QUERY,
     variables: {
@@ -94,7 +94,7 @@ export function mockSupergraphSdlRequestIfAfter(ifAfter: string | null, url: str
   });
 }
 
-export function mockSupergraphSdlRequest(ifAfter: string | null = null, url: string = mockCloudConfigUrl1) {
+export function mockSupergraphSdlRequest(ifAfter: string | null = null, url: string | RegExp = mockCloudConfigUrl1) {
   return mockSupergraphSdlRequestIfAfter(ifAfter, url);
 }
 
@@ -102,11 +102,12 @@ export function mockSupergraphSdlRequestSuccessIfAfter(
   ifAfter: string | null = null,
   id: string = 'originalId-1234',
   supergraphSdl: string = getTestingSupergraphSdl(),
+  url: string | RegExp = mockCloudConfigUrl1,
 ) {
   if (supergraphSdl == null) {
     supergraphSdl = getTestingSupergraphSdl();
   }
-  return mockSupergraphSdlRequestIfAfter(ifAfter).reply(
+  return mockSupergraphSdlRequestIfAfter(ifAfter, url).reply(
     200,
     JSON.stringify({
       data: {
@@ -136,8 +137,8 @@ export function mockSupergraphSdlRequestIfAfterUnchanged(
   );
 }
 
-export function mockSupergraphSdlRequestSuccess() {
-  return mockSupergraphSdlRequestSuccessIfAfter(null);
+export function mockSupergraphSdlRequestSuccess({supergraphSdl = getTestingSupergraphSdl(), url = mockCloudConfigUrl1}: {supergraphSdl?: string, url?: string | RegExp} = {}) {
+  return mockSupergraphSdlRequestSuccessIfAfter(null, undefined, supergraphSdl, url);
 }
 
 export function mockOutOfBandReportRequest() {

package/src/config.ts

@@ -8,6 +8,7 @@ import { OperationContext } from './operationContext';
 import { ServiceMap } from './executeQueryPlan';
 import { ServiceDefinition } from "@apollo/federation-internals";
 import { Fetcher } from '@apollo/utils.fetcher';
+import { UplinkSupergraphManager } from './supergraphManagers';
 
 export type ServiceEndpointDefinition = Pick<ServiceDefinition, 'name' | 'url'>;
 
@@ -325,6 +326,7 @@ export function isManagedConfig(
     'schemaConfigDeliveryEndpoint' in config ||
     'uplinkEndpoints' in config ||
     'fallbackPollIntervalInMs' in config ||
+    (isSupergraphManagerConfig(config) && config.supergraphSdl instanceof UplinkSupergraphManager) ||
     (!isLocalConfig(config) &&
       !isStaticSupergraphSdlConfig(config) &&
       !isManuallyManagedConfig(config))

package/src/index.ts

@@ -13,7 +13,6 @@ import {
   GraphQLSchema,
   VariableDefinitionNode,
 } from 'graphql';
-import loglevel from 'loglevel';
 import { buildOperationContext, OperationContext } from './operationContext';
 import {
   executeQueryPlan,
@@ -26,7 +25,6 @@ import {
 } from './datasources/types';
 import { RemoteGraphQLDataSource } from './datasources/RemoteGraphQLDataSource';
 import { getVariableValues } from 'graphql/execution/values';
-import fetcher from 'make-fetch-happen';
 import {
   QueryPlanner,
   QueryPlan,
@@ -46,7 +44,6 @@ import {
   isManagedConfig,
   SupergraphSdlUpdate,
   isManuallyManagedSupergraphSdlGatewayConfig,
-  ManagedGatewayConfig,
   isStaticSupergraphSdlConfig,
   SupergraphManager,
 } from './config';
@@ -55,7 +52,7 @@ import { OpenTelemetrySpanNames, tracer } from './utilities/opentelemetry';
 import { addExtensions } from './schema-helper/addExtensions';
 import {
   IntrospectAndCompose,
-  UplinkFetcher,
+  UplinkSupergraphManager,
   LegacyFetcher,
   LocalCompose,
 } from './supergraphManagers';
@@ -65,7 +62,7 @@ import {
   Schema,
   ServiceDefinition,
 } from '@apollo/federation-internals';
-import { Fetcher } from '@apollo/utils.fetcher';
+import { getDefaultLogger } from './logger';
 
 type DataSourceMap = {
   [serviceName: string]: { url?: string; dataSource: GraphQLDataSource };
@@ -145,9 +142,9 @@ export class ApolloGateway implements GraphQLService {
   private warnedStates: WarnedStates = Object.create(null);
   private queryPlanner?: QueryPlanner;
   private supergraphSdl?: string;
-  private fetcher: Fetcher;
   private compositionId?: string;
   private state: GatewayState;
+  private _supergraphManager?: SupergraphManager;
 
   // Observe query plan, service info, and operation info prior to execution.
   // The information made available here will give insight into the resulting
@@ -169,11 +166,10 @@ export class ApolloGateway implements GraphQLService {
       ...config,
     };
 
-    this.logger = this.initLogger();
+    this.logger = this.config.logger ?? getDefaultLogger(this.config.debug);
     this.queryPlanStore = this.initQueryPlanStore(
       config?.experimental_approximateQueryPlanStoreMiB,
     );
-    this.fetcher = config?.fetcher || fetcher;
 
     // set up experimental observability callbacks and config settings
     this.experimental_didResolveQueryPlan =
@@ -194,23 +190,8 @@ export class ApolloGateway implements GraphQLService {
     this.state = { phase: 'initialized' };
   }
 
-  private initLogger() {
-    // Setup logging facilities
-    if (this.config.logger) {
-      return this.config.logger;
-    }
-
-    // If the user didn't provide their own logger, we'll initialize one.
-    const loglevelLogger = loglevel.getLogger(`apollo-gateway`);
-
-    // And also support the `debug` option, if it's truthy.
-    if (this.config.debug === true) {
-      loglevelLogger.setLevel(loglevelLogger.levels.DEBUG);
-    } else {
-      loglevelLogger.setLevel(loglevelLogger.levels.WARN);
-    }
-
-    return loglevelLogger;
+  public get supergraphManager(): SupergraphManager | undefined {
+    return this._supergraphManager;
   }
 
   private initQueryPlanStore(approximateQueryPlanStoreMiB?: number) {
@@ -381,19 +362,21 @@ export class ApolloGateway implements GraphQLService {
             '`serviceList`, `supergraphSdl`, and `experimental_updateServiceDefinitions`.',
         );
       }
-      const uplinkEndpoints = this.getUplinkEndpoints(this.config);
 
+      const schemaDeliveryEndpoints: string[] | undefined = this.config
+        .schemaConfigDeliveryEndpoint
+        ? [this.config.schemaConfigDeliveryEndpoint]
+        : undefined;
       await this.initializeSupergraphManager(
-        new UplinkFetcher({
+        new UplinkSupergraphManager({
           graphRef: this.apolloConfig!.graphRef!,
           apiKey: this.apolloConfig!.key!,
-          uplinkEndpoints,
-          maxRetries:
-            this.config.uplinkMaxRetries ?? uplinkEndpoints.length * 3 - 1, // -1 for the initial request
-          subgraphHealthCheck: this.config.serviceHealthCheck,
-          fetcher: this.fetcher,
+          shouldRunSubgraphHealthcheck: this.config.serviceHealthCheck,
+          uplinkEndpoints:
+            this.config.uplinkEndpoints ?? schemaDeliveryEndpoints,
+          maxRetries: this.config.uplinkMaxRetries,
           logger: this.logger,
-          fallbackPollIntervalInMs: this.pollIntervalInMs ?? 10000,
+          fallbackPollIntervalInMs: this.pollIntervalInMs,
         }),
       );
     }
@@ -415,29 +398,6 @@ export class ApolloGateway implements GraphQLService {
     };
   }
 
-  private getUplinkEndpoints(config: ManagedGatewayConfig) {
-    /**
-     * Configuration priority order:
-     * 1. `uplinkEndpoints` configuration option
-     * 2. (deprecated) `schemaConfigDeliveryEndpoint` configuration option
-     * 3. APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT environment variable
-     * 4. default (GCP and AWS)
-     */
-    const rawEndpointsString =
-      process.env.APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT;
-    const envEndpoints = rawEndpointsString?.split(',') ?? null;
-    return (
-      config.uplinkEndpoints ??
-      (config.schemaConfigDeliveryEndpoint
-        ? [config.schemaConfigDeliveryEndpoint]
-        : null) ??
-      envEndpoints ?? [
-        'https://uplink.api.apollographql.com/',
-        'https://aws.uplink.api.apollographql.com/',
-      ]
-    );
-  }
-
   private getIdForSupergraphSdl(supergraphSdl: string) {
     return createHash('sha256').update(supergraphSdl).digest('hex');
   }
@@ -451,11 +411,6 @@ export class ApolloGateway implements GraphQLService {
         healthCheck: this.externalSubgraphHealthCheckCallback.bind(this),
         getDataSource: this.externalGetDataSourceCallback.bind(this),
       });
-      if (!result?.supergraphSdl) {
-        throw new Error(
-          'Provided `supergraphSdl` function did not return an object containing a `supergraphSdl` property',
-        );
-      }
       if (result?.cleanup) {
         if (typeof result.cleanup === 'function') {
           this.toDispose.push(result.cleanup);
@@ -473,6 +428,7 @@ export class ApolloGateway implements GraphQLService {
       throw e;
     }
 
+    this._supergraphManager = supergraphManager;
     this.state = { phase: 'loaded' };
   }
 
@@ -1008,9 +964,6 @@ export class ApolloGateway implements GraphQLService {
     switch (this.state.phase) {
       case 'initialized':
       case 'failed to load':
-        throw Error(
-          'ApolloGateway.stop does not need to be called before ApolloGateway.load is called successfully',
-        );
       case 'stopped':
         // Calls to stop() are idempotent.
         return;
@@ -1105,6 +1058,7 @@ export {
   CompositionInfo,
   IntrospectAndCompose,
   LocalCompose,
+  UplinkSupergraphManager,
 };
 
 export * from './datasources';
@@ -1114,8 +1068,13 @@ export {
   SubgraphHealthCheckFunction,
   GetDataSourceFunction,
   SupergraphSdlHook,
-  SupergraphManager
+  SupergraphManager,
 } from './config';
 
-export { UplinkFetcherError } from "./supergraphManagers"
-
+export {
+  UplinkFetcherError,
+  FailureToFetchSupergraphSdlAfterInit,
+  FailureToFetchSupergraphSdlDuringInit,
+  FailureToFetchSupergraphSdlFunctionParams,
+  DEFAULT_UPLINK_ENDPOINTS,
+} from './supergraphManagers';

package/src/logger.ts

@@ -0,0 +1,11 @@
+import loglevel from 'loglevel';
+import type { Logger } from '@apollo/utils.logger';
+
+export function getDefaultLogger(debug: boolean = true): Logger {
+  const logger = loglevel.getLogger('apollo-gateway');
+
+  const level = debug === true ? loglevel.levels.DEBUG : loglevel.levels.WARN;
+  logger.setLevel(level);
+
+  return logger;
+}