@apollo/gateway 2.1.0-alpha.1 → 2.1.0-alpha.4

package/src/datasources/RemoteGraphQLDataSource.ts

@@ -1,17 +1,3 @@
-import {
-  GraphQLRequestContext,
-  GraphQLResponse,
-  ValueOrPromise,
-  GraphQLRequest,
-  CacheHint,
-  CacheScope,
-  CachePolicy,
-} from 'apollo-server-types';
-import {
-  ApolloError,
-  AuthenticationError,
-  ForbiddenError,
-} from 'apollo-server-errors';
 import { isObject } from '../utilities/predicates';
 import { GraphQLDataSource, GraphQLDataSourceProcessOptions, GraphQLDataSourceRequestKind } from './types';
 import { createHash } from '@apollo/utils.createhash';
@@ -19,6 +5,8 @@ import { parseCacheControlHeader } from './parseCacheControlHeader';
 import fetcher from 'make-fetch-happen';
 import { Headers as NodeFetchHeaders, Request as NodeFetchRequest } from 'node-fetch';
 import { Fetcher, FetcherRequestInit, FetcherResponse } from '@apollo/utils.fetcher';
+import { GraphQLError, GraphQLErrorExtensions } from 'graphql';
+import { GatewayCacheHint, GatewayCachePolicy, GatewayGraphQLRequest, GatewayGraphQLRequestContext, GatewayGraphQLResponse } from '@apollo/server-gateway-interface';
 
 export class RemoteGraphQLDataSource<
   TContext extends Record<string, any> = Record<string, any>,
@@ -77,7 +65,7 @@ export class RemoteGraphQLDataSource<
 
   async process(
     options: GraphQLDataSourceProcessOptions<TContext>,
-  ): Promise<GraphQLResponse> {
+  ): Promise<GatewayGraphQLResponse> {
     const { request, context: originalContext } = options;
     // Deal with a bit of a hairy situation in typings: when doing health checks
     // and schema checks we always pass in `{}` as the context even though it's
@@ -160,7 +148,7 @@ export class RemoteGraphQLDataSource<
     // If APQ was enabled, we'll run the same request again, but add in the
     // previously omitted `query`.  If APQ was NOT enabled, this is the first
     // request (non-APQ, all the way).
-    const requestWithQuery: GraphQLRequest = {
+    const requestWithQuery: GatewayGraphQLRequest = {
       query,
       ...requestWithoutQuery,
     };
@@ -174,9 +162,9 @@ export class RemoteGraphQLDataSource<
   }
 
   private async sendRequest(
-    request: GraphQLRequest,
+    request: GatewayGraphQLRequest,
     context: TContext,
-  ): Promise<GraphQLResponse> {
+  ): Promise<GatewayGraphQLResponse> {
     // This would represent an internal programming error since this shouldn't
     // be possible in the way that this method is invoked right now.
     if (!request.http) {
@@ -229,7 +217,7 @@ export class RemoteGraphQLDataSource<
 
   public willSendRequest?(
     options: GraphQLDataSourceProcessOptions<TContext>,
-  ): ValueOrPromise<void>;
+  ): void | Promise<void>;
 
   private async respond({
     response,
@@ -237,11 +225,11 @@ export class RemoteGraphQLDataSource<
     context,
     overallCachePolicy,
   }: {
-    response: GraphQLResponse;
-    request: GraphQLRequest;
+    response: GatewayGraphQLResponse;
+    request: GatewayGraphQLRequest;
     context: TContext;
-    overallCachePolicy: CachePolicy | null;
-  }): Promise<GraphQLResponse> {
+    overallCachePolicy: GatewayCachePolicy | null;
+  }): Promise<GatewayGraphQLResponse> {
     const processedResponse =
       typeof this.didReceiveResponse === 'function'
         ? await this.didReceiveResponse({ response, request, context })
@@ -256,16 +244,16 @@ export class RemoteGraphQLDataSource<
       // thus the overall response) is uncacheable. (If you don't like this, you
       // can tweak the `cache-control` header in your `didReceiveResponse`
       // method.)
-      const hint: CacheHint = { maxAge: 0 };
+      const hint: GatewayCacheHint = { maxAge: 0 };
       const maxAge = parsed['max-age'];
       if (typeof maxAge === 'string' && maxAge.match(/^[0-9]+$/)) {
         hint.maxAge = +maxAge;
       }
       if (parsed['private'] === true) {
-        hint.scope = CacheScope.Private;
+        hint.scope = 'PRIVATE';
       }
       if (parsed['public'] === true) {
-        hint.scope = CacheScope.Public;
+        hint.scope = 'PUBLIC';
       }
       overallCachePolicy.restrict(hint);
     }
@@ -275,9 +263,9 @@ export class RemoteGraphQLDataSource<
 
   public didReceiveResponse?(
     requestContext: Required<
-      Pick<GraphQLRequestContext<TContext>, 'request' | 'response' | 'context'>
+      Pick<GatewayGraphQLRequestContext<TContext>, 'request' | 'response' | 'context'>
     >,
-  ): ValueOrPromise<GraphQLResponse>;
+  ): GatewayGraphQLResponse | Promise<GatewayGraphQLResponse>;
 
   public didEncounterError(
     error: Error,
@@ -302,28 +290,25 @@ export class RemoteGraphQLDataSource<
   }
 
   public async errorFromResponse(response: FetcherResponse) {
-    const message = `${response.status}: ${response.statusText}`;
-
-    let error: ApolloError;
-    if (response.status === 401) {
-      error = new AuthenticationError(message);
-    } else if (response.status === 403) {
-      error = new ForbiddenError(message);
-    } else {
-      error = new ApolloError(message);
-    }
-
     const body = await this.parseBody(response);
 
-    Object.assign(error.extensions, {
+    const extensions: GraphQLErrorExtensions = {
       response: {
         url: response.url,
         status: response.status,
         statusText: response.statusText,
         body,
       },
-    });
+    };
+
+    if (response.status === 401) {
+      extensions.code = 'UNAUTHENTICATED';
+    } else if (response.status === 403) {
+      extensions.code = 'FORBIDDEN';
+    }
 
-    return error;
+    return new GraphQLError(`${response.status}: ${response.statusText}`, {
+      extensions,
+    });
   }
 }

package/src/datasources/__tests__/LocalGraphQLDataSource.test.ts

@@ -2,8 +2,8 @@ import { LocalGraphQLDataSource } from '../LocalGraphQLDataSource';
 import { buildSubgraphSchema } from '@apollo/subgraph';
 import gql from 'graphql-tag';
 import { GraphQLResolverMap } from '@apollo/subgraph/src/schema-helper';
-import { GraphQLRequestContext } from 'apollo-server-types';
 import { GraphQLDataSourceRequestKind } from '../types';
+import { GatewayGraphQLRequestContext } from '@apollo/server-gateway-interface';
 
 describe('constructing requests', () => {
   it('accepts context', async () => {
@@ -42,7 +42,7 @@ describe('constructing requests', () => {
       },
       incomingRequestContext: {
         context: { userId: 2 },
-      } as GraphQLRequestContext<{userId: number}>,
+      } as GatewayGraphQLRequestContext<{userId: number}>,
       context: { userId: 2 },
     });
 

package/src/datasources/__tests__/RemoteGraphQLDataSource.test.ts

@@ -1,15 +1,10 @@
-import {
-  ApolloError,
-  AuthenticationError,
-  ForbiddenError,
-} from 'apollo-server-errors';
-
 import { RemoteGraphQLDataSource } from '../RemoteGraphQLDataSource';
 import { Response, Headers } from 'node-fetch';
-import { GraphQLRequestContext } from 'apollo-server-types';
 import { GraphQLDataSourceRequestKind } from '../types';
 import { nockBeforeEach, nockAfterEach } from '../../__tests__/nockAssertions';
 import nock from 'nock';
+import { GraphQLError } from 'graphql';
+import { GatewayGraphQLRequestContext } from '@apollo/server-gateway-interface';
 
 beforeEach(nockBeforeEach);
 afterEach(nockAfterEach);
@@ -322,7 +317,7 @@ describe('didReceiveResponse', () => {
         response,
       }: Required<
         Pick<
-          GraphQLRequestContext<MyContext>,
+          GatewayGraphQLRequestContext<MyContext>,
           'request' | 'response' | 'context'
         >
       >) {
@@ -367,7 +362,7 @@ describe('didReceiveResponse', () => {
         response,
       }: Required<
         Pick<
-          GraphQLRequestContext<MyContext>,
+          GatewayGraphQLRequestContext<MyContext>,
           'request' | 'response' | 'context'
         >
       >) {
@@ -403,7 +398,7 @@ describe('didReceiveResponse', () => {
         response,
       }: Required<
         Pick<
-          GraphQLRequestContext<MyContext>,
+          GatewayGraphQLRequestContext<MyContext>,
           'request' | 'response' | 'context'
         >
       >) {
@@ -457,11 +452,11 @@ describe('didEncounterError', () => {
       },
       incomingRequestContext: {
         context,
-      } as GraphQLRequestContext<MyContext>,
+      } as GatewayGraphQLRequestContext<MyContext>,
       context,
     });
 
-    await expect(result).rejects.toThrow(AuthenticationError);
+    await expect(result).rejects.toThrow(GraphQLError);
     expect(context).toMatchObject({
       timingData: [{ time: 1616446845234 }],
     });
@@ -469,7 +464,7 @@ describe('didEncounterError', () => {
 });
 
 describe('error handling', () => {
-  it('throws an AuthenticationError when the response status is 401', async () => {
+  it('throws error with code UNAUTHENTICATED when the response status is 401', async () => {
     const DataSource = new RemoteGraphQLDataSource({
       url: 'https://api.example.com/foo',
     });
@@ -480,7 +475,7 @@ describe('error handling', () => {
       ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
     });
-    await expect(result).rejects.toThrow(AuthenticationError);
+    await expect(result).rejects.toThrow(GraphQLError);
     await expect(result).rejects.toMatchObject({
       extensions: {
         code: 'UNAUTHENTICATED',
@@ -492,7 +487,7 @@ describe('error handling', () => {
     });
   });
 
-  it('throws a ForbiddenError when the response status is 403', async () => {
+  it('throws an error with code FORBIDDEN when the response status is 403', async () => {
     const DataSource = new RemoteGraphQLDataSource({
       url: 'https://api.example.com/foo',
     });
@@ -503,7 +498,7 @@ describe('error handling', () => {
       ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
     });
-    await expect(result).rejects.toThrow(ForbiddenError);
+    await expect(result).rejects.toThrow(GraphQLError);
     await expect(result).rejects.toMatchObject({
       extensions: {
         code: 'FORBIDDEN',
@@ -515,7 +510,7 @@ describe('error handling', () => {
     });
   });
 
-  it('throws an ApolloError when the response status is 500', async () => {
+  it('throws a GraphQLError when the response status is 500', async () => {
     const DataSource = new RemoteGraphQLDataSource({
       url: 'https://api.example.com/foo',
     });
@@ -526,7 +521,7 @@ describe('error handling', () => {
       ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
     });
-    await expect(result).rejects.toThrow(ApolloError);
+    await expect(result).rejects.toThrow(GraphQLError);
     await expect(result).rejects.toMatchObject({
       extensions: {
         response: {
@@ -560,7 +555,7 @@ describe('error handling', () => {
       ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
     });
-    await expect(result).rejects.toThrow(ApolloError);
+    await expect(result).rejects.toThrow(GraphQLError);
     await expect(result).rejects.toMatchObject({
       extensions: {
         response: {

package/src/datasources/types.ts

@@ -1,11 +1,11 @@
-import { GraphQLResponse, GraphQLRequestContext } from 'apollo-server-types';
+import { GatewayGraphQLResponse, GatewayGraphQLRequestContext } from '@apollo/server-gateway-interface';
 
 export interface GraphQLDataSource<
   TContext extends Record<string, any> = Record<string, any>,
 > {
   process(
     options: GraphQLDataSourceProcessOptions<TContext>,
-  ): Promise<GraphQLResponse>;
+  ): Promise<GatewayGraphQLResponse>;
 }
 
 export enum GraphQLDataSourceRequestKind {
@@ -20,7 +20,7 @@ export type GraphQLDataSourceProcessOptions<
   /**
    * The request to send to the subgraph.
    */
-  request: GraphQLRequestContext<TContext>['request'];
+  request: GatewayGraphQLRequestContext<TContext>['request'];
 } & (
   | {
       kind: GraphQLDataSourceRequestKind.INCOMING_OPERATION;
@@ -29,7 +29,7 @@ export type GraphQLDataSourceProcessOptions<
        * one of the strings if this operation is generated by the gateway without an
        * incoming request.
        */
-      incomingRequestContext: GraphQLRequestContext<TContext>;
+      incomingRequestContext: GatewayGraphQLRequestContext<TContext>;
       /**
        * Equivalent to incomingRequestContext.context (provided here for
        * backwards compatibility): the object created by the Apollo Server
@@ -38,11 +38,11 @@ export type GraphQLDataSourceProcessOptions<
        * @deprecated Use `incomingRequestContext.context` instead (after
        * checking `kind`).
        */
-      context: GraphQLRequestContext<TContext>['context'];
+      context: GatewayGraphQLRequestContext<TContext>['context'];
       /**
        * The document representation of the request's query being sent to the subgraph, if available.
        */
-      document?: GraphQLRequestContext<TContext>['document'];
+      document?: GatewayGraphQLRequestContext<TContext>['document'];
     }
   | {
       kind:

package/src/executeQueryPlan.ts

@@ -1,7 +1,3 @@
-import {
-  GraphQLExecutionResult,
-  GraphQLRequestContext,
-} from 'apollo-server-types';
 import { Headers } from 'node-fetch';
 import {
   execute,
@@ -33,7 +29,8 @@ import { deepMerge } from './utilities/deepMerge';
 import { isNotNullOrUndefined } from './utilities/array';
 import { SpanStatusCode } from "@opentelemetry/api";
 import { OpenTelemetrySpanNames, tracer } from "./utilities/opentelemetry";
-import { defaultRootName, errorCodeDef, ERRORS } from '@apollo/federation-internals';
+import { assert, defaultRootName, errorCodeDef, ERRORS } from '@apollo/federation-internals';
+import { GatewayGraphQLRequestContext, GatewayExecutionResult } from '@apollo/server-gateway-interface';
 
 export type ServiceMap = {
   [serviceName: string]: GraphQLDataSource;
@@ -41,22 +38,22 @@ export type ServiceMap = {
 
 type ResultMap = Record<string, any>;
 
-interface ExecutionContext<TContext> {
+interface ExecutionContext {
   queryPlan: QueryPlan;
   operationContext: OperationContext;
   serviceMap: ServiceMap;
-  requestContext: GraphQLRequestContext<TContext>;
+  requestContext: GatewayGraphQLRequestContext;
   supergraphSchema: GraphQLSchema;
   errors: GraphQLError[];
 }
 
-export async function executeQueryPlan<TContext>(
+export async function executeQueryPlan(
   queryPlan: QueryPlan,
   serviceMap: ServiceMap,
-  requestContext: GraphQLRequestContext<TContext>,
+  requestContext: GatewayGraphQLRequestContext,
   operationContext: OperationContext,
   supergraphSchema: GraphQLSchema,
-): Promise<GraphQLExecutionResult> {
+): Promise<GatewayExecutionResult> {
 
   const logger = requestContext.logger || console;
 
@@ -64,7 +61,7 @@ export async function executeQueryPlan<TContext>(
     try {
       const errors: GraphQLError[] = [];
 
-      const context: ExecutionContext<TContext> = {
+      const context: ExecutionContext = {
         queryPlan,
         operationContext,
         serviceMap,
@@ -170,8 +167,8 @@ export async function executeQueryPlan<TContext>(
 // we're going to ignore it, because it makes the code much simpler and more
 // typesafe. However, it doesn't actually ask for traces from the backend
 // service unless we are capturing traces for Studio.
-async function executeNode<TContext>(
-  context: ExecutionContext<TContext>,
+async function executeNode(
+  context: ExecutionContext,
   node: PlanNode,
   results: ResultMap | ResultMap[],
   path: ResponsePath,
@@ -251,11 +248,17 @@ async function executeNode<TContext>(
       }
       return new Trace.QueryPlanNode({ fetch: traceNode });
     }
+    case 'Defer': {
+      assert(false, `@defer support is not available in the gateway`);
+    }
+    case 'Condition': {
+      assert(false, `Condition nodes are not available in the gateway`);
+    }
   }
 }
 
-async function executeFetch<TContext>(
-  context: ExecutionContext<TContext>,
+async function executeFetch(
+  context: ExecutionContext,
   fetch: FetchNode,
   results: ResultMap | (ResultMap | null | undefined)[],
   _path: ResponsePath,
@@ -379,7 +382,7 @@ async function executeFetch<TContext>(
     }
   });
   async function sendOperation(
-    context: ExecutionContext<TContext>,
+    context: ExecutionContext,
     source: string,
     variables: Record<string, any>,
     operationName: string | undefined,

package/src/index.ts

@@ -1,12 +1,7 @@
 import { deprecate } from 'util';
-import { GraphQLService, Unsubscriber } from 'apollo-server-core';
-import {
-  GraphQLExecutionResult,
-  GraphQLRequestContextExecutionDidStart,
-} from 'apollo-server-types';
 import { createHash } from '@apollo/utils.createhash';
 import type { Logger } from '@apollo/utils.logger';
-import { InMemoryLRUCache } from 'apollo-server-caching';
+import LRUCache from 'lru-cache';
 import {
   isObjectType,
   isIntrospectionType,
@@ -63,6 +58,7 @@ import {
   ServiceDefinition,
 } from '@apollo/federation-internals';
 import { getDefaultLogger } from './logger';
+import {GatewayInterface, GatewayUnsubscriber, GatewayGraphQLRequestContext, GatewayExecutionResult} from '@apollo/server-gateway-interface';
 
 type DataSourceMap = {
   [serviceName: string]: { url?: string; dataSource: GraphQLDataSource };
@@ -118,7 +114,7 @@ interface GraphQLServiceEngineConfig {
   graphVariant?: string;
 }
 
-export class ApolloGateway implements GraphQLService {
+export class ApolloGateway implements GatewayInterface {
   public schema?: GraphQLSchema;
   // Same as a `schema` but as a `Schema` to avoid reconverting when we need it.
   // TODO(sylvain): if we add caching in `Schema.toGraphQLJSSchema`, we could maybe only keep `apiSchema`
@@ -130,7 +126,7 @@ export class ApolloGateway implements GraphQLService {
   private serviceMap: DataSourceMap = Object.create(null);
   private config: GatewayConfig;
   private logger: Logger;
-  private queryPlanStore: InMemoryLRUCache<QueryPlan>;
+  private queryPlanStore: LRUCache<string, QueryPlan>;
   private apolloConfig?: ApolloConfigFromAS3;
   private onSchemaChangeListeners = new Set<(schema: GraphQLSchema) => void>();
   private onSchemaLoadOrUpdateListeners = new Set<
@@ -196,14 +192,14 @@ export class ApolloGateway implements GraphQLService {
   }
 
   private initQueryPlanStore(approximateQueryPlanStoreMiB?: number) {
-    return new InMemoryLRUCache<QueryPlan>({
+    return new LRUCache<string, QueryPlan>({
       // Create ~about~ a 30MiB InMemoryLRUCache.  This is less than precise
       // since the technique to calculate the size of a DocumentNode is
       // only using JSON.stringify on the DocumentNode (and thus doesn't account
       // for unicode characters, etc.), but it should do a reasonable job at
       // providing a caching document store for most operations.
       maxSize: Math.pow(2, 20) * (approximateQueryPlanStoreMiB || 30),
-      sizeCalculator: approximateObjectSize,
+      sizeCalculation: approximateObjectSize,
     });
   }
 
@@ -360,6 +356,7 @@ export class ApolloGateway implements GraphQLService {
           uplinkEndpoints:
             this.config.uplinkEndpoints ?? schemaDeliveryEndpoints,
           maxRetries: this.config.uplinkMaxRetries,
+          fetcher: this.config.fetcher,
           logger: this.logger,
           fallbackPollIntervalInMs: this.pollIntervalInMs,
         }),
@@ -558,12 +555,12 @@ export class ApolloGateway implements GraphQLService {
     // Once we remove the deprecated onSchemaChange() method, we can remove this.
     legacyDontNotifyOnSchemaChangeListeners: boolean = false,
   ): void {
-    if (this.queryPlanStore) this.queryPlanStore.flush();
+    this.queryPlanStore.clear();
     this.apiSchema = coreSchema.toAPISchema();
     this.schema = addExtensions(
       wrapSchemaWithAliasResolver(this.apiSchema.toGraphQLJSSchema()),
     );
-    this.queryPlanner = new QueryPlanner(coreSchema);
+    this.queryPlanner = new QueryPlanner(coreSchema, this.config.queryPlannerConfig);
 
     // Notify onSchemaChange listeners of the updated schema
     if (!legacyDontNotifyOnSchemaChangeListeners) {
@@ -650,7 +647,7 @@ export class ApolloGateway implements GraphQLService {
    */
   public onSchemaChange(
     callback: (schema: GraphQLSchema) => void,
-  ): Unsubscriber {
+  ): GatewayUnsubscriber {
     this.onSchemaChangeListeners.add(callback);
 
     return () => {
@@ -663,7 +660,7 @@ export class ApolloGateway implements GraphQLService {
       apiSchema: GraphQLSchema;
       coreSupergraphSdl: string;
     }) => void,
-  ): Unsubscriber {
+  ): GatewayUnsubscriber {
     this.onSchemaLoadOrUpdateListeners.add(callback);
 
     return () => {
@@ -743,9 +740,9 @@ export class ApolloGateway implements GraphQLService {
   // ApolloServerPluginUsageReporting) assumes that. In fact, errors talking to backends
   // are unlikely to show up as GraphQLErrors. Do we need to use
   // formatApolloErrors or something?
-  public executor = async <TContext>(
-    requestContext: GraphQLRequestContextExecutionDidStart<TContext>,
-  ): Promise<GraphQLExecutionResult> => {
+  public executor = async (
+    requestContext: GatewayGraphQLRequestContext,
+  ): Promise<GatewayExecutionResult> => {
     const spanAttributes = requestContext.operationName
       ? { operationName: requestContext.operationName }
       : {};
@@ -774,10 +771,7 @@ export class ApolloGateway implements GraphQLService {
             span.setStatus({ code: SpanStatusCode.ERROR });
             return { errors: validationErrors };
           }
-          let queryPlan: QueryPlan | undefined;
-          if (this.queryPlanStore) {
-            queryPlan = await this.queryPlanStore.get(queryPlanStoreKey);
-          }
+          let queryPlan = this.queryPlanStore.get(queryPlanStoreKey);
 
           if (!queryPlan) {
             queryPlan = tracer.startActiveSpan(
@@ -800,25 +794,11 @@ export class ApolloGateway implements GraphQLService {
               },
             );
 
-            if (this.queryPlanStore) {
-              // The underlying cache store behind the `documentStore` returns a
-              // `Promise` which is resolved (or rejected), eventually, based on the
-              // success or failure (respectively) of the cache save attempt.  While
-              // it's certainly possible to `await` this `Promise`, we don't care about
-              // whether or not it's successful at this point.  We'll instead proceed
-              // to serve the rest of the request and just hope that this works out.
-              // If it doesn't work, the next request will have another opportunity to
-              // try again.  Errors will surface as warnings, as appropriate.
-              //
-              // While it shouldn't normally be necessary to wrap this `Promise` in a
-              // `Promise.resolve` invocation, it seems that the underlying cache store
-              // is returning a non-native `Promise` (e.g. Bluebird, etc.).
-              Promise.resolve(
-                this.queryPlanStore.set(queryPlanStoreKey, queryPlan),
-              ).catch((err) =>
-                this.logger.warn(
-                  'Could not store queryPlan' + ((err && err.message) || err),
-                ),
+            try {
+              this.queryPlanStore.set(queryPlanStoreKey, queryPlan);
+            } catch (err) {
+              this.logger.warn(
+                'Could not store queryPlan' + ((err && err.message) || err),
               );
             }
           }
@@ -840,7 +820,7 @@ export class ApolloGateway implements GraphQLService {
             });
           }
 
-          const response = await executeQueryPlan<TContext>(
+          const response = await executeQueryPlan(
             queryPlan,
             serviceMap,
             requestContext,
@@ -898,8 +878,8 @@ export class ApolloGateway implements GraphQLService {
     );
   };
 
-  private validateIncomingRequest<TContext>(
-    requestContext: GraphQLRequestContextExecutionDidStart<TContext>,
+  private validateIncomingRequest(
+    requestContext: GatewayGraphQLRequestContext,
     operationContext: OperationContext,
   ) {
     return tracer.startActiveSpan(OpenTelemetrySpanNames.VALIDATE, (span) => {

package/src/logger.ts

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

package/src/supergraphManagers/IntrospectAndCompose/loadServicesFromRemoteEndpoint.ts

@@ -1,10 +1,10 @@
-import { GraphQLRequest } from 'apollo-server-types';
 import { parse } from 'graphql';
 import { Headers, type HeadersInit } from 'node-fetch';
 import { ServiceDefinition } from '@apollo/federation-internals';
 import { GraphQLDataSource, GraphQLDataSourceRequestKind } from '../../datasources/types';
 import { SERVICE_DEFINITION_QUERY } from '../..';
 import { ServiceDefinitionUpdate, ServiceEndpointDefinition } from '../../config';
+import { GatewayGraphQLRequest } from '@apollo/server-gateway-interface';
 
 export type Service = ServiceEndpointDefinition & {
   dataSource: GraphQLDataSource;
@@ -35,7 +35,7 @@ export async function loadServicesFromRemoteEndpoint({
         `Tried to load schema for '${name}' but no 'url' was specified.`);
     }
 
-    const request: GraphQLRequest = {
+    const request: GatewayGraphQLRequest = {
       query: SERVICE_DEFINITION_QUERY,
       http: {
         url,