@apollo/gateway 0.26.0-alpha.2 → 0.26.3

package/src/__tests__/execution-utils.ts

@@ -12,18 +12,17 @@ import {
 } from '@apollo/federation';
 
 import {
-  buildQueryPlan,
   executeQueryPlan,
   buildOperationContext,
 } from '@apollo/gateway';
-import { QueryPlan } from '@apollo/query-planner';
+import { buildComposedSchema, QueryPlanner, QueryPlan } from '@apollo/query-planner';
 import { LocalGraphQLDataSource } from '../datasources/LocalGraphQLDataSource';
 import { mergeDeep } from 'apollo-utilities';
 
 import { queryPlanSerializer, astSerializer } from 'apollo-federation-integration-testsuite';
 import gql from 'graphql-tag';
 import { fixtures } from 'apollo-federation-integration-testsuite';
-import { getQueryPlanner } from '@apollo/query-planner';
+import { parse } from 'graphql';
 
 const prettyFormat = require('pretty-format');
 
@@ -56,16 +55,14 @@ export async function execute(
     }),
   );
 
-  const { schema, queryPlannerPointer } = getFederatedTestingSchema(services);
+  const { schema, queryPlanner } = getFederatedTestingSchema(services);
 
   const operationContext = buildOperationContext({
     schema,
     operationDocument: gql`${request.query}`,
-    operationString: request.query!,
-    queryPlannerPointer,
   });
 
-  const queryPlan = buildQueryPlan(operationContext);
+  const queryPlan = queryPlanner.buildQueryPlan(operationContext);
 
   const result = await executeQueryPlan(
     queryPlan,
@@ -107,9 +104,11 @@ export function getFederatedTestingSchema(services: ServiceDefinitionModule[] =
     throw new GraphQLSchemaValidationError(compositionResult.errors);
   }
 
-  const queryPlannerPointer = getQueryPlanner(compositionResult.supergraphSdl);
+  const schema = buildComposedSchema(parse(compositionResult.supergraphSdl))
 
-  return { serviceMap, schema: compositionResult.schema, queryPlannerPointer };
+  const queryPlanner = new QueryPlanner(schema);
+
+  return { serviceMap, schema, queryPlanner };
 }
 
 export function getTestingSupergraphSdl(services: typeof fixtures = fixtures) {

package/src/__tests__/gateway/queryPlanCache.test.ts

@@ -5,12 +5,9 @@ import { buildFederatedSchema } from '@apollo/federation';
 import { LocalGraphQLDataSource } from '../../datasources/LocalGraphQLDataSource';
 import { ApolloGateway } from '../../';
 import { fixtures } from 'apollo-federation-integration-testsuite';
-
+import { QueryPlanner } from '@apollo/query-planner';
 it('caches the query plan for a request', async () => {
-  const planner = require('../../buildQueryPlan');
-  const originalPlanner = planner.buildQueryPlan;
-
-  planner.buildQueryPlan = jest.fn(originalPlanner);
+  const buildQueryPlanSpy = jest.spyOn(QueryPlanner.prototype, 'buildQueryPlan');
 
   const gateway = new ApolloGateway({
     localServiceList: fixtures,
@@ -51,7 +48,7 @@ it('caches the query plan for a request', async () => {
   });
 
   expect(result.data).toEqual(secondResult.data);
-  expect(planner.buildQueryPlan).toHaveBeenCalledTimes(1);
+  expect(buildQueryPlanSpy).toHaveBeenCalledTimes(1);
 });
 
 it('supports multiple operations and operationName', async () => {

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

@@ -1,4 +1,5 @@
 import gql from 'graphql-tag';
+import http from 'http';
 import mockedEnv from 'mocked-env';
 import { Logger } from 'apollo-server-types';
 import { ApolloGateway } from '../..';
@@ -204,6 +205,101 @@ describe('gateway config / env behavior', () => {
     }
   });
 
+  describe('introspection headers', () => {
+    it('should allow not passing introspectionHeaders', async () => {
+      const receivedHeaders = jest.fn();
+      const nock = mockSdlQuerySuccess(service);
+      nock.on('request', (req: http.ClientRequest) =>
+        receivedHeaders(req.getHeaders()),
+      );
+
+      gateway = new ApolloGateway({
+        serviceList: [{ name: 'accounts', url: service.url }],
+      });
+
+      await gateway.load(mockApolloConfig);
+
+      expect(receivedHeaders).toHaveBeenCalledWith(
+        expect.objectContaining({
+          host: 'localhost:4001',
+        }),
+      );
+    });
+
+    it('should use static headers', async () => {
+      const receivedHeaders = jest.fn();
+      const nock = mockSdlQuerySuccess(service);
+      nock.on('request', (req: http.ClientRequest) =>
+        receivedHeaders(req.getHeaders()),
+      );
+
+      gateway = new ApolloGateway({
+        serviceList: [{ name: 'accounts', url: service.url }],
+        introspectionHeaders: {
+          Authorization: 'Bearer static',
+        },
+      });
+
+      await gateway.load(mockApolloConfig);
+
+      expect(receivedHeaders).toHaveBeenCalledWith(
+        expect.objectContaining({
+          authorization: ['Bearer static'],
+        }),
+      );
+    });
+
+    it('should use dynamic async headers', async () => {
+      const receivedHeaders = jest.fn();
+      const nock = mockSdlQuerySuccess(service);
+      nock.on('request', (req: http.ClientRequest) =>
+        receivedHeaders(req.getHeaders()),
+      );
+
+      gateway = new ApolloGateway({
+        serviceList: [{ name: 'accounts', url: service.url }],
+        introspectionHeaders: async ({ name }) => ({
+          Authorization: 'Bearer dynamic-async',
+          'X-Service-Name': name,
+        }),
+      });
+
+      await gateway.load(mockApolloConfig);
+
+      expect(receivedHeaders).toHaveBeenCalledWith(
+        expect.objectContaining({
+          authorization: ['Bearer dynamic-async'],
+          'x-service-name': ['accounts'],
+        }),
+      );
+    });
+
+    it('should use dynamic non-async headers', async () => {
+      const receivedHeaders = jest.fn();
+      const nock = mockSdlQuerySuccess(service);
+      nock.on('request', (req: http.ClientRequest) =>
+        receivedHeaders(req.getHeaders()),
+      );
+
+      gateway = new ApolloGateway({
+        serviceList: [{ name: 'accounts', url: service.url }],
+        introspectionHeaders: ({ name }) => ({
+          Authorization: 'Bearer dynamic-sync',
+          'X-Service-Name': name,
+        }),
+      });
+
+      await gateway.load(mockApolloConfig);
+
+      expect(receivedHeaders).toHaveBeenCalledWith(
+        expect.objectContaining({
+          authorization: ['Bearer dynamic-sync'],
+          'x-service-name': ['accounts'],
+        }),
+      );
+    });
+  });
+
   // TODO(trevor:cloudconfig): this behavior will be updated
   describe('schema config delivery endpoint configuration', () => {
     it('A code config overrides the env variable', async () => {

package/src/__tests__/integration/nockMocks.ts

@@ -28,7 +28,7 @@ function mockSdlQuery({ url }: MockService) {
 }
 
 export function mockSdlQuerySuccess(service: MockService) {
-  mockSdlQuery(service).reply(200, {
+  return mockSdlQuery(service).reply(200, {
     data: { _service: { sdl: print(service.typeDefs) } },
   });
 }

package/src/__tests__/loadServicesFromRemoteEndpoint.test.ts

@@ -10,6 +10,7 @@ describe('getServiceDefinitionsFromRemoteEndpoint', () => {
       getServiceDefinitionsFromRemoteEndpoint({
         serviceList,
         serviceSdlCache,
+        getServiceIntrospectionHeaders: async () => ({})
       }),
     ).rejects.toThrowError(
       "Tried to load schema for 'test' but no 'url' was specified.",
@@ -30,7 +31,10 @@ describe('getServiceDefinitionsFromRemoteEndpoint', () => {
       getServiceDefinitionsFromRemoteEndpoint({
         serviceList,
         serviceSdlCache,
+        getServiceIntrospectionHeaders: async () => ({}),
       }),
-    ).rejects.toThrowError(/^Couldn't load service definitions for "test" at http:\/\/host-which-better-not-resolve\/graphql: request to http:\/\/host-which-better-not-resolve\/graphql failed, reason: getaddrinfo (ENOTFOUND|EAI_AGAIN)/);
+    ).rejects.toThrowError(
+      /^Couldn't load service definitions for "test" at http:\/\/host-which-better-not-resolve\/graphql: request to http:\/\/host-which-better-not-resolve\/graphql failed, reason: getaddrinfo (ENOTFOUND|EAI_AGAIN)/,
+    );
   });
 });

package/src/__tests__/loadSupergraphSdlFromStorage.test.ts

@@ -74,7 +74,7 @@ describe('loadSupergraphSdlFromStorage', () => {
         price: String @join__field(graph: PRODUCT)
         details: ProductDetailsBook @join__field(graph: PRODUCT)
         reviews: [Review] @join__field(graph: REVIEWS)
-        relatedReviews: [Review!]! @join__field(graph: REVIEWS, requires: \\"similarBooks { isbn }\\")
+        relatedReviews: [Review!]! @join__field(graph: REVIEWS, requires: \\"similarBooks{isbn}\\")
       }
 
       union Brand = Ikea | Amazon
@@ -250,7 +250,7 @@ describe('loadSupergraphSdlFromStorage', () => {
       type User
         @join__owner(graph: ACCOUNTS)
         @join__type(graph: ACCOUNTS, key: \\"id\\")
-        @join__type(graph: ACCOUNTS, key: \\"username name { first last }\\")
+        @join__type(graph: ACCOUNTS, key: \\"username name{first last}\\")
         @join__type(graph: INVENTORY, key: \\"id\\")
         @join__type(graph: PRODUCT, key: \\"id\\")
         @join__type(graph: REVIEWS, key: \\"id\\")
@@ -261,12 +261,12 @@ describe('loadSupergraphSdlFromStorage', () => {
         birthDate(locale: String): String @join__field(graph: ACCOUNTS)
         account: AccountType @join__field(graph: ACCOUNTS)
         metadata: [UserMetadata] @join__field(graph: ACCOUNTS)
-        goodDescription: Boolean @join__field(graph: INVENTORY, requires: \\"metadata { description }\\")
+        goodDescription: Boolean @join__field(graph: INVENTORY, requires: \\"metadata{description}\\")
         vehicle: Vehicle @join__field(graph: PRODUCT)
         thing: Thing @join__field(graph: PRODUCT)
         reviews: [Review] @join__field(graph: REVIEWS)
         numberOfReviews: Int! @join__field(graph: REVIEWS)
-        goodAddress: Boolean @join__field(graph: REVIEWS, requires: \\"metadata { address }\\")
+        goodAddress: Boolean @join__field(graph: REVIEWS, requires: \\"metadata{address}\\")
       }
 
       type UserMetadata {

package/src/__tests__/queryPlanCucumber.test.ts

@@ -2,8 +2,8 @@ import gql from 'graphql-tag';
 import { defineFeature, loadFeature } from 'jest-cucumber';
 import { DocumentNode } from 'graphql';
 
-import { QueryPlan } from '@apollo/query-planner';
-import { buildQueryPlan, buildOperationContext, BuildQueryPlanOptions } from '../buildQueryPlan';
+import { QueryPlan, BuildQueryPlanOptions } from '@apollo/query-planner';
+import { buildOperationContext } from '../operationContext';
 import { getFederatedTestingSchema } from './execution-utils';
 
 const buildQueryPlanFeature = loadFeature(
@@ -20,17 +20,15 @@ features.forEach((feature) => {
     feature.scenarios.forEach((scenario) => {
       test(scenario.title, async ({ given, when, then }) => {
         let operationDocument: DocumentNode;
-        let operationString: string;
         let queryPlan: QueryPlan;
         let options: BuildQueryPlanOptions = { autoFragmentization: false };
 
         // throws on composition errors
-        const { schema, queryPlannerPointer } = getFederatedTestingSchema();
+        const { schema, queryPlanner } = getFederatedTestingSchema();
 
         const givenQuery = () => {
           given(/^query$/im, (operation: string) => {
             operationDocument = gql(operation);
-            operationString = operation;
           })
         }
 
@@ -42,12 +40,10 @@ features.forEach((feature) => {
 
         const thenQueryPlanShouldBe = () => {
           then(/^query plan$/i, (expectedQueryPlan: string) => {
-            queryPlan = buildQueryPlan(
+            queryPlan = queryPlanner.buildQueryPlan(
               buildOperationContext({
                 schema,
                 operationDocument,
-                operationString,
-                queryPlannerPointer,
               }),
               options
             );

package/src/config.ts

@@ -5,7 +5,7 @@ import { GraphQLRequestContextExecutionDidStart, Logger } from "apollo-server-ty
 import { ServiceDefinition } from "@apollo/federation";
 import { GraphQLDataSource } from './datasources/types';
 import { QueryPlan } from '@apollo/query-planner';
-import { OperationContext } from './';
+import { OperationContext } from './operationContext';
 import { ServiceMap } from './executeQueryPlan';
 
 export type ServiceEndpointDefinition = Pick<ServiceDefinition, 'name' | 'url'>;
@@ -127,17 +127,19 @@ interface GatewayConfigBase {
   fetcher?: typeof fetch;
   serviceHealthCheck?: boolean;
   /**
-   * @deprecated This configuration option shouldn't be used unless by
-   *             recommendation from Apollo staff. This behavior will be
-   *             defaulted in a future release and this option will strictly be
-   *             used as an override.
+   * Enable an upcoming mechanism for fetching a graph’s schema and
+   * configuration when using managed federation. This mechanism is currently in
+   * a preview state and should not be used in production graphs.
+   * See https://go.apollo.dev/g/supergraph-preview for details.
    */
   experimental_schemaConfigDeliveryEndpoint?: null | string;
 }
 
 export interface RemoteGatewayConfig extends GatewayConfigBase {
   serviceList: ServiceEndpointDefinition[];
-  introspectionHeaders?: HeadersInit;
+  introspectionHeaders?:
+    | HeadersInit
+    | ((service: ServiceEndpointDefinition) => Promise<HeadersInit> | HeadersInit);
 }
 
 // TODO(trevor:cloudconfig): This type goes away

package/src/datasources/RemoteGraphQLDataSource.ts

@@ -78,10 +78,6 @@ export class RemoteGraphQLDataSource<TContext extends Record<string, any> = Reco
       throw new Error("Missing query");
     }
 
-    const apqHash = createSHA('sha256')
-       .update(request.query)
-       .digest('hex');
-
     const { query, ...requestWithoutQuery } = request;
 
     const respond = (response: GraphQLResponse, request: GraphQLRequest) =>
@@ -90,6 +86,10 @@ export class RemoteGraphQLDataSource<TContext extends Record<string, any> = Reco
         : response;
 
     if (this.apq) {
+      const apqHash = createSHA('sha256')
+        .update(request.query)
+        .digest('hex');
+
       // Take the original extensions and extend them with
       // the necessary "extensions" for APQ handshaking.
       requestWithoutQuery.extensions = {
@@ -140,9 +140,10 @@ export class RemoteGraphQLDataSource<TContext extends Record<string, any> = Reco
     // being transmitted.  Instead, we want those to be used to indicate what
     // we're accessing (e.g. url) and what we access it with (e.g. headers).
     const { http, ...requestWithoutHttp } = request;
+    const stringifiedRequestWithoutHttp = JSON.stringify(requestWithoutHttp);
     const fetchRequest = new Request(http.url, {
       ...http,
-      body: JSON.stringify(requestWithoutHttp),
+      body: stringifiedRequestWithoutHttp,
     });
 
     let fetchResponse: Response | undefined;
@@ -152,7 +153,7 @@ export class RemoteGraphQLDataSource<TContext extends Record<string, any> = Reco
       // Use the fetcher's `Request` implementation for compatibility
       fetchResponse = await this.fetcher(http.url, {
         ...http,
-        body: JSON.stringify(requestWithoutHttp)
+        body: stringifiedRequestWithoutHttp,
       });
 
       if (!fetchResponse.ok) {

package/src/executeQueryPlan.ts

@@ -14,7 +14,7 @@ import {
 import { Trace, google } from 'apollo-reporting-protobuf';
 import { defaultRootOperationNameLookup } from '@apollo/federation';
 import { GraphQLDataSource } from './datasources/types';
-import { OperationContext } from './';
+import { OperationContext } from './operationContext';
 import {
   FetchNode,
   PlanNode,

package/src/index.ts

@@ -18,8 +18,6 @@ import {
   VariableDefinitionNode,
   DocumentNode,
   print,
-  FragmentDefinitionNode,
-  OperationDefinitionNode,
   parse,
 } from 'graphql';
 import {
@@ -29,7 +27,7 @@ import {
 } from '@apollo/federation';
 import loglevel from 'loglevel';
 
-import { buildQueryPlan, buildOperationContext } from './buildQueryPlan';
+import { buildOperationContext, OperationContext } from './operationContext';
 import {
   executeQueryPlan,
   ServiceMap,
@@ -43,7 +41,7 @@ import { getVariableValues } from 'graphql/execution/values';
 import fetcher from 'make-fetch-happen';
 import { HttpRequestCache } from './cache';
 import { fetch } from 'apollo-server-env';
-import { getQueryPlanner, QueryPlannerPointer, QueryPlan, prettyFormatQueryPlan } from '@apollo/query-planner';
+import { QueryPlanner, QueryPlan, prettyFormatQueryPlan } from '@apollo/query-planner';
 import {
   ServiceEndpointDefinition,
   Experimental_DidFailCompositionCallback,
@@ -73,16 +71,6 @@ import { loadSupergraphSdlFromStorage } from './loadSupergraphSdlFromStorage';
 import { getServiceDefinitionsFromStorage } from './legacyLoadServicesFromStorage';
 import { buildComposedSchema } from '@apollo/query-planner';
 
-type FragmentMap = { [fragmentName: string]: FragmentDefinitionNode };
-
-export type OperationContext = {
-  schema: GraphQLSchema;
-  operation: OperationDefinitionNode;
-  fragments: FragmentMap;
-  queryPlannerPointer: QueryPlannerPointer;
-  operationString: string;
-};
-
 type DataSourceMap = {
   [serviceName: string]: { url?: string; dataSource: GraphQLDataSource };
 };
@@ -160,7 +148,7 @@ export class ApolloGateway implements GraphQLService {
   private compositionMetadata?: CompositionMetadata;
   private serviceSdlCache = new Map<string, string>();
   private warnedStates: WarnedStates = Object.create(null);
-  private queryPlannerPointer?: QueryPlannerPointer;
+  private queryPlanner?: QueryPlanner;
   private parsedSupergraphSdl?: DocumentNode;
   private fetcher: typeof fetch;
   private compositionId?: string;
@@ -367,7 +355,7 @@ export class ApolloGateway implements GraphQLService {
 
     this.maybeWarnOnConflictingConfig();
 
-    // Handles initial assignment of `this.schema`, `this.queryPlannerPointer`
+    // Handles initial assignment of `this.schema`, `this.queryPlanner`
     isStaticConfig(this.config)
       ? this.loadStatic(this.config)
       : await this.loadDynamic(unrefTimer);
@@ -404,7 +392,7 @@ export class ApolloGateway implements GraphQLService {
     this.schema = schema;
     // TODO(trevor): #580 redundant parse
     this.parsedSupergraphSdl = parse(supergraphSdl);
-    this.queryPlannerPointer = getQueryPlanner(supergraphSdl);
+    this.queryPlanner = new QueryPlanner(schema);
     this.state = { phase: 'loaded' };
   }
 
@@ -482,7 +470,7 @@ export class ApolloGateway implements GraphQLService {
       );
     } else {
       this.schema = schema;
-      this.queryPlannerPointer = getQueryPlanner(supergraphSdl);
+      this.queryPlanner = new QueryPlanner(schema);
 
       // Notify the schema listeners of the updated schema
       try {
@@ -555,7 +543,7 @@ export class ApolloGateway implements GraphQLService {
       );
     } else {
       this.schema = schema;
-      this.queryPlannerPointer = getQueryPlanner(supergraphSdl);
+      this.queryPlanner = new QueryPlanner(schema);
 
       // Notify the schema listeners of the updated schema
       try {
@@ -707,12 +695,7 @@ export class ApolloGateway implements GraphQLService {
       throw Error(`Couldn't find graph map in composed schema`);
     }
 
-    const serviceList = Object.values(graphMap).map(graph => ({
-      name: graph.name,
-      url: graph.url
-    }))
-
-    return serviceList;
+    return Array.from(graphMap.values());
   }
 
   private createSchemaFromSupergraphSdl(supergraphSdl: string) {
@@ -868,9 +851,11 @@ export class ApolloGateway implements GraphQLService {
 
       return getServiceDefinitionsFromRemoteEndpoint({
         serviceList,
-        ...(config.introspectionHeaders
-          ? { headers: config.introspectionHeaders }
-          : {}),
+        async getServiceIntrospectionHeaders(service) {
+          return typeof config.introspectionHeaders === 'function'
+            ? await config.introspectionHeaders(service)
+            : config.introspectionHeaders;
+        },
         serviceSdlCache: this.serviceSdlCache,
       });
     }
@@ -943,13 +928,11 @@ export class ApolloGateway implements GraphQLService {
   public executor = async <TContext>(
     requestContext: GraphQLRequestContextExecutionDidStart<TContext>,
   ): Promise<GraphQLExecutionResult> => {
-    const { request, document, queryHash, source } = requestContext;
+    const { request, document, queryHash } = requestContext;
     const queryPlanStoreKey = queryHash + (request.operationName || '');
     const operationContext = buildOperationContext({
       schema: this.schema!,
       operationDocument: document,
-      operationString: source,
-      queryPlannerPointer: this.queryPlannerPointer!,
       operationName: request.operationName,
     });
 
@@ -970,7 +953,8 @@ export class ApolloGateway implements GraphQLService {
     }
 
     if (!queryPlan) {
-      queryPlan = buildQueryPlan(operationContext, {
+      // TODO(#631): Can we be sure the query planner has been initialized here?
+      queryPlan = this.queryPlanner!.buildQueryPlan(operationContext, {
         autoFragmentization: Boolean(
           this.config.experimental_autoFragmentization,
         ),
@@ -1175,7 +1159,6 @@ class UnreachableCaseError extends Error {
 }
 
 export {
-  buildQueryPlan,
   executeQueryPlan,
   buildOperationContext,
   ServiceMap,

package/src/loadServicesFromRemoteEndpoint.ts

@@ -3,20 +3,22 @@ import { parse } from 'graphql';
 import { Headers, HeadersInit } from 'node-fetch';
 import { GraphQLDataSource } from './datasources/types';
 import { SERVICE_DEFINITION_QUERY } from './';
-import { CompositionUpdate } from './config';
+import { CompositionUpdate, ServiceEndpointDefinition } from './config';
 import { ServiceDefinition } from '@apollo/federation';
 
+type Service = ServiceEndpointDefinition & {
+  dataSource: GraphQLDataSource;
+};
+
 export async function getServiceDefinitionsFromRemoteEndpoint({
   serviceList,
-  headers = {},
+  getServiceIntrospectionHeaders,
   serviceSdlCache,
 }: {
-  serviceList: {
-    name: string;
-    url?: string;
-    dataSource: GraphQLDataSource;
-  }[];
-  headers?: HeadersInit;
+  serviceList: Service[];
+  getServiceIntrospectionHeaders: (
+    service: ServiceEndpointDefinition,
+  ) => Promise<HeadersInit | undefined>;
   serviceSdlCache: Map<string, string>;
 }): Promise<CompositionUpdate> {
   if (!serviceList || !serviceList.length) {
@@ -27,7 +29,7 @@ export async function getServiceDefinitionsFromRemoteEndpoint({
 
   let isNewSchema = false;
   // for each service, fetch its introspection schema
-  const promiseOfServiceList = serviceList.map(({ name, url, dataSource }) => {
+  const promiseOfServiceList = serviceList.map(async ({ name, url, dataSource }) => {
     if (!url) {
       throw new Error(
         `Tried to load schema for '${name}' but no 'url' was specified.`);
@@ -38,7 +40,7 @@ export async function getServiceDefinitionsFromRemoteEndpoint({
       http: {
         url,
         method: 'POST',
-        headers: new Headers(headers),
+        headers: new Headers(await getServiceIntrospectionHeaders({ name, url })),
       },
     };
 

package/src/{buildQueryPlan.ts → operationContext.ts}

@@ -5,41 +5,26 @@ import {
   GraphQLSchema,
   Kind,
   OperationDefinitionNode,
-  print,
 } from 'graphql';
-import { OperationContext } from './';
-import { getQueryPlan, QueryPlan, QueryPlannerPointer } from '@apollo/query-planner';
 
-export interface BuildQueryPlanOptions {
-  autoFragmentization: boolean;
-}
-
-export function buildQueryPlan(
-  operationContext: OperationContext,
-  options: BuildQueryPlanOptions = { autoFragmentization: false },
-): QueryPlan {
+type FragmentMap = { [fragmentName: string]: FragmentDefinitionNode };
 
-  return getQueryPlan(
-    operationContext.queryPlannerPointer,
-    operationContext.operationString,
-    options
-  );
-}
+export type OperationContext = {
+  schema: GraphQLSchema;
+  operation: OperationDefinitionNode;
+  fragments: FragmentMap;
+};
 
 // Adapted from buildExecutionContext in graphql-js
 interface BuildOperationContextOptions {
   schema: GraphQLSchema;
   operationDocument: DocumentNode;
-  operationString: string;
-  queryPlannerPointer: QueryPlannerPointer;
   operationName?: string;
 };
 
 export function buildOperationContext({
   schema,
   operationDocument,
-  operationString,
-  queryPlannerPointer,
   operationName,
 }: BuildOperationContextOptions): OperationContext {
   let operation: OperationDefinitionNode | undefined;
@@ -77,23 +62,9 @@ export function buildOperationContext({
     }
   }
 
-  // In the case of multiple operations specified (operationName presence validated above),
-  // `operation` === the operation specified by `operationName`
-  const trimmedOperationString = operationCount > 1
-    ? print({
-      kind: Kind.DOCUMENT,
-      definitions: [
-        operation,
-        ...Object.values(fragments),
-      ],
-    })
-    : operationString;
-
   return {
     schema,
     operation,
     fragments,
-    queryPlannerPointer,
-    operationString: trimmedOperationString
   };
 }

package/src/utilities/assert.ts

@@ -0,0 +1,14 @@
+/**
+ * For lack of a "home of federation utilities", this function is copy/pasted
+ * verbatim across the federation, gateway, and query-planner packages. Any changes
+ * made here should be reflected in the other two locations as well.
+ *
+ * @param condition
+ * @param message
+ * @throws {@link Error}
+ */
+export function assert(condition: any, message: string): asserts condition {
+  if (!condition) {
+    throw new Error(message);
+  }
+}