@apollo/gateway 0.300.0-alpha.2 → 2.0.0-alpha.2

package/dist/index.js

@@ -7,199 +7,312 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     o[k2] = m[k];
 }));
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildOperationContext = exports.serializeQueryPlan = exports.executeQueryPlan = exports.buildQueryPlan = exports.ApolloGateway = exports.SERVICE_DEFINITION_QUERY = exports.HEALTH_CHECK_QUERY = exports.getDefaultGcsFetcher = exports.GCS_RETRY_COUNT = void 0;
+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");
-const apollo_graphql_1 = require("apollo-graphql");
-const federation_1 = require("@apollo/federation");
 const loglevel_1 = __importDefault(require("loglevel"));
-const buildQueryPlan_1 = require("./buildQueryPlan");
-Object.defineProperty(exports, "buildQueryPlan", { enumerable: true, get: function () { return buildQueryPlan_1.buildQueryPlan; } });
-Object.defineProperty(exports, "buildOperationContext", { enumerable: true, get: function () { return buildQueryPlan_1.buildOperationContext; } });
+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 loadServicesFromStorage_1 = require("./loadServicesFromStorage");
-const QueryPlan_1 = require("./QueryPlan");
-Object.defineProperty(exports, "serializeQueryPlan", { enumerable: true, get: function () { return QueryPlan_1.serializeQueryPlan; } });
+const types_1 = require("./datasources/types");
 const RemoteGraphQLDataSource_1 = require("./datasources/RemoteGraphQLDataSource");
 const values_1 = require("graphql/execution/values");
 const make_fetch_happen_1 = __importDefault(require("make-fetch-happen"));
 const cache_1 = require("./cache");
-function isLocalConfig(config) {
-    return 'localServiceList' in config;
-}
-function isRemoteConfig(config) {
-    return 'serviceList' in config;
-}
-function isManagedConfig(config) {
-    return !isRemoteConfig(config) && !isLocalConfig(config);
-}
-exports.GCS_RETRY_COUNT = 5;
-function getDefaultGcsFetcher() {
+const query_planner_1 = require("@apollo/query-planner");
+const config_1 = require("./config");
+const loadSupergraphSdlFromStorage_1 = require("./loadSupergraphSdlFromStorage");
+const api_1 = require("@opentelemetry/api");
+const opentelemetry_1 = require("./utilities/opentelemetry");
+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({
         cacheManager: new cache_1.HttpRequestCache(),
         headers: {
-            'user-agent': `apollo-gateway/${require('../package.json').version}`,
+            'apollographql-client-name': name,
+            'apollographql-client-version': version,
+            'user-agent': `${name}/${version}`,
+            'content-type': 'application/json',
         },
         retry: {
-            retries: exports.GCS_RETRY_COUNT,
+            retries: 5,
             factor: 2,
             minTimeout: 1000,
             randomize: true,
         },
     });
 }
-exports.getDefaultGcsFetcher = getDefaultGcsFetcher;
+exports.getDefaultFetcher = getDefaultFetcher;
 exports.HEALTH_CHECK_QUERY = 'query __ApolloServiceHealthCheck__ { __typename }';
 exports.SERVICE_DEFINITION_QUERY = 'query __ApolloGetServiceDefinition__ { _service { sdl } }';
 class ApolloGateway {
     constructor(config) {
+        var _a, _b;
         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.fetcher = getDefaultGcsFetcher();
         this.executor = async (requestContext) => {
-            const { request, document, queryHash } = requestContext;
-            const queryPlanStoreKey = queryHash + (request.operationName || '');
-            const operationContext = buildQueryPlan_1.buildOperationContext(this.schema, document, request.operationName);
-            const validationErrors = this.validateIncomingRequest(requestContext, operationContext);
-            if (validationErrors.length > 0) {
-                return { errors: validationErrors };
-            }
-            let queryPlan;
-            if (this.queryPlanStore) {
-                queryPlan = await this.queryPlanStore.get(queryPlanStoreKey);
-            }
-            if (!queryPlan) {
-                queryPlan = buildQueryPlan_1.buildQueryPlan(operationContext, {
-                    autoFragmentization: Boolean(this.config.experimental_autoFragmentization),
-                });
-                if (this.queryPlanStore) {
-                    Promise.resolve(this.queryPlanStore.set(queryPlanStoreKey, queryPlan)).catch(err => this.logger.warn('Could not store queryPlan' + ((err && err.message) || err)));
+            const spanAttributes = requestContext.operationName
+                ? { operationName: requestContext.operationName }
+                : {};
+            return opentelemetry_1.tracer.startActiveSpan(opentelemetry_1.OpenTelemetrySpanNames.REQUEST, { attributes: spanAttributes }, async (span) => {
+                try {
+                    const { request, document, queryHash } = requestContext;
+                    const queryPlanStoreKey = queryHash + (request.operationName || '');
+                    const operationContext = (0, operationContext_1.buildOperationContext)({
+                        schema: this.schema,
+                        operationDocument: document,
+                        operationName: request.operationName,
+                    });
+                    const validationErrors = this.validateIncomingRequest(requestContext, operationContext);
+                    if (validationErrors.length > 0) {
+                        span.setStatus({ code: api_1.SpanStatusCode.ERROR });
+                        return { errors: validationErrors };
+                    }
+                    let queryPlan;
+                    if (this.queryPlanStore) {
+                        queryPlan = await this.queryPlanStore.get(queryPlanStoreKey);
+                    }
+                    if (!queryPlan) {
+                        queryPlan = opentelemetry_1.tracer.startActiveSpan(opentelemetry_1.OpenTelemetrySpanNames.PLAN, (span) => {
+                            try {
+                                const operation = (0, federation_internals_1.operationFromDocument)(this.apiSchema, document, request.operationName);
+                                return this.queryPlanner.buildQueryPlan(operation);
+                            }
+                            catch (err) {
+                                span.setStatus({ code: api_1.SpanStatusCode.ERROR });
+                                throw err;
+                            }
+                            finally {
+                                span.end();
+                            }
+                        });
+                        if (this.queryPlanStore) {
+                            Promise.resolve(this.queryPlanStore.set(queryPlanStoreKey, queryPlan)).catch((err) => this.logger.warn('Could not store queryPlan' + ((err && err.message) || err)));
+                        }
+                    }
+                    const serviceMap = Object.entries(this.serviceMap).reduce((serviceDataSources, [serviceName, { dataSource }]) => {
+                        serviceDataSources[serviceName] = dataSource;
+                        return serviceDataSources;
+                    }, Object.create(null));
+                    if (this.experimental_didResolveQueryPlan) {
+                        this.experimental_didResolveQueryPlan({
+                            queryPlan,
+                            serviceMap,
+                            requestContext,
+                            operationContext,
+                        });
+                    }
+                    const response = await (0, executeQueryPlan_1.executeQueryPlan)(queryPlan, serviceMap, requestContext, operationContext);
+                    const shouldShowQueryPlan = this.config.__exposeQueryPlanExperimental &&
+                        request.http &&
+                        request.http.headers &&
+                        request.http.headers.get('Apollo-Query-Plan-Experimental');
+                    const serializedQueryPlan = queryPlan.node && (this.config.debug || shouldShowQueryPlan)
+                        ?
+                            (0, query_planner_1.prettyFormatQueryPlan)(queryPlan)
+                        : null;
+                    if (this.config.debug && serializedQueryPlan) {
+                        this.logger.debug(serializedQueryPlan);
+                    }
+                    if (shouldShowQueryPlan) {
+                        response.extensions = {
+                            __queryPlanExperimental: serializedQueryPlan || true,
+                        };
+                    }
+                    if (response.errors) {
+                        span.setStatus({ code: api_1.SpanStatusCode.ERROR });
+                    }
+                    return response;
                 }
-            }
-            const serviceMap = Object.entries(this.serviceMap).reduce((serviceDataSources, [serviceName, { dataSource }]) => {
-                serviceDataSources[serviceName] = dataSource;
-                return serviceDataSources;
-            }, Object.create(null));
-            if (this.experimental_didResolveQueryPlan) {
-                this.experimental_didResolveQueryPlan({
-                    queryPlan,
-                    serviceMap,
-                    requestContext,
-                    operationContext,
-                });
-            }
-            const response = await executeQueryPlan_1.executeQueryPlan(queryPlan, serviceMap, requestContext, operationContext);
-            const shouldShowQueryPlan = this.config.__exposeQueryPlanExperimental &&
-                request.http &&
-                request.http.headers &&
-                request.http.headers.get('Apollo-Query-Plan-Experimental');
-            const serializedQueryPlan = queryPlan.node && (this.config.debug || shouldShowQueryPlan)
-                ? QueryPlan_1.serializeQueryPlan(queryPlan)
-                : null;
-            if (this.config.debug && serializedQueryPlan) {
-                this.logger.debug(serializedQueryPlan);
-            }
-            if (shouldShowQueryPlan) {
-                response.extensions = {
-                    __queryPlanExperimental: serializedQueryPlan || true,
-                };
-            }
-            return response;
+                catch (err) {
+                    span.setStatus({ code: api_1.SpanStatusCode.ERROR });
+                    throw err;
+                }
+                finally {
+                    span.end();
+                }
+            });
         };
         this.config = {
             __exposeQueryPlanExperimental: process.env.NODE_ENV !== 'production',
             ...config,
         };
-        if (this.config.logger) {
-            this.logger = this.config.logger;
+        this.logger = this.initLogger();
+        this.queryPlanStore = this.initQueryPlanStore(config === null || config === void 0 ? void 0 : config.experimental_approximateQueryPlanStoreMiB);
+        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.isManagedConfig)(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 {
-            const loglevelLogger = loglevel_1.default.getLogger(`apollo-gateway`);
-            if (this.config.debug === true) {
-                loglevelLogger.setLevel(loglevelLogger.levels.DEBUG);
+        if ((0, config_1.isManuallyManagedConfig)(this.config)) {
+            if ('experimental_updateSupergraphSdl' in this.config) {
+                this.updateServiceDefinitions =
+                    this.config.experimental_updateSupergraphSdl;
             }
-            else {
-                loglevelLogger.setLevel(loglevelLogger.levels.WARN);
-            }
-            this.logger = loglevelLogger;
-        }
-        if (isLocalConfig(this.config)) {
-            this.schema = this.createSchema(this.config.localServiceList);
-        }
-        this.initializeQueryPlanStore();
-        this.updateServiceDefinitions = this.loadServiceDefinitions;
-        if (config) {
-            this.updateServiceDefinitions =
-                config.experimental_updateServiceDefinitions ||
-                    this.updateServiceDefinitions;
-            this.experimental_didResolveQueryPlan =
-                config.experimental_didResolveQueryPlan;
-            this.experimental_didFailComposition =
-                config.experimental_didFailComposition;
-            this.experimental_didUpdateComposition =
-                config.experimental_didUpdateComposition;
-            this.experimental_approximateQueryPlanStoreMiB =
-                config.experimental_approximateQueryPlanStoreMiB;
-            if (isManagedConfig(config) &&
-                config.experimental_pollInterval &&
-                config.experimental_pollInterval < 10000) {
-                this.experimental_pollInterval = 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 your team, please contact support.');
+            else if ('experimental_updateServiceDefinitions' in this.config) {
+                this.updateServiceDefinitions =
+                    this.config.experimental_updateServiceDefinitions;
             }
             else {
-                this.experimental_pollInterval = config.experimental_pollInterval;
-            }
-            if (config.experimental_pollInterval && isRemoteConfig(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.');
-            }
-            if (config.fetcher) {
-                this.fetcher = config.fetcher;
+                throw Error('Programming error: unexpected manual configuration provided');
             }
         }
+        else {
+            this.updateServiceDefinitions = this.loadServiceDefinitions;
+        }
+        if ((0, config_1.isDynamicConfig)(this.config)) {
+            this.issueDynamicWarningsIfApplicable();
+        }
+        this.state = { phase: 'initialized' };
+    }
+    initLogger() {
+        if (this.config.logger) {
+            return this.config.logger;
+        }
+        const loglevelLogger = loglevel_1.default.getLogger(`apollo-gateway`);
+        if (this.config.debug === true) {
+            loglevelLogger.setLevel(loglevelLogger.levels.DEBUG);
+        }
+        else {
+            loglevelLogger.setLevel(loglevelLogger.levels.WARN);
+        }
+        return loglevelLogger;
+    }
+    initQueryPlanStore(approximateQueryPlanStoreMiB) {
+        return new apollo_server_caching_1.InMemoryLRUCache({
+            maxSize: Math.pow(2, 20) * (approximateQueryPlanStoreMiB || 30),
+            sizeCalculator: approximateObjectSize,
+        });
+    }
+    issueDynamicWarningsIfApplicable() {
+        if ((0, config_1.isManagedConfig)(this.config) &&
+            this.config.experimental_pollInterval &&
+            this.config.experimental_pollInterval < 10000) {
+            this.experimental_pollInterval = 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 ' +
+                'your team, please contact support.');
+        }
+        if (this.config.experimental_pollInterval && (0, config_1.isRemoteConfig)(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.');
+        }
+        if ((0, config_1.isManuallyManagedConfig)(this.config) &&
+            'experimental_updateSupergraphSdl' in this.config &&
+            'experimental_updateServiceDefinitions' in this.config) {
+            this.logger.warn('Gateway found two manual update configurations when only one should be ' +
+                'provided. Gateway will default to using the provided `experimental_updateSupergraphSdl` ' +
+                'function when both `experimental_updateSupergraphSdl` and experimental_updateServiceDefinitions` ' +
+                'are provided.');
+        }
     }
     async load(options) {
-        if (options && options.engine) {
-            if (!options.engine.graphVariant)
-                this.logger.warn('No graph variant provided. Defaulting to `current`.');
-            this.engineConfig = options.engine;
-        }
-        await this.updateComposition();
-        if ((isManagedConfig(this.config) || this.experimental_pollInterval) &&
-            !this.pollingTimer) {
-            this.pollServices();
-        }
-        const { graphId, graphVariant } = (options && options.engine) || {};
-        const mode = isManagedConfig(this.config) ? 'managed' : 'unmanaged';
-        this.logger.info(`Gateway successfully loaded schema.\n\t* Mode: ${mode}${graphId ? `\n\t* Service: ${graphId}@${graphVariant || 'current'}` : ''}`);
+        if (this.state.phase !== 'initialized') {
+            throw Error(`ApolloGateway.load called in surprising state ${this.state.phase}`);
+        }
+        if (options === null || options === void 0 ? void 0 : options.apollo) {
+            const { key, keyHash, graphRef, graphId, graphVariant } = options.apollo;
+            this.apolloConfig = {
+                key,
+                keyHash,
+                graphRef: graphRef !== null && graphRef !== void 0 ? graphRef : (graphId ? `${graphId}@${graphVariant !== null && graphVariant !== void 0 ? graphVariant : 'current'}` : undefined),
+            };
+        }
+        else if (options === null || options === void 0 ? void 0 : options.engine) {
+            const { apiKeyHash, graphId, graphVariant } = options.engine;
+            this.apolloConfig = {
+                keyHash: apiKeyHash,
+                graphRef: graphId
+                    ? `${graphId}@${graphVariant !== null && graphVariant !== void 0 ? graphVariant : 'current'}`
+                    : undefined,
+            };
+        }
+        const unrefTimer = !!options && !options.apollo;
+        this.maybeWarnOnConflictingConfig();
+        (0, config_1.isStaticConfig)(this.config)
+            ? this.loadStatic(this.config)
+            : await this.loadDynamic(unrefTimer);
+        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}`
+            : ''}`);
         return {
             schema: this.schema,
             executor: this.executor,
         };
     }
-    async updateComposition() {
-        let result;
-        this.logger.debug('Checking service definitions...');
+    loadStatic(config) {
+        let schema;
+        let supergraphSdl;
         try {
-            result = await this.updateServiceDefinitions(this.config);
+            ({ 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.logger.error("Error checking for changes to service definitions: " +
-                (e && e.message || e));
+            this.state = { phase: 'failed to load' };
             throw e;
         }
+        this.state = { phase: 'loaded' };
+    }
+    async loadDynamic(unrefTimer) {
+        try {
+            await this.updateSchema();
+        }
+        catch (e) {
+            this.state = { phase: 'failed to load' };
+            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);
+        }
+        else if ((0, config_1.isServiceDefinitionUpdate)(result)) {
+            await this.updateByComposition(result);
+        }
+        else {
+            throw new Error('Programming error: unexpected result type from `updateServiceDefinitions`');
+        }
+    }
+    async updateByComposition(result) {
         if (!result.serviceDefinitions ||
             JSON.stringify(this.serviceDefinitions) ===
                 JSON.stringify(result.serviceDefinitions)) {
@@ -210,10 +323,110 @@ class ApolloGateway {
         const previousServiceDefinitions = this.serviceDefinitions;
         const previousCompositionMetadata = this.compositionMetadata;
         if (previousSchema) {
-            this.logger.info("New service definitions were found.");
+            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.");
+        }
+        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,
+                    }),
+                });
+            }
+        }
+    }
+    async updateWithSupergraphSdl(result) {
+        if (result.id === this.compositionId) {
+            this.logger.debug('No change in composition since last check.');
+            return;
         }
+        const { schema, supergraphSdl } = this.createSchemaFromSupergraphSdl(result.supergraphSdl);
+        const previousSchema = this.schema;
+        const previousSupergraphSdl = this.supergraphSdl;
+        const previousCompositionId = this.compositionId;
+        if (previousSchema) {
+            this.logger.info('Updated Supergraph SDL was found.');
+        }
+        await this.maybePerformServiceHealthCheck(result);
+        this.compositionId = result.id;
+        this.supergraphSdl = result.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({
+                    compositionId: result.id,
+                    supergraphSdl: result.supergraphSdl,
+                    schema: schema.toGraphQLJSSchema(),
+                }, previousCompositionId && previousSupergraphSdl && previousSchema
+                    ? {
+                        compositionId: previousCompositionId,
+                        supergraphSdl: previousSupergraphSdl,
+                        schema: previousSchema,
+                    }
+                    : undefined);
+            }
+        }
+    }
+    updateWithSchemaAndNotify(coreSchema, coreSupergraphSdl, legacyDontNotifyOnSchemaChangeListeners = false) {
+        if (this.queryPlanStore)
+            this.queryPlanStore.flush();
+        this.apiSchema = coreSchema.toAPISchema();
+        this.schema = wrapSchemaWithAliasResolver(this.apiSchema.toGraphQLJSSchema());
+        this.queryPlanner = new query_planner_1.QueryPlanner(coreSchema);
+        if (!legacyDontNotifyOnSchemaChangeListeners) {
+            this.onSchemaChangeListeners.forEach((listener) => {
+                try {
+                    listener(this.schema);
+                }
+                catch (e) {
+                    this.logger.error("An error was thrown from an 'onSchemaChange' listener. " +
+                        'The schema will still update: ' +
+                        ((e && e.message) || e));
+                }
+            });
+        }
+        this.onSchemaLoadOrUpdateListeners.forEach((listener) => {
+            try {
+                listener({
+                    apiSchema: this.schema,
+                    coreSupergraphSdl,
+                });
+            }
+            catch (e) {
+                this.logger.error("An error was thrown from an 'onSchemaLoadOrUpdate' listener. " +
+                    'The schema will still update: ' +
+                    ((e && e.message) || e));
+            }
+        });
+    }
+    async maybePerformServiceHealthCheck(update) {
         if (this.config.serviceHealthCheck) {
-            const serviceMap = result.serviceDefinitions.reduce((serviceMap, serviceDef) => {
+            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),
@@ -224,51 +437,32 @@ class ApolloGateway {
                 await this.serviceHealthCheck(serviceMap);
             }
             catch (e) {
-                this.logger.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.' + e);
-                throw 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);
             }
         }
-        this.compositionMetadata = result.compositionMetadata;
-        this.serviceDefinitions = result.serviceDefinitions;
-        if (this.queryPlanStore)
-            this.queryPlanStore.flush();
-        this.schema = this.createSchema(result.serviceDefinitions);
-        try {
-            this.onSchemaChangeListeners.forEach(listener => listener(this.schema));
-        }
-        catch (e) {
-            this.logger.error("An error was thrown from an 'onSchemaChange' listener. " +
-                "The schema will still update: " + (e && e.message || e));
-        }
-        if (this.experimental_didUpdateComposition) {
-            this.experimental_didUpdateComposition({
-                serviceDefinitions: result.serviceDefinitions,
-                schema: this.schema,
-                ...(this.compositionMetadata && {
-                    compositionMetadata: this.compositionMetadata,
-                }),
-            }, previousServiceDefinitions &&
-                previousSchema && {
-                serviceDefinitions: previousServiceDefinitions,
-                schema: previousSchema,
-                ...(previousCompositionMetadata && {
-                    compositionMetadata: previousCompositionMetadata,
-                }),
-            });
-        }
     }
     serviceHealthCheck(serviceMap = this.serviceMap) {
         return Promise.all(Object.entries(serviceMap).map(([name, { dataSource }]) => dataSource
-            .process({ request: { query: exports.HEALTH_CHECK_QUERY }, context: {} })
-            .then(response => ({ name, response }))));
+            .process({
+            kind: types_1.GraphQLDataSourceRequestKind.HEALTH_CHECK,
+            request: { query: exports.HEALTH_CHECK_QUERY },
+            context: {},
+        })
+            .then((response) => ({ name, response }))
+            .catch((e) => {
+            throw new Error(`[${name}]: ${e.message}`);
+        })));
     }
-    createSchema(serviceList) {
+    createSchemaFromServiceList(serviceList) {
         this.logger.debug(`Composing schema from service list: \n${serviceList
             .map(({ name, url }) => `  ${url || 'local'}: ${name}`)
             .join('\n')}`);
-        const { schema, errors } = federation_1.composeAndValidate(serviceList);
-        if (errors && errors.length > 0) {
+        const compositionResult = (0, composition_1.composeServices)(serviceList);
+        const errors = compositionResult.errors;
+        if (errors) {
             if (this.experimental_didFailComposition) {
                 this.experimental_didFailComposition({
                     errors,
@@ -278,11 +472,28 @@ class ApolloGateway {
                     }),
                 });
             }
-            throw new apollo_graphql_1.GraphQLSchemaValidationError(errors);
+            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];
+    }
+    createSchemaFromSupergraphSdl(supergraphSdl) {
+        const [schema, serviceList] = (0, federation_internals_1.buildSupergraphSchema)(supergraphSdl);
         this.createServices(serviceList);
-        this.logger.debug('Schema loaded and ready for execution');
-        return wrapSchemaWithAliasResolver(schema);
+        return {
+            schema,
+            supergraphSdl,
+        };
     }
     onSchemaChange(callback) {
         this.onSchemaChangeListeners.add(callback);
@@ -290,21 +501,64 @@ class ApolloGateway {
             this.onSchemaChangeListeners.delete(callback);
         };
     }
-    async pollServices() {
-        if (this.pollingTimer)
-            clearTimeout(this.pollingTimer);
-        await new Promise(res => {
-            var _a;
-            this.pollingTimer = setTimeout(() => res(), this.experimental_pollInterval || 10000);
-            (_a = this.pollingTimer) === null || _a === void 0 ? void 0 : _a.unref();
+    onSchemaLoadOrUpdate(callback) {
+        this.onSchemaLoadOrUpdateListeners.add(callback);
+        return () => {
+            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.updateComposition();
+            await this.updateSchema();
         }
         catch (err) {
-            this.logger.error(err && err.message || err);
+            this.logger.error((err && err.message) || err);
+        }
+        if (this.state.phase === 'polling') {
+            this.state = { phase: 'loaded' };
+            setImmediate(() => this.pollServices(unrefTimer));
         }
-        this.pollServices();
+        pollingDone();
     }
     createAndCacheDataSource(serviceDef) {
         if (this.serviceMap[serviceDef.name] &&
@@ -315,7 +569,7 @@ class ApolloGateway {
         return dataSource;
     }
     createDataSource(serviceDef) {
-        if (!serviceDef.url && !isLocalConfig(this.config)) {
+        if (!serviceDef.url && !(0, config_1.isLocalConfig)(this.config)) {
             this.logger.error(`Service definition for service ${serviceDef.name} is missing a url`);
         }
         return this.config.buildService
@@ -330,79 +584,129 @@ class ApolloGateway {
         }
     }
     async loadServiceDefinitions(config) {
-        const getManagedConfig = (engineConfig) => {
-            return loadServicesFromStorage_1.getServiceDefinitionsFromStorage({
-                graphId: engineConfig.graphId,
-                apiKeyHash: engineConfig.apiKeyHash,
-                graphVariant: engineConfig.graphVariant,
-                federationVersion: config.federationVersion || 1,
-                fetcher: this.fetcher,
-            });
-        };
-        if (isLocalConfig(config) || isRemoteConfig(config)) {
-            if (this.engineConfig && !this.warnedStates.remoteWithLocalConfig) {
-                this.warnedStates.remoteWithLocalConfig = true;
-                getManagedConfig(this.engineConfig).then(() => {
-                    this.logger.warn("A local gateway service list is overriding an Apollo Graph " +
-                        "Manager managed configuration.  To use the managed " +
-                        "configuration, do not specify a service list locally.");
-                }).catch(() => { });
-            }
-        }
-        if (isLocalConfig(config)) {
-            return { isNewSchema: false };
-        }
-        if (isRemoteConfig(config)) {
-            const serviceList = config.serviceList.map(serviceDefinition => ({
+        var _a, _b, _c;
+        if ((0, config_1.isRemoteConfig)(config)) {
+            const serviceList = config.serviceList.map((serviceDefinition) => ({
                 ...serviceDefinition,
                 dataSource: this.createAndCacheDataSource(serviceDefinition),
             }));
-            return loadServicesFromRemoteEndpoint_1.getServiceDefinitionsFromRemoteEndpoint({
+            return (0, loadServicesFromRemoteEndpoint_1.getServiceDefinitionsFromRemoteEndpoint)({
                 serviceList,
-                ...(config.introspectionHeaders
-                    ? { headers: config.introspectionHeaders }
-                    : {}),
+                async getServiceIntrospectionHeaders(service) {
+                    return typeof config.introspectionHeaders === 'function'
+                        ? await config.introspectionHeaders(service)
+                        : config.introspectionHeaders;
+                },
                 serviceSdlCache: this.serviceSdlCache,
             });
         }
-        if (!this.engineConfig) {
-            throw new Error('When `serviceList` is not set, an Apollo Engine configuration must be provided. See https://www.apollographql.com/docs/apollo-server/federation/managed-federation/ for more information.');
+        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 result = await (0, loadSupergraphSdlFromStorage_1.loadSupergraphSdlFromStorage)({
+            graphRef: this.apolloConfig.graphRef,
+            apiKey: this.apolloConfig.key,
+            endpoint: this.schemaConfigDeliveryEndpoint,
+            fetcher: this.fetcher,
+            compositionId: (_c = this.compositionId) !== null && _c !== void 0 ? _c : null,
+        });
+        return (result !== null && result !== void 0 ? result : {
+            id: this.compositionId,
+            supergraphSdl: this.supergraphSdl,
+        });
+    }
+    maybeWarnOnConflictingConfig() {
+        var _a, _b;
+        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 (!(0, config_1.isManagedConfig)(this.config) &&
+            canUseManagedConfig &&
+            !this.warnedStates.remoteWithLocalConfig) {
+            this.warnedStates.remoteWithLocalConfig = true;
+            this.logger.warn('A local gateway configuration is overriding a managed federation ' +
+                'configuration.  To use the managed ' +
+                'configuration, do not specify a service list or supergraphSdl locally.');
         }
-        return getManagedConfig(this.engineConfig);
     }
     validateIncomingRequest(requestContext, operationContext) {
-        const variableDefinitions = operationContext.operation
-            .variableDefinitions;
-        if (!variableDefinitions)
-            return [];
-        const { errors } = values_1.getVariableValues(operationContext.schema, variableDefinitions, requestContext.request.variables);
-        return errors || [];
-    }
-    initializeQueryPlanStore() {
-        this.queryPlanStore = new apollo_server_caching_1.InMemoryLRUCache({
-            maxSize: Math.pow(2, 20) *
-                (this.experimental_approximateQueryPlanStoreMiB || 30),
-            sizeCalculator: approximateObjectSize,
+        return opentelemetry_1.tracer.startActiveSpan(opentelemetry_1.OpenTelemetrySpanNames.VALIDATE, (span) => {
+            try {
+                const variableDefinitions = operationContext.operation
+                    .variableDefinitions;
+                if (!variableDefinitions)
+                    return [];
+                const { errors } = (0, values_1.getVariableValues)(operationContext.schema, variableDefinitions, requestContext.request.variables || {});
+                if (errors) {
+                    span.setStatus({ code: api_1.SpanStatusCode.ERROR });
+                }
+                return errors || [];
+            }
+            catch (err) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR });
+                throw err;
+            }
+            finally {
+                span.end();
+            }
         });
     }
     async stop() {
-        if (this.pollingTimer) {
-            clearTimeout(this.pollingTimer);
-            this.pollingTimer = undefined;
+        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':
+                return;
+            case 'stopping':
+                await this.state.stoppingDonePromise;
+                if (this.state.phase !== 'stopped') {
+                    throw Error(`Expected to be stopped when done stopping, but instead ${this.state.phase}`);
+                }
+                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;
+                this.state = {
+                    phase: 'stopping',
+                    stoppingDonePromise: new Promise((res) => {
+                        stoppingDone = res;
+                    }),
+                };
+                await pollingDonePromise;
+                this.state = { phase: 'stopped' };
+                stoppingDone();
+                return;
+            }
+            default:
+                throw new UnreachableCaseError(this.state);
         }
     }
 }
 exports.ApolloGateway = ApolloGateway;
+ApolloGateway.prototype.onSchemaChange = (0, util_1.deprecate)(ApolloGateway.prototype.onSchemaChange, `'ApolloGateway.prototype.onSchemaChange' is deprecated. Use 'ApolloGateway.prototype.onSchemaLoadOrUpdate' instead.`);
 function approximateObjectSize(obj) {
     return Buffer.byteLength(JSON.stringify(obj), 'utf8');
 }
 function wrapSchemaWithAliasResolver(schema) {
     const typeMap = schema.getTypeMap();
-    Object.keys(typeMap).forEach(typeName => {
+    Object.keys(typeMap).forEach((typeName) => {
         const type = typeMap[typeName];
-        if (graphql_1.isObjectType(type) && !graphql_1.isIntrospectionType(type)) {
+        if ((0, graphql_1.isObjectType)(type) && !(0, graphql_1.isIntrospectionType)(type)) {
             const fields = type.getFields();
-            Object.keys(fields).forEach(fieldName => {
+            Object.keys(fields).forEach((fieldName) => {
                 const field = fields[fieldName];
                 field.resolve = executeQueryPlan_1.defaultFieldResolverWithAliasSupport;
             });
@@ -410,5 +714,10 @@ function wrapSchemaWithAliasResolver(schema) {
     });
     return schema;
 }
+class UnreachableCaseError extends Error {
+    constructor(val) {
+        super(`Unreachable case: ${val}`);
+    }
+}
 __exportStar(require("./datasources"), exports);
 //# sourceMappingURL=index.js.map