@apollo/gateway 0.43.1 → 2.0.0-alpha.1

package/src/__tests__/loadSupergraphSdlFromStorage.test.ts

@@ -36,313 +36,388 @@ describe('loadSupergraphSdlFromStorage', () => {
       Object {
         "id": "originalId-1234",
         "supergraphSdl": "schema
-        @core(feature: \\"https://specs.apollo.dev/core/v0.2\\"),
-        @core(feature: \\"https://specs.apollo.dev/join/v0.1\\", for: EXECUTION),
+        @core(feature: \\"https://specs.apollo.dev/core/v0.2\\")
+        @core(feature: \\"https://specs.apollo.dev/join/v0.2\\", for: EXECUTION)
         @core(feature: \\"https://specs.apollo.dev/tag/v0.1\\")
       {
         query: Query
         mutation: Mutation
       }
 
-      directive @core(as: String, feature: String!, for: core__Purpose) repeatable on SCHEMA
+      directive @core(feature: String!, as: String, for: core__Purpose) repeatable on SCHEMA
 
-      directive @join__field(graph: join__Graph, provides: join__FieldSet, requires: join__FieldSet) on FIELD_DEFINITION
+      directive @join__field(graph: join__Graph!, requires: join__FieldSet, provides: join__FieldSet, type: String, external: Boolean) repeatable on FIELD_DEFINITION | INPUT_FIELD_DEFINITION
 
       directive @join__graph(name: String!, url: String!) on ENUM_VALUE
 
-      directive @join__owner(graph: join__Graph!) on INTERFACE | OBJECT
+      directive @join__implements(graph: join__Graph!, interface: String!) repeatable on OBJECT | INTERFACE
 
-      directive @join__type(graph: join__Graph!, key: join__FieldSet) repeatable on INTERFACE | OBJECT
+      directive @join__type(graph: join__Graph!, key: join__FieldSet, extension: Boolean! = false) repeatable on OBJECT | INTERFACE | UNION | ENUM | INPUT_OBJECT | SCALAR
 
       directive @stream on FIELD
 
-      directive @tag(name: String!) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION
+      directive @tag(name: String!) repeatable on FIELD_DEFINITION | OBJECT | INTERFACE | UNION
 
       directive @transform(from: String!) on FIELD
 
       union AccountType
+        @join__type(graph: ACCOUNTS)
         @tag(name: \\"from-accounts\\")
-      = PasswordAccount | SMSAccount
+       = PasswordAccount | SMSAccount
 
-      type Amazon {
+      type Amazon
+        @join__type(graph: PRODUCT)
+      {
         referrer: String
       }
 
-      union Body = Image | Text
+      union Body
+        @join__type(graph: DOCUMENTS)
+       = Image | Text
 
       type Book implements Product
-        @join__owner(graph: BOOKS)
+        @join__implements(graph: INVENTORY, interface: \\"Product\\")
+        @join__implements(graph: PRODUCT, interface: \\"Product\\")
+        @join__implements(graph: REVIEWS, interface: \\"Product\\")
         @join__type(graph: BOOKS, key: \\"isbn\\")
-        @join__type(graph: INVENTORY, key: \\"isbn\\")
-        @join__type(graph: PRODUCT, key: \\"isbn\\")
-        @join__type(graph: REVIEWS, key: \\"isbn\\")
+        @join__type(graph: INVENTORY, key: \\"isbn\\", extension: true)
+        @join__type(graph: PRODUCT, key: \\"isbn\\", extension: true)
+        @join__type(graph: REVIEWS, key: \\"isbn\\", extension: true)
       {
-        details: ProductDetailsBook @join__field(graph: PRODUCT)
+        isbn: String!
+        title: String @join__field(graph: BOOKS) @join__field(graph: PRODUCT, external: true)
+        year: Int @join__field(graph: BOOKS) @join__field(graph: PRODUCT, external: true)
+        similarBooks: [Book]! @join__field(graph: BOOKS) @join__field(graph: REVIEWS, external: true)
+        metadata: [MetadataOrError] @join__field(graph: BOOKS)
         inStock: Boolean @join__field(graph: INVENTORY)
         isCheckedOut: Boolean @join__field(graph: INVENTORY)
-        isbn: String! @join__field(graph: BOOKS)
-        metadata: [MetadataOrError] @join__field(graph: BOOKS)
+        upc: String! @join__field(graph: PRODUCT)
+        sku: String! @join__field(graph: PRODUCT)
         name(delimeter: String = \\" \\"): String @join__field(graph: PRODUCT, requires: \\"title year\\")
         price: String @join__field(graph: PRODUCT)
-        relatedReviews: [Review!]! @join__field(graph: REVIEWS, requires: \\"similarBooks{isbn}\\")
+        details: ProductDetailsBook @join__field(graph: PRODUCT)
         reviews: [Review] @join__field(graph: REVIEWS)
-        similarBooks: [Book]! @join__field(graph: BOOKS)
-        sku: String! @join__field(graph: PRODUCT)
-        title: String @join__field(graph: BOOKS)
-        upc: String! @join__field(graph: PRODUCT)
-        year: Int @join__field(graph: BOOKS)
+        relatedReviews: [Review!]! @join__field(graph: REVIEWS, requires: \\"similarBooks { isbn }\\")
       }
 
-      union Brand = Amazon | Ikea
+      union Brand
+        @join__type(graph: PRODUCT)
+       = Ikea | Amazon
 
-      enum CacheControlScope {
-        PRIVATE
+      enum CacheControlScope
+        @join__type(graph: ACCOUNTS)
+        @join__type(graph: BOOKS)
+        @join__type(graph: PRODUCT)
+      {
         PUBLIC
+        PRIVATE
       }
 
       type Car implements Vehicle
-        @join__owner(graph: PRODUCT)
+        @join__implements(graph: PRODUCT, interface: \\"Vehicle\\")
+        @join__implements(graph: REVIEWS, interface: \\"Vehicle\\")
         @join__type(graph: PRODUCT, key: \\"id\\")
-        @join__type(graph: REVIEWS, key: \\"id\\")
+        @join__type(graph: REVIEWS, key: \\"id\\", extension: true)
       {
+        id: String!
         description: String @join__field(graph: PRODUCT)
-        id: String! @join__field(graph: PRODUCT)
-        price: String @join__field(graph: PRODUCT)
+        price: String @join__field(graph: PRODUCT) @join__field(graph: REVIEWS, external: true)
         retailPrice: String @join__field(graph: REVIEWS, requires: \\"price\\")
       }
 
-      type Error {
+      enum core__Purpose {
+        \\"\\"\\"
+        \`SECURITY\` features provide metadata necessary to securely resolve fields.
+        \\"\\"\\"
+        SECURITY
+
+        \\"\\"\\"
+        \`EXECUTION\` features provide metadata necessary for operation execution.
+        \\"\\"\\"
+        EXECUTION
+      }
+
+      type Error
+        @join__type(graph: BOOKS)
+        @join__type(graph: PRODUCT)
+        @join__type(graph: REVIEWS)
+      {
         code: Int
         message: String
       }
 
       type Furniture implements Product
-        @join__owner(graph: PRODUCT)
+        @join__implements(graph: INVENTORY, interface: \\"Product\\")
+        @join__implements(graph: PRODUCT, interface: \\"Product\\")
+        @join__implements(graph: REVIEWS, interface: \\"Product\\")
+        @join__type(graph: INVENTORY, key: \\"sku\\", extension: true)
         @join__type(graph: PRODUCT, key: \\"upc\\")
         @join__type(graph: PRODUCT, key: \\"sku\\")
-        @join__type(graph: INVENTORY, key: \\"sku\\")
-        @join__type(graph: REVIEWS, key: \\"upc\\")
+        @join__type(graph: REVIEWS, key: \\"upc\\", extension: true)
       {
-        brand: Brand @join__field(graph: PRODUCT)
-        details: ProductDetailsFurniture @join__field(graph: PRODUCT)
+        sku: String! @join__field(graph: INVENTORY) @join__field(graph: PRODUCT)
         inStock: Boolean @join__field(graph: INVENTORY)
         isHeavy: Boolean @join__field(graph: INVENTORY)
-        metadata: [MetadataOrError] @join__field(graph: PRODUCT)
+        upc: String! @join__field(graph: PRODUCT) @join__field(graph: REVIEWS)
         name: String @join__field(graph: PRODUCT)
         price: String @join__field(graph: PRODUCT)
+        brand: Brand @join__field(graph: PRODUCT)
+        metadata: [MetadataOrError] @join__field(graph: PRODUCT)
+        details: ProductDetailsFurniture @join__field(graph: PRODUCT)
         reviews: [Review] @join__field(graph: REVIEWS)
-        sku: String! @join__field(graph: PRODUCT)
-        upc: String! @join__field(graph: PRODUCT)
       }
 
-      type Ikea {
+      type Ikea
+        @join__type(graph: PRODUCT)
+      {
         asile: Int
       }
 
-      type Image implements NamedObject {
-        attributes: ImageAttributes!
+      type Image implements NamedObject
+        @join__implements(graph: DOCUMENTS, interface: \\"NamedObject\\")
+        @join__type(graph: DOCUMENTS)
+      {
         name: String!
+        attributes: ImageAttributes!
       }
 
-      type ImageAttributes {
+      type ImageAttributes
+        @join__type(graph: DOCUMENTS)
+      {
         url: String!
       }
 
-      scalar JSON @specifiedBy(url: \\"https://json-spec.dev\\")
+      scalar join__FieldSet
 
-      type KeyValue {
+      enum join__Graph {
+        ACCOUNTS @join__graph(name: \\"accounts\\", url: \\"https://accounts.api.com\\")
+        BOOKS @join__graph(name: \\"books\\", url: \\"https://books.api.com\\")
+        DOCUMENTS @join__graph(name: \\"documents\\", url: \\"https://documents.api.com\\")
+        INVENTORY @join__graph(name: \\"inventory\\", url: \\"https://inventory.api.com\\")
+        PRODUCT @join__graph(name: \\"product\\", url: \\"https://product.api.com\\")
+        REVIEWS @join__graph(name: \\"reviews\\", url: \\"https://reviews.api.com\\")
+      }
+
+      scalar JSON
+        @join__type(graph: ACCOUNTS)
+        @specifiedBy(url: \\"https://json-spec.dev\\")
+
+      type KeyValue
+        @join__type(graph: BOOKS)
+        @join__type(graph: PRODUCT)
+        @join__type(graph: REVIEWS)
+      {
         key: String!
         value: String!
       }
 
       type Library
-        @join__owner(graph: BOOKS)
+        @join__type(graph: ACCOUNTS, key: \\"id\\", extension: true)
         @join__type(graph: BOOKS, key: \\"id\\")
-        @join__type(graph: ACCOUNTS, key: \\"id\\")
       {
-        id: ID! @join__field(graph: BOOKS)
-        name: String @join__field(graph: BOOKS)
+        id: ID!
+        name: String @join__field(graph: ACCOUNTS, external: true) @join__field(graph: BOOKS)
         userAccount(id: ID! = 1): User @join__field(graph: ACCOUNTS, requires: \\"name\\")
       }
 
-      union MetadataOrError = Error | KeyValue
+      union MetadataOrError
+        @join__type(graph: BOOKS)
+        @join__type(graph: PRODUCT)
+        @join__type(graph: REVIEWS)
+       = KeyValue | Error
 
-      type Mutation {
-        deleteReview(id: ID!): Boolean @join__field(graph: REVIEWS)
-        login(password: String!, userId: String @deprecated(reason: \\"Use username instead\\"), username: String!): User @join__field(graph: ACCOUNTS)
+      type Mutation
+        @join__type(graph: ACCOUNTS)
+        @join__type(graph: REVIEWS)
+      {
+        login(username: String!, password: String!, userId: String @deprecated(reason: \\"Use username instead\\")): User @join__field(graph: ACCOUNTS)
         reviewProduct(input: ReviewProduct!): Product @join__field(graph: REVIEWS)
         updateReview(review: UpdateReviewInput!): Review @join__field(graph: REVIEWS)
+        deleteReview(id: ID!): Boolean @join__field(graph: REVIEWS)
       }
 
-      type Name {
+      type Name
+        @join__type(graph: ACCOUNTS)
+      {
         first: String
         last: String
       }
 
-      interface NamedObject {
+      interface NamedObject
+        @join__type(graph: DOCUMENTS)
+      {
         name: String!
       }
 
       type PasswordAccount
-        @join__owner(graph: ACCOUNTS)
         @join__type(graph: ACCOUNTS, key: \\"email\\")
       {
-        email: String! @join__field(graph: ACCOUNTS)
+        email: String!
       }
 
       interface Product
+        @join__type(graph: INVENTORY)
+        @join__type(graph: PRODUCT)
+        @join__type(graph: REVIEWS)
         @tag(name: \\"from-reviews\\")
       {
-        details: ProductDetails
-        inStock: Boolean
-        name: String
-        price: String
-        reviews: [Review]
-        sku: String!
-        upc: String!
+        inStock: Boolean @join__field(graph: INVENTORY)
+        upc: String! @join__field(graph: PRODUCT)
+        sku: String! @join__field(graph: PRODUCT)
+        name: String @join__field(graph: PRODUCT)
+        price: String @join__field(graph: PRODUCT)
+        details: ProductDetails @join__field(graph: PRODUCT)
+        reviews: [Review] @join__field(graph: REVIEWS)
       }
 
-      interface ProductDetails {
+      interface ProductDetails
+        @join__type(graph: PRODUCT)
+      {
         country: String
       }
 
-      type ProductDetailsBook implements ProductDetails {
+      type ProductDetailsBook implements ProductDetails
+        @join__implements(graph: PRODUCT, interface: \\"ProductDetails\\")
+        @join__type(graph: PRODUCT)
+      {
         country: String
         pages: Int
       }
 
-      type ProductDetailsFurniture implements ProductDetails {
-        color: String
+      type ProductDetailsFurniture implements ProductDetails
+        @join__implements(graph: PRODUCT, interface: \\"ProductDetails\\")
+        @join__type(graph: PRODUCT)
+      {
         country: String
+        color: String
       }
 
-      type Query {
-        body: Body! @join__field(graph: DOCUMENTS)
+      type Query
+        @join__type(graph: ACCOUNTS)
+        @join__type(graph: BOOKS)
+        @join__type(graph: DOCUMENTS)
+        @join__type(graph: INVENTORY)
+        @join__type(graph: PRODUCT)
+        @join__type(graph: REVIEWS)
+      {
+        user(id: ID!): User @join__field(graph: ACCOUNTS)
+        me: User @join__field(graph: ACCOUNTS)
         book(isbn: String!): Book @join__field(graph: BOOKS)
         books: [Book] @join__field(graph: BOOKS)
         library(id: ID!): Library @join__field(graph: BOOKS)
-        me: User @join__field(graph: ACCOUNTS)
+        body: Body! @join__field(graph: DOCUMENTS)
         product(upc: String!): Product @join__field(graph: PRODUCT)
-        topCars(first: Int = 5): [Car] @join__field(graph: PRODUCT)
+        vehicle(id: String!): Vehicle @join__field(graph: PRODUCT)
         topProducts(first: Int = 5): [Product] @join__field(graph: PRODUCT)
+        topCars(first: Int = 5): [Car] @join__field(graph: PRODUCT)
         topReviews(first: Int = 5): [Review] @join__field(graph: REVIEWS)
-        user(id: ID!): User @join__field(graph: ACCOUNTS)
-        vehicle(id: String!): Vehicle @join__field(graph: PRODUCT)
       }
 
       type Review
-        @join__owner(graph: REVIEWS)
         @join__type(graph: REVIEWS, key: \\"id\\")
       {
+        id: ID!
+        body(format: Boolean = false): String
         author: User @join__field(graph: REVIEWS, provides: \\"username\\")
-        body(format: Boolean = false): String @join__field(graph: REVIEWS)
-        id: ID! @join__field(graph: REVIEWS)
-        metadata: [MetadataOrError] @join__field(graph: REVIEWS)
-        product: Product @join__field(graph: REVIEWS)
+        product: Product
+        metadata: [MetadataOrError]
       }
 
-      input ReviewProduct {
+      input ReviewProduct
+        @join__type(graph: REVIEWS)
+      {
+        upc: String!
         body: String!
         stars: Int @deprecated(reason: \\"Stars are no longer in use\\")
-        upc: String!
       }
 
       type SMSAccount
-        @join__owner(graph: ACCOUNTS)
         @join__type(graph: ACCOUNTS, key: \\"number\\")
       {
-        number: String @join__field(graph: ACCOUNTS)
+        number: String
       }
 
-      type Text implements NamedObject {
-        attributes: TextAttributes!
+      type Text implements NamedObject
+        @join__implements(graph: DOCUMENTS, interface: \\"NamedObject\\")
+        @join__type(graph: DOCUMENTS)
+      {
         name: String!
+        attributes: TextAttributes!
       }
 
-      type TextAttributes {
+      type TextAttributes
+        @join__type(graph: DOCUMENTS)
+      {
         bold: Boolean
         text: String
       }
 
-      union Thing = Car | Ikea
+      union Thing
+        @join__type(graph: PRODUCT)
+       = Car | Ikea
 
-      input UpdateReviewInput {
-        body: String
+      input UpdateReviewInput
+        @join__type(graph: REVIEWS)
+      {
         id: ID!
+        body: String
       }
 
       type User
-        @join__owner(graph: ACCOUNTS)
         @join__type(graph: ACCOUNTS, key: \\"id\\")
-        @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\\")
+        @join__type(graph: ACCOUNTS, key: \\"username name { first last }\\")
+        @join__type(graph: INVENTORY, key: \\"id\\", extension: true)
+        @join__type(graph: PRODUCT, key: \\"id\\", extension: true)
+        @join__type(graph: REVIEWS, key: \\"id\\", extension: true)
         @tag(name: \\"from-accounts\\")
         @tag(name: \\"from-reviews\\")
       {
-        account: AccountType @join__field(graph: ACCOUNTS)
-        birthDate(locale: String): String @join__field(graph: ACCOUNTS) @tag(name: \\"admin\\") @tag(name: \\"dev\\")
-        goodAddress: Boolean @join__field(graph: REVIEWS, requires: \\"metadata{address}\\")
-        goodDescription: Boolean @join__field(graph: INVENTORY, requires: \\"metadata{description}\\")
-        id: ID! @join__field(graph: ACCOUNTS) @tag(name: \\"accounts\\") @tag(name: \\"on-external\\")
-        metadata: [UserMetadata] @join__field(graph: ACCOUNTS)
+        id: ID! @tag(name: \\"accounts\\")
         name: Name @join__field(graph: ACCOUNTS)
-        numberOfReviews: Int! @join__field(graph: REVIEWS)
-        reviews: [Review] @join__field(graph: REVIEWS)
+        username: String @join__field(graph: ACCOUNTS) @join__field(graph: REVIEWS, external: true)
+        birthDate(locale: String): String @tag(name: \\"admin\\") @tag(name: \\"dev\\") @join__field(graph: ACCOUNTS)
+        account: AccountType @join__field(graph: ACCOUNTS)
+        metadata: [UserMetadata] @join__field(graph: ACCOUNTS) @join__field(graph: INVENTORY, external: true) @join__field(graph: REVIEWS, external: true)
         ssn: String @join__field(graph: ACCOUNTS)
-        thing: Thing @join__field(graph: PRODUCT)
-        username: String @join__field(graph: ACCOUNTS)
+        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 }\\")
       }
 
-      type UserMetadata {
-        address: String
-        description: String
-        name: String
+      type UserMetadata
+        @join__type(graph: ACCOUNTS)
+        @join__type(graph: INVENTORY)
+        @join__type(graph: REVIEWS)
+      {
+        name: String @join__field(graph: ACCOUNTS)
+        address: String @join__field(graph: ACCOUNTS) @join__field(graph: REVIEWS, external: true)
+        description: String @join__field(graph: ACCOUNTS) @join__field(graph: INVENTORY, external: true)
       }
 
       type Van implements Vehicle
-        @join__owner(graph: PRODUCT)
+        @join__implements(graph: PRODUCT, interface: \\"Vehicle\\")
+        @join__implements(graph: REVIEWS, interface: \\"Vehicle\\")
         @join__type(graph: PRODUCT, key: \\"id\\")
-        @join__type(graph: REVIEWS, key: \\"id\\")
+        @join__type(graph: REVIEWS, key: \\"id\\", extension: true)
       {
+        id: String!
         description: String @join__field(graph: PRODUCT)
-        id: String! @join__field(graph: PRODUCT)
-        price: String @join__field(graph: PRODUCT)
+        price: String @join__field(graph: PRODUCT) @join__field(graph: REVIEWS, external: true)
         retailPrice: String @join__field(graph: REVIEWS, requires: \\"price\\")
       }
 
-      interface Vehicle {
-        description: String
-        id: String!
-        price: String
-        retailPrice: String
-      }
-
-      enum core__Purpose {
-        \\"\\"\\"
-        \`EXECUTION\` features provide metadata necessary to for operation execution.
-        \\"\\"\\"
-        EXECUTION
-
-        \\"\\"\\"
-        \`SECURITY\` features provide metadata necessary to securely resolve fields.
-        \\"\\"\\"
-        SECURITY
-      }
-
-      scalar join__FieldSet
-
-      enum join__Graph {
-        ACCOUNTS @join__graph(name: \\"accounts\\" url: \\"https://accounts.api.com\\")
-        BOOKS @join__graph(name: \\"books\\" url: \\"https://books.api.com\\")
-        DOCUMENTS @join__graph(name: \\"documents\\" url: \\"https://documents.api.com\\")
-        INVENTORY @join__graph(name: \\"inventory\\" url: \\"https://inventory.api.com\\")
-        PRODUCT @join__graph(name: \\"product\\" url: \\"https://product.api.com\\")
-        REVIEWS @join__graph(name: \\"reviews\\" url: \\"https://reviews.api.com\\")
-      }
-      ",
+      interface Vehicle
+        @join__type(graph: PRODUCT)
+        @join__type(graph: REVIEWS)
+      {
+        id: String! @join__field(graph: PRODUCT)
+        description: String @join__field(graph: PRODUCT)
+        price: String @join__field(graph: PRODUCT)
+        retailPrice: String @join__field(graph: REVIEWS)
+      }",
       }
     `);
   });

package/src/__tests__/queryPlanCucumber.test.ts

@@ -2,9 +2,9 @@ import gql from 'graphql-tag';
 import { defineFeature, loadFeature } from 'jest-cucumber';
 import { DocumentNode } from 'graphql';
 
-import { QueryPlan, BuildQueryPlanOptions } from '@apollo/query-planner';
-import { buildOperationContext } from '../operationContext';
+import { QueryPlan } from '@apollo/query-planner';
 import { getFederatedTestingSchema } from './execution-utils';
+import { operationFromDocument } from '@apollo/federation-internals';
 
 const buildQueryPlanFeature = loadFeature(
   './gateway-js/src/__tests__/build-query-plan.feature'
@@ -18,10 +18,9 @@ const features = [
 features.forEach((feature) => {
   defineFeature(feature, (test) => {
     feature.scenarios.forEach((scenario) => {
-      test(scenario.title, async ({ given, when, then }) => {
+      test(scenario.title, async ({ given, then }) => {
         let operationDocument: DocumentNode;
         let queryPlan: QueryPlan;
-        let options: BuildQueryPlanOptions = { autoFragmentization: false };
 
         // throws on composition errors
         const { schema, queryPlanner } = getFederatedTestingSchema();
@@ -32,21 +31,9 @@ features.forEach((feature) => {
           })
         }
 
-        const whenUsingAutoFragmentization = () => {
-          when(/using autofragmentization/i, () => {
-            options = { autoFragmentization: true };
-          })
-        }
-
         const thenQueryPlanShouldBe = () => {
           then(/^query plan$/i, (expectedQueryPlan: string) => {
-            queryPlan = queryPlanner.buildQueryPlan(
-              buildOperationContext({
-                schema,
-                operationDocument,
-              }),
-              options
-            );
+            queryPlan = queryPlanner.buildQueryPlan(operationFromDocument(schema, operationDocument));
 
             const parsedExpectedPlan = JSON.parse(expectedQueryPlan);
 
@@ -59,7 +46,6 @@ features.forEach((feature) => {
         scenario.steps.forEach(({ stepText }) => {
           const title = stepText.toLocaleLowerCase();
           if (title === "query") givenQuery();
-          else if (title === "using autofragmentization") whenUsingAutoFragmentization();
           else if (title === "query plan") thenQueryPlanShouldBe();
           else throw new Error(`Unrecognized steps used in "build-query-plan.feature"`);
         });

package/src/core/__tests__/core.test.ts

@@ -192,6 +192,7 @@ describe('core v0.2', () => {
     const supergraphSdl = `#graphql
       schema
         @core(feature: "https://specs.apollo.dev/core/v0.2")
+        @core(feature: "https://specs.apollo.dev/join/v0.1", for: EXECUTION)
         @core(feature: "https://specs.apollo.dev/tag/v0.1")
         @core(feature: "https://specs.apollo.dev/unsupported-feature/v0.1") {
         query: Query

package/src/executeQueryPlan.ts

@@ -1,7 +1,6 @@
 import {
   GraphQLExecutionResult,
   GraphQLRequestContext,
-  VariableValues,
 } from 'apollo-server-types';
 import { Headers } from 'apollo-server-env';
 import {
@@ -26,7 +25,6 @@ import {
   QueryPlanSelectionNode,
   QueryPlanFieldNode,
   getResponseName,
-  toAPISchema
 } from '@apollo/query-planner';
 import { deepMerge } from './utilities/deepMerge';
 import { isNotNullOrUndefined } from './utilities/array';
@@ -94,7 +92,7 @@ export async function executeQueryPlan<TContext>(
         // the original query.
         // It is also used to allow execution of introspection queries though.
         try {
-          const schema = toAPISchema(operationContext.schema);
+          const schema = operationContext.schema;
           ({ data } = await execute({
             schema,
             document: {
@@ -233,10 +231,6 @@ async function executeNode<TContext>(
       });
     }
     case 'Fetch': {
-      if (shouldSkipFetchNode(node, context.requestContext.request.variables)) {
-        return new Trace.QueryPlanNode();
-      }
-
       const traceNode = new Trace.QueryPlanNode.FetchNode({
         serviceName: node.serviceName,
         // executeFetch will fill in the other fields if desired.
@@ -257,31 +251,6 @@ async function executeNode<TContext>(
   }
 }
 
-export function shouldSkipFetchNode(
-  node: FetchNode,
-  variables: VariableValues = {},
-) {
-  if (!node.inclusionConditions) return false;
-
-  return node.inclusionConditions.every((conditionals) => {
-    function resolveConditionalValue(conditional: 'skip' | 'include') {
-      const conditionalType = typeof conditionals[conditional];
-      if (conditionalType === 'boolean') {
-        return conditionals[conditional] as boolean;
-      } else if (conditionalType === 'string') {
-        return variables[conditionals[conditional] as string] as boolean;
-      } else {
-        return null;
-      }
-    }
-
-    const includeValue = resolveConditionalValue('include');
-    const skipValue = resolveConditionalValue('skip');
-
-    return includeValue === false || skipValue === true;
-  });
-}
-
 async function executeFetch<TContext>(
   context: ExecutionContext<TContext>,
   fetch: FetchNode,