@apollo/gateway 2.0.0-alpha.0 → 2.0.0-alpha.4

package/dist/index.js

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildOperationContext = exports.executeQueryPlan = exports.ApolloGateway = exports.SERVICE_DEFINITION_QUERY = exports.HEALTH_CHECK_QUERY = exports.GCS_RETRY_COUNT = exports.getDefaultGcsFetcher = exports.getDefaultFetcher = void 0;
+exports.LocalCompose = exports.IntrospectAndCompose = exports.buildOperationContext = exports.executeQueryPlan = exports.ApolloGateway = exports.SERVICE_DEFINITION_QUERY = exports.HEALTH_CHECK_QUERY = exports.getDefaultFetcher = void 0;
 const util_1 = require("util");
 const apollo_server_caching_1 = require("apollo-server-caching");
 const graphql_1 = require("graphql");
@@ -22,7 +22,6 @@ const operationContext_1 = require("./operationContext");
 Object.defineProperty(exports, "buildOperationContext", { enumerable: true, get: function () { return operationContext_1.buildOperationContext; } });
 const executeQueryPlan_1 = require("./executeQueryPlan");
 Object.defineProperty(exports, "executeQueryPlan", { enumerable: true, get: function () { return executeQueryPlan_1.executeQueryPlan; } });
-const loadServicesFromRemoteEndpoint_1 = require("./loadServicesFromRemoteEndpoint");
 const types_1 = require("./datasources/types");
 const RemoteGraphQLDataSource_1 = require("./datasources/RemoteGraphQLDataSource");
 const values_1 = require("graphql/execution/values");
@@ -30,12 +29,13 @@ const make_fetch_happen_1 = __importDefault(require("make-fetch-happen"));
 const cache_1 = require("./cache");
 const query_planner_1 = require("@apollo/query-planner");
 const config_1 = require("./config");
-const loadSupergraphSdlFromStorage_1 = require("./loadSupergraphSdlFromStorage");
-const legacyLoadServicesFromStorage_1 = require("./legacyLoadServicesFromStorage");
 const api_1 = require("@opentelemetry/api");
 const opentelemetry_1 = require("./utilities/opentelemetry");
+const createHash_1 = require("./utilities/createHash");
+const supergraphManagers_1 = require("./supergraphManagers");
+Object.defineProperty(exports, "IntrospectAndCompose", { enumerable: true, get: function () { return supergraphManagers_1.IntrospectAndCompose; } });
+Object.defineProperty(exports, "LocalCompose", { enumerable: true, get: function () { return supergraphManagers_1.LocalCompose; } });
 const federation_internals_1 = require("@apollo/federation-internals");
-const composition_1 = require("@apollo/composition");
 function getDefaultFetcher() {
     const { name, version } = require('../package.json');
     return make_fetch_happen_1.default.defaults({
@@ -55,19 +55,16 @@ function getDefaultFetcher() {
     });
 }
 exports.getDefaultFetcher = getDefaultFetcher;
-exports.getDefaultGcsFetcher = (0, util_1.deprecate)(getDefaultFetcher, `'getDefaultGcsFetcher' is deprecated. Use 'getDefaultFetcher' instead.`);
-exports.GCS_RETRY_COUNT = 5;
 exports.HEALTH_CHECK_QUERY = 'query __ApolloServiceHealthCheck__ { __typename }';
 exports.SERVICE_DEFINITION_QUERY = 'query __ApolloGetServiceDefinition__ { _service { sdl } }';
 class ApolloGateway {
     constructor(config) {
-        var _a, _b;
+        var _a;
         this.serviceMap = Object.create(null);
         this.onSchemaChangeListeners = new Set();
         this.onSchemaLoadOrUpdateListeners = new Set();
-        this.serviceDefinitions = [];
-        this.serviceSdlCache = new Map();
         this.warnedStates = Object.create(null);
+        this.toDispose = [];
         this.executor = async (requestContext) => {
             const spanAttributes = requestContext.operationName
                 ? { operationName: requestContext.operationName }
@@ -160,38 +157,12 @@ class ApolloGateway {
         this.fetcher = (config === null || config === void 0 ? void 0 : config.fetcher) || getDefaultFetcher();
         this.experimental_didResolveQueryPlan =
             config === null || config === void 0 ? void 0 : config.experimental_didResolveQueryPlan;
-        this.experimental_didFailComposition =
-            config === null || config === void 0 ? void 0 : config.experimental_didFailComposition;
-        this.experimental_didUpdateComposition =
-            config === null || config === void 0 ? void 0 : config.experimental_didUpdateComposition;
-        this.experimental_pollInterval = config === null || config === void 0 ? void 0 : config.experimental_pollInterval;
-        if ((0, config_1.isPrecomposedManagedConfig)(this.config)) {
-            const envEndpoint = process.env.APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT;
-            this.schemaConfigDeliveryEndpoint =
-                (_b = (_a = this.config.schemaConfigDeliveryEndpoint) !== null && _a !== void 0 ? _a : envEndpoint) !== null && _b !== void 0 ? _b : 'https://uplink.api.apollographql.com/';
-        }
-        else if ((0, config_1.isLegacyManagedConfig)(this.config)) {
-            this.schemaConfigDeliveryEndpoint = null;
-        }
-        if ((0, config_1.isManuallyManagedConfig)(this.config)) {
-            if ('experimental_updateSupergraphSdl' in this.config) {
-                this.updateServiceDefinitions =
-                    this.config.experimental_updateSupergraphSdl;
-            }
-            else if ('experimental_updateServiceDefinitions' in this.config) {
-                this.updateServiceDefinitions =
-                    this.config.experimental_updateServiceDefinitions;
-            }
-            else {
-                throw Error('Programming error: unexpected manual configuration provided');
-            }
-        }
-        else {
-            this.updateServiceDefinitions = this.loadServiceDefinitions;
-        }
-        if ((0, config_1.isDynamicConfig)(this.config)) {
-            this.issueDynamicWarningsIfApplicable();
-        }
+        this.experimental_didUpdateSupergraph =
+            config === null || config === void 0 ? void 0 : config.experimental_didUpdateSupergraph;
+        this.pollIntervalInMs =
+            (_a = config === null || config === void 0 ? void 0 : config.pollIntervalInMs) !== null && _a !== void 0 ? _a : config === null || config === void 0 ? void 0 : config.experimental_pollInterval;
+        this.issueConfigurationWarningsIfApplicable();
+        this.logger.debug('Gateway successfully initialized (but not yet loaded)');
         this.state = { phase: 'initialized' };
     }
     initLogger() {
@@ -213,18 +184,18 @@ class ApolloGateway {
             sizeCalculator: approximateObjectSize,
         });
     }
-    issueDynamicWarningsIfApplicable() {
+    issueConfigurationWarningsIfApplicable() {
         if ((0, config_1.isManagedConfig)(this.config) &&
-            this.config.experimental_pollInterval &&
-            this.config.experimental_pollInterval < 10000) {
-            this.experimental_pollInterval = 10000;
+            this.pollIntervalInMs &&
+            this.pollIntervalInMs < 10000) {
+            this.pollIntervalInMs = 10000;
             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 ' +
-                'experimental_pollInterval accordingly. If this is problematic for ' +
+                '`pollIntervalInMs` accordingly. If this is problematic for ' +
                 'your team, please contact support.');
         }
-        if (this.config.experimental_pollInterval && (0, config_1.isRemoteConfig)(this.config)) {
+        if (this.pollIntervalInMs && (0, config_1.isServiceListConfig)(this.config)) {
             this.logger.warn('Polling running services is dangerous and not recommended in production. ' +
                 'Polling should only be used against a registry. ' +
                 'If you are polling running services, use with caution.');
@@ -237,8 +208,16 @@ class ApolloGateway {
                 'function when both `experimental_updateSupergraphSdl` and experimental_updateServiceDefinitions` ' +
                 'are provided.');
         }
+        if ('schemaConfigDeliveryEndpoint' in this.config) {
+            this.logger.warn('The `schemaConfigDeliveryEndpoint` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to the equivalent (array form) `uplinkEndpoints` configuration option.');
+        }
+        if ('experimental_pollInterval' in this.config) {
+            this.logger.warn('The `experimental_pollInterval` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to the equivalent `pollIntervalInMs` configuration option.');
+        }
     }
     async load(options) {
+        var _a, _b, _c, _d;
+        this.logger.debug('Loading gateway...');
         if (this.state.phase !== 'initialized') {
             throw Error(`ApolloGateway.load called in surprising state ${this.state.phase}`);
         }
@@ -259,11 +238,72 @@ class ApolloGateway {
                     : undefined,
             };
         }
-        const unrefTimer = !!options && !options.apollo;
         this.maybeWarnOnConflictingConfig();
-        (0, config_1.isStaticConfig)(this.config)
-            ? this.loadStatic(this.config)
-            : await this.loadDynamic(unrefTimer);
+        if ((0, config_1.isStaticSupergraphSdlConfig)(this.config)) {
+            const supergraphSdl = this.config.supergraphSdl;
+            await this.initializeSupergraphManager({
+                initialize: async () => {
+                    return {
+                        supergraphSdl,
+                    };
+                },
+            });
+        }
+        else if ((0, config_1.isLocalConfig)(this.config)) {
+            await this.initializeSupergraphManager(new supergraphManagers_1.LocalCompose({
+                localServiceList: this.config.localServiceList,
+                logger: this.logger,
+            }));
+        }
+        else if ((0, config_1.isManuallyManagedSupergraphSdlGatewayConfig)(this.config)) {
+            const supergraphManager = typeof this.config.supergraphSdl === 'object'
+                ? this.config.supergraphSdl
+                : { initialize: this.config.supergraphSdl };
+            await this.initializeSupergraphManager(supergraphManager);
+        }
+        else if ('experimental_updateServiceDefinitions' in this.config ||
+            'experimental_updateSupergraphSdl' in this.config) {
+            const updateServiceDefinitions = 'experimental_updateServiceDefinitions' in this.config
+                ? this.config.experimental_updateServiceDefinitions
+                : this.config.experimental_updateSupergraphSdl;
+            await this.initializeSupergraphManager(new supergraphManagers_1.LegacyFetcher({
+                logger: this.logger,
+                gatewayConfig: this.config,
+                updateServiceDefinitions,
+                pollIntervalInMs: this.pollIntervalInMs,
+                subgraphHealthCheck: this.config.serviceHealthCheck,
+            }));
+        }
+        else if ((0, config_1.isServiceListConfig)(this.config)) {
+            this.logger.warn('The `serviceList` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to its replacement `IntrospectAndCompose`. More information on `IntrospectAndCompose` can be found in the documentation.');
+            await this.initializeSupergraphManager(new supergraphManagers_1.IntrospectAndCompose({
+                subgraphs: this.config.serviceList,
+                pollIntervalInMs: this.pollIntervalInMs,
+                logger: this.logger,
+                subgraphHealthCheck: this.config.serviceHealthCheck,
+                introspectionHeaders: this.config.introspectionHeaders,
+            }));
+        }
+        else {
+            const canUseManagedConfig = ((_a = this.apolloConfig) === null || _a === void 0 ? void 0 : _a.graphRef) && ((_b = this.apolloConfig) === null || _b === void 0 ? void 0 : _b.keyHash);
+            if (!canUseManagedConfig) {
+                throw new Error('When a manual configuration is not provided, gateway requires an Apollo ' +
+                    'configuration. See https://www.apollographql.com/docs/apollo-server/federation/managed-federation/ ' +
+                    'for more information. Manual configuration options include: ' +
+                    '`serviceList`, `supergraphSdl`, and `experimental_updateServiceDefinitions`.');
+            }
+            const uplinkEndpoints = this.getUplinkEndpoints(this.config);
+            await this.initializeSupergraphManager(new supergraphManagers_1.UplinkFetcher({
+                graphRef: this.apolloConfig.graphRef,
+                apiKey: this.apolloConfig.key,
+                uplinkEndpoints,
+                maxRetries: (_c = this.config.uplinkMaxRetries) !== null && _c !== void 0 ? _c : uplinkEndpoints.length * 3,
+                subgraphHealthCheck: this.config.serviceHealthCheck,
+                fetcher: this.fetcher,
+                logger: this.logger,
+                pollIntervalInMs: (_d = this.pollIntervalInMs) !== null && _d !== void 0 ? _d : 10000,
+            }));
+        }
         const mode = (0, config_1.isManagedConfig)(this.config) ? 'managed' : 'unmanaged';
         this.logger.info(`Gateway successfully loaded schema.\n\t* Mode: ${mode}${this.apolloConfig && this.apolloConfig.graphRef
             ? `\n\t* Service: ${this.apolloConfig.graphRef}`
@@ -273,92 +313,97 @@ class ApolloGateway {
             executor: this.executor,
         };
     }
-    loadStatic(config) {
-        let schema;
-        let supergraphSdl;
-        try {
-            ({ schema, supergraphSdl } = (0, config_1.isLocalConfig)(config)
-                ? this.createSchemaFromServiceList(config.localServiceList)
-                : this.createSchemaFromSupergraphSdl(config.supergraphSdl));
-            this.supergraphSdl = supergraphSdl;
-            this.updateWithSchemaAndNotify(schema, supergraphSdl, true);
-        }
-        catch (e) {
-            this.state = { phase: 'failed to load' };
-            throw e;
-        }
-        this.state = { phase: 'loaded' };
+    getUplinkEndpoints(config) {
+        var _a, _b, _c, _d;
+        const rawEndpointsString = process.env.APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT;
+        const envEndpoints = (_a = rawEndpointsString === null || rawEndpointsString === void 0 ? void 0 : rawEndpointsString.split(',')) !== null && _a !== void 0 ? _a : null;
+        return ((_d = (_c = (_b = config.uplinkEndpoints) !== null && _b !== void 0 ? _b : (config.schemaConfigDeliveryEndpoint
+            ? [config.schemaConfigDeliveryEndpoint]
+            : null)) !== null && _c !== void 0 ? _c : envEndpoints) !== null && _d !== void 0 ? _d : [
+            'https://uplink.api.apollographql.com/',
+            'https://aws.uplink.api.apollographql.com/',
+        ]);
     }
-    async loadDynamic(unrefTimer) {
+    getIdForSupergraphSdl(supergraphSdl) {
+        return (0, createHash_1.createHash)('sha256').update(supergraphSdl).digest('hex');
+    }
+    async initializeSupergraphManager(supergraphManager) {
         try {
-            await this.updateSchema();
+            const result = await supergraphManager.initialize({
+                update: this.externalSupergraphUpdateCallback.bind(this),
+                healthCheck: this.externalSubgraphHealthCheckCallback.bind(this),
+                getDataSource: this.externalGetDataSourceCallback.bind(this),
+            });
+            if (!(result === null || result === void 0 ? void 0 : result.supergraphSdl)) {
+                throw new Error('Provided `supergraphSdl` function did not return an object containing a `supergraphSdl` property');
+            }
+            if (result === null || result === void 0 ? void 0 : result.cleanup) {
+                if (typeof result.cleanup === 'function') {
+                    this.toDispose.push(result.cleanup);
+                }
+                else {
+                    this.logger.error('Provided `supergraphSdl` function returned an invalid `cleanup` property (must be a function)');
+                }
+            }
+            this.externalSupergraphUpdateCallback(result.supergraphSdl);
         }
         catch (e) {
             this.state = { phase: 'failed to load' };
+            await this.performCleanupAndLogErrors();
             throw e;
         }
         this.state = { phase: 'loaded' };
-        if (this.shouldBeginPolling()) {
-            this.pollServices(unrefTimer);
-        }
     }
-    shouldBeginPolling() {
-        return (0, config_1.isManagedConfig)(this.config) || this.experimental_pollInterval;
-    }
-    async updateSchema() {
-        this.logger.debug('Checking for composition updates...');
-        const result = await this.updateServiceDefinitions(this.config);
-        if ((0, config_1.isSupergraphSdlUpdate)(result)) {
-            await this.updateWithSupergraphSdl(result);
+    externalSupergraphUpdateCallback(supergraphSdl) {
+        switch (this.state.phase) {
+            case 'failed to load':
+                throw new Error("Can't call `update` callback after gateway failed to load.");
+            case 'updating schema':
+                throw new Error("Can't call `update` callback while supergraph update is in progress.");
+            case 'stopped':
+                throw new Error("Can't call `update` callback after gateway has been stopped.");
+            case 'stopping':
+                throw new Error("Can't call `update` callback while gateway is stopping.");
+            case 'loaded':
+            case 'initialized':
+                break;
+            default:
+                throw new UnreachableCaseError(this.state);
         }
-        else if ((0, config_1.isServiceDefinitionUpdate)(result)) {
-            await this.updateByComposition(result);
+        this.state = { phase: 'updating schema' };
+        try {
+            this.updateWithSupergraphSdl({
+                supergraphSdl,
+                id: this.getIdForSupergraphSdl(supergraphSdl),
+            });
         }
-        else {
-            throw new Error('Programming error: unexpected result type from `updateServiceDefinitions`');
+        finally {
+            this.state = { phase: 'loaded' };
         }
     }
-    async updateByComposition(result) {
-        if (!result.serviceDefinitions ||
-            JSON.stringify(this.serviceDefinitions) ===
-                JSON.stringify(result.serviceDefinitions)) {
-            this.logger.debug('No change in service definitions since last check.');
-            return;
-        }
-        const previousSchema = this.schema;
-        const previousServiceDefinitions = this.serviceDefinitions;
-        const previousCompositionMetadata = this.compositionMetadata;
-        if (previousSchema) {
-            this.logger.info('New service definitions were found.');
-        }
-        await this.maybePerformServiceHealthCheck(result);
-        this.compositionMetadata = result.compositionMetadata;
-        this.serviceDefinitions = result.serviceDefinitions;
-        const { schema, supergraphSdl } = this.createSchemaFromServiceList(result.serviceDefinitions);
-        if (!supergraphSdl) {
-            this.logger.error("A valid schema couldn't be composed. Falling back to previous schema.");
+    async externalSubgraphHealthCheckCallback(supergraphSdl) {
+        const serviceList = this.serviceListFromSupergraphSdl(supergraphSdl);
+        const serviceMap = serviceList.reduce((serviceMap, serviceDef) => {
+            serviceMap[serviceDef.name] = {
+                url: serviceDef.url,
+                dataSource: this.createDataSource(serviceDef),
+            };
+            return serviceMap;
+        }, Object.create(null));
+        try {
+            await this.serviceHealthCheck(serviceMap);
         }
-        else {
-            this.updateWithSchemaAndNotify(schema, supergraphSdl);
-            if (this.experimental_didUpdateComposition) {
-                this.experimental_didUpdateComposition({
-                    serviceDefinitions: result.serviceDefinitions,
-                    schema: schema.toGraphQLJSSchema(),
-                    ...(this.compositionMetadata && {
-                        compositionMetadata: this.compositionMetadata,
-                    }),
-                }, previousServiceDefinitions &&
-                    previousSchema && {
-                    serviceDefinitions: previousServiceDefinitions,
-                    schema: previousSchema,
-                    ...(previousCompositionMetadata && {
-                        compositionMetadata: previousCompositionMetadata,
-                    }),
-                });
-            }
+        catch (e) {
+            throw new 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' +
+                e.message);
         }
     }
-    async updateWithSupergraphSdl(result) {
+    externalGetDataSourceCallback({ name, url, }) {
+        return this.getOrCreateDataSource({ name, url });
+    }
+    updateWithSupergraphSdl(result) {
         if (result.id === this.compositionId) {
             this.logger.debug('No change in composition since last check.');
             return;
@@ -370,18 +415,17 @@ class ApolloGateway {
         if (previousSchema) {
             this.logger.info('Updated Supergraph SDL was found.');
         }
-        await this.maybePerformServiceHealthCheck(result);
         this.compositionId = result.id;
-        this.supergraphSdl = result.supergraphSdl;
+        this.supergraphSdl = supergraphSdl;
         if (!supergraphSdl) {
             this.logger.error("A valid schema couldn't be composed. Falling back to previous schema.");
         }
         else {
             this.updateWithSchemaAndNotify(schema, supergraphSdl);
-            if (this.experimental_didUpdateComposition) {
-                this.experimental_didUpdateComposition({
+            if (this.experimental_didUpdateSupergraph) {
+                this.experimental_didUpdateSupergraph({
                     compositionId: result.id,
-                    supergraphSdl: result.supergraphSdl,
+                    supergraphSdl,
                     schema: schema.toGraphQLJSSchema(),
                 }, previousCompositionId && previousSupergraphSdl && previousSchema
                     ? {
@@ -425,31 +469,6 @@ class ApolloGateway {
             }
         });
     }
-    async maybePerformServiceHealthCheck(update) {
-        if (this.config.serviceHealthCheck) {
-            const serviceList = (0, config_1.isSupergraphSdlUpdate)(update)
-                ?
-                    this.serviceListFromSupergraphSdl(update.supergraphSdl)
-                :
-                    update.serviceDefinitions;
-            const serviceMap = serviceList.reduce((serviceMap, serviceDef) => {
-                serviceMap[serviceDef.name] = {
-                    url: serviceDef.url,
-                    dataSource: this.createDataSource(serviceDef),
-                };
-                return serviceMap;
-            }, Object.create(null));
-            try {
-                await this.serviceHealthCheck(serviceMap);
-            }
-            catch (e) {
-                throw new Error('The gateway did not update its schema due to failed service health checks. ' +
-                    'The gateway will continue to operate with the previous schema and reattempt updates. ' +
-                    'The following error occurred during the health check:\n' +
-                    e.message);
-            }
-        }
-    }
     serviceHealthCheck(serviceMap = this.serviceMap) {
         return Promise.all(Object.entries(serviceMap).map(([name, { dataSource }]) => dataSource
             .process({
@@ -462,34 +481,6 @@ class ApolloGateway {
             throw new Error(`[${name}]: ${e.message}`);
         })));
     }
-    createSchemaFromServiceList(serviceList) {
-        this.logger.debug(`Composing schema from service list: \n${serviceList
-            .map(({ name, url }) => `  ${url || 'local'}: ${name}`)
-            .join('\n')}`);
-        const compositionResult = (0, composition_1.composeServices)(serviceList);
-        const errors = compositionResult.errors;
-        if (errors) {
-            if (this.experimental_didFailComposition) {
-                this.experimental_didFailComposition({
-                    errors,
-                    serviceList,
-                    ...(this.compositionMetadata && {
-                        compositionMetadata: this.compositionMetadata,
-                    }),
-                });
-            }
-            throw Error("A valid schema couldn't be composed. The following composition errors were found:\n" +
-                errors.map((e) => '\t' + e.message).join('\n'));
-        }
-        else {
-            this.createServices(serviceList);
-            this.logger.debug('Schema loaded and ready for execution');
-            return {
-                schema: compositionResult.schema,
-                supergraphSdl: compositionResult.supergraphSdl,
-            };
-        }
-    }
     serviceListFromSupergraphSdl(supergraphSdl) {
         return (0, federation_internals_1.buildSupergraphSchema)(supergraphSdl)[1];
     }
@@ -513,63 +504,11 @@ class ApolloGateway {
             this.onSchemaLoadOrUpdateListeners.delete(callback);
         };
     }
-    async pollServices(unrefTimer) {
-        switch (this.state.phase) {
-            case 'stopping':
-            case 'stopped':
-            case 'failed to load':
-                return;
-            case 'initialized':
-                throw Error('pollServices should not be called before load!');
-            case 'polling':
-                throw Error('pollServices should not be called while in the middle of polling!');
-            case 'waiting to poll':
-                throw Error('pollServices should not be called while already waiting to poll!');
-            case 'loaded':
-                break;
-            default:
-                throw new UnreachableCaseError(this.state);
-        }
-        await new Promise((doneWaiting) => {
-            this.state = {
-                phase: 'waiting to poll',
-                doneWaiting,
-                pollWaitTimer: setTimeout(() => {
-                    if (this.state.phase == 'waiting to poll') {
-                        this.state.doneWaiting();
-                    }
-                }, this.experimental_pollInterval || 10000),
-            };
-            if (unrefTimer) {
-                this.state.pollWaitTimer.unref();
-            }
-        });
-        if (this.state.phase !== 'waiting to poll') {
-            return;
-        }
-        let pollingDone;
-        this.state = {
-            phase: 'polling',
-            pollingDonePromise: new Promise((res) => {
-                pollingDone = res;
-            }),
-        };
-        try {
-            await this.updateSchema();
-        }
-        catch (err) {
-            this.logger.error((err && err.message) || err);
-        }
-        if (this.state.phase === 'polling') {
-            this.state = { phase: 'loaded' };
-            setImmediate(() => this.pollServices(unrefTimer));
-        }
-        pollingDone();
-    }
-    createAndCacheDataSource(serviceDef) {
+    getOrCreateDataSource(serviceDef) {
         if (this.serviceMap[serviceDef.name] &&
-            serviceDef.url === this.serviceMap[serviceDef.name].url)
+            serviceDef.url === this.serviceMap[serviceDef.name].url) {
             return this.serviceMap[serviceDef.name].dataSource;
+        }
         const dataSource = this.createDataSource(serviceDef);
         this.serviceMap[serviceDef.name] = { url: serviceDef.url, dataSource };
         return dataSource;
@@ -586,51 +525,7 @@ class ApolloGateway {
     }
     createServices(services) {
         for (const serviceDef of services) {
-            this.createAndCacheDataSource(serviceDef);
-        }
-    }
-    async loadServiceDefinitions(config) {
-        var _a, _b;
-        if ((0, config_1.isRemoteConfig)(config)) {
-            const serviceList = config.serviceList.map((serviceDefinition) => ({
-                ...serviceDefinition,
-                dataSource: this.createAndCacheDataSource(serviceDefinition),
-            }));
-            return (0, loadServicesFromRemoteEndpoint_1.getServiceDefinitionsFromRemoteEndpoint)({
-                serviceList,
-                async getServiceIntrospectionHeaders(service) {
-                    return typeof config.introspectionHeaders === 'function'
-                        ? await config.introspectionHeaders(service)
-                        : config.introspectionHeaders;
-                },
-                serviceSdlCache: this.serviceSdlCache,
-            });
-        }
-        const canUseManagedConfig = ((_a = this.apolloConfig) === null || _a === void 0 ? void 0 : _a.graphRef) && ((_b = this.apolloConfig) === null || _b === void 0 ? void 0 : _b.keyHash);
-        if (!canUseManagedConfig) {
-            throw new Error('When a manual configuration is not provided, gateway requires an Apollo ' +
-                'configuration. See https://www.apollographql.com/docs/apollo-server/federation/managed-federation/ ' +
-                'for more information. Manual configuration options include: ' +
-                '`serviceList`, `supergraphSdl`, and `experimental_updateServiceDefinitions`.');
-        }
-        if ((0, config_1.isPrecomposedManagedConfig)(config)) {
-            return (0, loadSupergraphSdlFromStorage_1.loadSupergraphSdlFromStorage)({
-                graphRef: this.apolloConfig.graphRef,
-                apiKey: this.apolloConfig.key,
-                endpoint: this.schemaConfigDeliveryEndpoint,
-                fetcher: this.fetcher,
-            });
-        }
-        else if ((0, config_1.isLegacyManagedConfig)(config)) {
-            return (0, legacyLoadServicesFromStorage_1.getServiceDefinitionsFromStorage)({
-                graphRef: this.apolloConfig.graphRef,
-                apiKeyHash: this.apolloConfig.keyHash,
-                federationVersion: config.federationVersion || 1,
-                fetcher: this.fetcher,
-            });
-        }
-        else {
-            throw new Error('Programming error: unhandled configuration');
+            this.getOrCreateDataSource(serviceDef);
         }
     }
     maybeWarnOnConflictingConfig() {
@@ -667,6 +562,16 @@ class ApolloGateway {
             }
         });
     }
+    async performCleanupAndLogErrors() {
+        if (this.toDispose.length === 0)
+            return;
+        await Promise.all(this.toDispose.map((p) => p().catch((e) => {
+            var _a;
+            this.logger.error('Error occured while calling user provided `cleanup` function: ' +
+                ((_a = e.message) !== null && _a !== void 0 ? _a : e));
+        })));
+        this.toDispose = [];
+    }
     async stop() {
         switch (this.state.phase) {
             case 'initialized':
@@ -681,33 +586,28 @@ class ApolloGateway {
                 }
                 return;
             case 'loaded':
-                this.state = { phase: 'stopped' };
-                return;
-            case 'waiting to poll': {
-                const doneWaiting = this.state.doneWaiting;
-                clearTimeout(this.state.pollWaitTimer);
-                this.state = { phase: 'stopped' };
-                doneWaiting();
-                return;
-            }
-            case 'polling': {
-                const pollingDonePromise = this.state.pollingDonePromise;
-                let stoppingDone;
+                const stoppingDonePromise = this.performCleanupAndLogErrors();
                 this.state = {
                     phase: 'stopping',
-                    stoppingDonePromise: new Promise((res) => {
-                        stoppingDone = res;
-                    }),
+                    stoppingDonePromise,
                 };
-                await pollingDonePromise;
+                await stoppingDonePromise;
                 this.state = { phase: 'stopped' };
-                stoppingDone();
                 return;
+            case 'updating schema': {
+                throw Error("`ApolloGateway.stop` shouldn't be called from inside a schema change listener");
             }
             default:
                 throw new UnreachableCaseError(this.state);
         }
     }
+    __testing() {
+        return {
+            state: this.state,
+            compositionId: this.compositionId,
+            supergraphSdl: this.supergraphSdl,
+        };
+    }
 }
 exports.ApolloGateway = ApolloGateway;
 ApolloGateway.prototype.onSchemaChange = (0, util_1.deprecate)(ApolloGateway.prototype.onSchemaChange, `'ApolloGateway.prototype.onSchemaChange' is deprecated. Use 'ApolloGateway.prototype.onSchemaLoadOrUpdate' instead.`);