@apollo/gateway 0.43.1 → 2.0.0-alpha.1

package/src/index.ts

@@ -11,14 +11,8 @@ import {
   isIntrospectionType,
   GraphQLSchema,
   VariableDefinitionNode,
-  DocumentNode,
-  print,
-  parse,
-  Source,
 } from 'graphql';
 import {
-  composeAndValidate,
-  compositionHasErrors,
   ServiceDefinition,
 } from '@apollo/federation';
 import loglevel from 'loglevel';
@@ -41,7 +35,6 @@ import {
   QueryPlanner,
   QueryPlan,
   prettyFormatQueryPlan,
-  toAPISchema,
 } from '@apollo/query-planner';
 import {
   ServiceEndpointDefinition,
@@ -71,11 +64,15 @@ import {
 } from './config';
 import { loadSupergraphSdlFromStorage } from './loadSupergraphSdlFromStorage';
 import { getServiceDefinitionsFromStorage } from './legacyLoadServicesFromStorage';
-import { buildComposedSchema } from '@apollo/query-planner';
 import { SpanStatusCode } from '@opentelemetry/api';
 import { OpenTelemetrySpanNames, tracer } from './utilities/opentelemetry';
-import { CoreSchema } from '@apollo/core-schema';
-import { featureSupport } from './core';
+
+import {
+  buildSupergraphSchema,
+  operationFromDocument,
+  Schema,
+} from '@apollo/federation-internals';
+import { composeServices } from '@apollo/composition'
 
 type DataSourceMap = {
   [serviceName: string]: { url?: string; dataSource: GraphQLDataSource };
@@ -176,6 +173,13 @@ interface GraphQLServiceEngineConfig {
 
 export class ApolloGateway implements GraphQLService {
   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`
+  // and make `schema` a getter (though `schema` does rely on `wrapSchemaWithAliasResolver` so this should
+  // be accounted for and this may look ugly). Unsure if moving from a member to a getter could break anyone externally however
+  // (also unclear why we expose a mutable member public in the first place; don't everything break if the
+  // use manually assigns `schema`?).
+  private apiSchema?: Schema;
   private serviceMap: DataSourceMap = Object.create(null);
   private config: GatewayConfig;
   private logger: Logger;
@@ -193,7 +197,7 @@ export class ApolloGateway implements GraphQLService {
   private serviceSdlCache = new Map<string, string>();
   private warnedStates: WarnedStates = Object.create(null);
   private queryPlanner?: QueryPlanner;
-  private parsedSupergraphSdl?: DocumentNode;
+  private supergraphSdl?: string;
   private fetcher: typeof fetch;
   private compositionId?: string;
   private state: GatewayState;
@@ -439,14 +443,13 @@ export class ApolloGateway implements GraphQLService {
   // Synchronously load a statically configured schema, update class instance's
   // schema and query planner.
   private loadStatic(config: StaticGatewayConfig) {
-    let schema: GraphQLSchema;
+    let schema: Schema;
     let supergraphSdl: string;
     try {
       ({ schema, supergraphSdl } = isLocalConfig(config)
         ? this.createSchemaFromServiceList(config.localServiceList)
         : this.createSchemaFromSupergraphSdl(config.supergraphSdl));
-      // TODO(trevor): #580 redundant parse
-      this.parsedSupergraphSdl = parse(supergraphSdl);
+      this.supergraphSdl = supergraphSdl;
       this.updateWithSchemaAndNotify(schema, supergraphSdl, true);
     } catch (e) {
       this.state = { phase: 'failed to load' };
@@ -532,7 +535,7 @@ export class ApolloGateway implements GraphQLService {
         this.experimental_didUpdateComposition(
           {
             serviceDefinitions: result.serviceDefinitions,
-            schema,
+            schema: schema.toGraphQLJSSchema(),
             ...(this.compositionMetadata && {
               compositionMetadata: this.compositionMetadata,
             }),
@@ -558,15 +561,14 @@ export class ApolloGateway implements GraphQLService {
       return;
     }
 
-    // TODO(trevor): #580 redundant parse
     // This may throw, so we'll calculate early (specifically before making any updates)
     // In the case that it throws, the gateway will:
     //   * on initial load, throw the error
     //   * on update, log the error and don't update
-    const parsedSupergraphSdl = parse(result.supergraphSdl);
+    const { schema, supergraphSdl } = this.createSchemaFromSupergraphSdl(result.supergraphSdl);
 
     const previousSchema = this.schema;
-    const previousSupergraphSdl = this.parsedSupergraphSdl;
+    const previousSupergraphSdl = this.supergraphSdl;
     const previousCompositionId = this.compositionId;
 
     if (previousSchema) {
@@ -576,11 +578,8 @@ export class ApolloGateway implements GraphQLService {
     await this.maybePerformServiceHealthCheck(result);
 
     this.compositionId = result.id;
-    this.parsedSupergraphSdl = parsedSupergraphSdl;
+    this.supergraphSdl = result.supergraphSdl;
 
-    const { schema, supergraphSdl } = this.createSchemaFromSupergraphSdl(
-      result.supergraphSdl,
-    );
 
     if (!supergraphSdl) {
       this.logger.error(
@@ -594,12 +593,12 @@ export class ApolloGateway implements GraphQLService {
           {
             compositionId: result.id,
             supergraphSdl: result.supergraphSdl,
-            schema,
+            schema: schema.toGraphQLJSSchema(),
           },
           previousCompositionId && previousSupergraphSdl && previousSchema
             ? {
                 compositionId: previousCompositionId,
-                supergraphSdl: print(previousSupergraphSdl),
+                supergraphSdl: previousSupergraphSdl,
                 schema: previousSchema,
               }
             : undefined,
@@ -612,13 +611,14 @@ export class ApolloGateway implements GraphQLService {
   //       ensure we do not forget to update some of that state, and to avoid scenarios where
   //       concurrently executing code sees partially-updated state.
   private updateWithSchemaAndNotify(
-    coreSchema: GraphQLSchema,
+    coreSchema: Schema,
     coreSupergraphSdl: string,
     // Once we remove the deprecated onSchemaChange() method, we can remove this.
     legacyDontNotifyOnSchemaChangeListeners: boolean = false,
   ): void {
     if (this.queryPlanStore) this.queryPlanStore.flush();
-    this.schema = toAPISchema(coreSchema);
+    this.apiSchema = coreSchema.toAPISchema(); 
+    this.schema = wrapSchemaWithAliasResolver(this.apiSchema.toGraphQLJSSchema());
     this.queryPlanner = new QueryPlanner(coreSchema);
 
     // Notify onSchemaChange listeners of the updated schema
@@ -658,10 +658,9 @@ export class ApolloGateway implements GraphQLService {
     // This is the last chance to bail out of a schema update.
     if (this.config.serviceHealthCheck) {
       const serviceList = isSupergraphSdlUpdate(update)
-        ? // TODO(trevor): #580 redundant parse
-          // Parsing could technically fail and throw here, but parseability has
+        ? // Parsing of the supergraph SDL could technically fail and throw here, but parseability has
           // already been confirmed slightly earlier in the code path
-          this.serviceListFromSupergraphSdl(parse(update.supergraphSdl))
+          this.serviceListFromSupergraphSdl(update.supergraphSdl)
         : // Existence of this is determined in advance with an early return otherwise
           update.serviceDefinitions!;
       // Here we need to construct new datasources based on the new schema info
@@ -726,10 +725,9 @@ export class ApolloGateway implements GraphQLService {
         .join('\n')}`,
     );
 
-    const compositionResult = composeAndValidate(serviceList);
-
-    if (compositionHasErrors(compositionResult)) {
-      const { errors } = compositionResult;
+    const compositionResult = composeServices(serviceList);
+    const errors = compositionResult.errors;
+    if (errors) {
       if (this.experimental_didFailComposition) {
         this.experimental_didFailComposition({
           errors,
@@ -744,60 +742,25 @@ export class ApolloGateway implements GraphQLService {
           errors.map((e) => '\t' + e.message).join('\n'),
       );
     } else {
-      const { supergraphSdl } = compositionResult;
       this.createServices(serviceList);
-
-      const schema = buildComposedSchema(parse(supergraphSdl));
-
       this.logger.debug('Schema loaded and ready for execution');
-
-      // This is a workaround for automatic wrapping of all fields, which Apollo
-      // Server does in the case of implementing resolver wrapping for plugins.
-      // Here we wrap all fields with support for resolving aliases as part of the
-      // root value which happens because aliases are resolved by sub services and
-      // the shape of the root value already contains the aliased fields as
-      // responseNames
       return {
-        schema: wrapSchemaWithAliasResolver(schema),
-        supergraphSdl,
+        schema: compositionResult.schema,
+        supergraphSdl: compositionResult.supergraphSdl,
       };
     }
   }
 
-  private serviceListFromSupergraphSdl(
-    supergraphSdl: DocumentNode,
-  ): Omit<ServiceDefinition, 'typeDefs'>[] {
-    const schema = buildComposedSchema(supergraphSdl);
-    return this.serviceListFromComposedSchema(schema);
-  }
-
-  private serviceListFromComposedSchema(schema: GraphQLSchema) {
-    const graphMap = schema.extensions?.federation?.graphs;
-    if (!graphMap) {
-      throw Error(`Couldn't find graph map in composed schema`);
-    }
-
-    return Array.from(graphMap.values());
+  private serviceListFromSupergraphSdl(supergraphSdl: string): Omit<ServiceDefinition, 'typeDefs'>[] {
+    return buildSupergraphSchema(supergraphSdl)[1];
   }
 
   private createSchemaFromSupergraphSdl(supergraphSdl: string) {
-    const core = CoreSchema.fromSource(
-      new Source(supergraphSdl, 'supergraphSdl'),
-    )
-      .check() // run basic core schema compliance checks
-      .check(featureSupport); // run supported feature check
-
-    // TODO(trevor): #580 redundant parse
-    this.parsedSupergraphSdl = core.document;
-
-    const schema = buildComposedSchema(this.parsedSupergraphSdl);
-
-    const serviceList = this.serviceListFromComposedSchema(schema);
-
+    const [schema, serviceList] = buildSupergraphSchema(supergraphSdl);
     this.createServices(serviceList);
 
     return {
-      schema: wrapSchemaWithAliasResolver(schema),
+      schema,
       supergraphSdl,
     };
   }
@@ -1059,7 +1022,6 @@ 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);
@@ -1070,12 +1032,9 @@ export class ApolloGateway implements GraphQLService {
               OpenTelemetrySpanNames.PLAN,
               (span) => {
                 try {
+                  const operation = operationFromDocument(this.apiSchema!, document, request.operationName);
                   // TODO(#631): Can we be sure the query planner has been initialized here?
-                  return this.queryPlanner!.buildQueryPlan(operationContext, {
-                    autoFragmentization: Boolean(
-                      this.config.experimental_autoFragmentization,
-                    ),
-                  });
+                  return this.queryPlanner!.buildQueryPlan(operation);
                 } catch (err) {
                   span.setStatus({ code: SpanStatusCode.ERROR });
                   throw err;

package/src/utilities/__tests__/cleanErrorOfInaccessibleElements.test.ts

@@ -1,9 +1,9 @@
-import { buildSchema, execute, GraphQLError, parse } from "graphql";
-import { toAPISchema } from "@apollo/query-planner";
+import { execute, GraphQLError, parse } from "graphql";
 import { cleanErrorOfInaccessibleNames } from "../cleanErrorOfInaccessibleNames";
+import { buildSchema } from "@apollo/federation-internals";
 
 describe('cleanErrorOfInaccessibleNames', () => {
-  let schema = buildSchema(`
+  const coreSchema = buildSchema(`
     directive @core(
       feature: String!,
       as: String,
@@ -46,7 +46,7 @@ describe('cleanErrorOfInaccessibleNames', () => {
       inaccessibleField: String @inaccessible
     }
   `);
-  schema = toAPISchema(schema);
+  const schema = coreSchema.toAPISchema().toGraphQLJSSchema();
 
   it('removes inaccessible type names from error messages', async () => {
     const result = await execute(schema, parse('{fooField{someField}}'), {

package/LICENSE.md

@@ -1,21 +0,0 @@
-The MIT License
-
-Copyright (c) 2020- Apollo Graph, Inc.
-Copyright (c) 2019-2020 Meteor Development Group, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/core/index.d.ts

@@ -1,13 +0,0 @@
-import { CoreSchemaContext, Feature } from '@apollo/core-schema';
-export declare const ErrUnsupportedFeature: (feature: Feature) => import("@apollo/core-schema/dist/error").GraphQLErrorExt<"UnsupportedFeature"> & {
-    message: string;
-    feature: Feature;
-    nodes: import("graphql").DirectiveNode[];
-};
-export declare const ErrForUnsupported: (core: Feature, ...features: readonly Feature[]) => import("@apollo/core-schema/dist/error").GraphQLErrorExt<"ForUnsupported"> & {
-    message: string;
-    features: readonly Feature[];
-    nodes: import("graphql").DirectiveNode[];
-};
-export declare function featureSupport(this: CoreSchemaContext): void;
-//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAO,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAUtE,eAAO,MAAM,qBAAqB,YAAa,OAAO;;;;CAKlD,CAAC;AAEL,eAAO,MAAM,iBAAiB,SAAU,OAAO,eAAe,SAAS,OAAO,EAAE;;;;CAO5E,CAAC;AAEL,wBAAgB,cAAc,CAAC,IAAI,EAAE,iBAAiB,QAwBrD"}

package/dist/core/index.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.featureSupport = exports.ErrForUnsupported = exports.ErrUnsupportedFeature = void 0;
-const core_schema_1 = require("@apollo/core-schema");
-const SUPPORTED_FEATURES = new Set([
-    'https://specs.apollo.dev/core/v0.1',
-    'https://specs.apollo.dev/core/v0.2',
-    'https://specs.apollo.dev/join/v0.1',
-    'https://specs.apollo.dev/tag/v0.1',
-    'https://specs.apollo.dev/inaccessible/v0.1',
-]);
-const ErrUnsupportedFeature = (feature) => (0, core_schema_1.err)('UnsupportedFeature', {
-    message: `feature ${feature.url} is for: ${feature.purpose} but is unsupported`,
-    feature,
-    nodes: [feature.directive],
-});
-exports.ErrUnsupportedFeature = ErrUnsupportedFeature;
-const ErrForUnsupported = (core, ...features) => (0, core_schema_1.err)('ForUnsupported', {
-    message: `the \`for:\` argument is unsupported by version ${core.url.version} ` +
-        `of the core spec. Please upgrade to at least @core v0.2 (https://specs.apollo.dev/core/v0.2).`,
-    features,
-    nodes: [core.directive, ...features.map(f => f.directive)]
-});
-exports.ErrForUnsupported = ErrForUnsupported;
-function featureSupport() {
-    const coreVersionZeroDotOne = this.features.find('https://specs.apollo.dev/core/v0.1', true);
-    if (coreVersionZeroDotOne) {
-        const purposefulFeatures = [...this.features].filter(f => f.purpose);
-        if (purposefulFeatures.length > 0)
-            this.report((0, exports.ErrForUnsupported)(coreVersionZeroDotOne, ...purposefulFeatures));
-    }
-    for (const feature of this.features) {
-        if (!feature.purpose)
-            continue;
-        if (feature.purpose === 'EXECUTION' || feature.purpose === 'SECURITY') {
-            if (!SUPPORTED_FEATURES.has(feature.url.base.toString())) {
-                this.report((0, exports.ErrUnsupportedFeature)(feature));
-            }
-        }
-    }
-}
-exports.featureSupport = featureSupport;
-//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";;;AAAA,qDAAsE;AAEtE,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC;IACjC,oCAAoC;IACpC,oCAAoC;IACpC,oCAAoC;IACpC,mCAAmC;IACnC,4CAA4C;CAC7C,CAAC,CAAC;AAEI,MAAM,qBAAqB,GAAG,CAAC,OAAgB,EAAE,EAAE,CACxD,IAAA,iBAAG,EAAC,oBAAoB,EAAE;IACxB,OAAO,EAAE,WAAW,OAAO,CAAC,GAAG,YAAY,OAAO,CAAC,OAAO,qBAAqB;IAC/E,OAAO;IACP,KAAK,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC;CAC3B,CAAC,CAAC;AALQ,QAAA,qBAAqB,yBAK7B;AAEE,MAAM,iBAAiB,GAAG,CAAC,IAAa,EAAE,GAAG,QAA4B,EAAE,EAAE,CAClF,IAAA,iBAAG,EAAC,gBAAgB,EAAE;IACpB,OAAO,EACL,mDAAmD,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG;QACtE,+FAA+F;IACjG,QAAQ;IACR,KAAK,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;CAC3D,CAAC,CAAC;AAPQ,QAAA,iBAAiB,qBAOzB;AAEL,SAAgB,cAAc;IAC5B,MAAM,qBAAqB,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAC9C,oCAAoC,EACpC,IAAI,CACL,CAAC;IAIF,IAAI,qBAAqB,EAAE;QACzB,MAAM,kBAAkB,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAA;QACpE,IAAI,kBAAkB,CAAC,MAAM,GAAG,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,IAAA,yBAAiB,EAAC,qBAAqB,EAAE,GAAG,kBAAkB,CAAC,CAAC,CAAA;KAG/E;IAED,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE;QACnC,IAAI,CAAC,OAAO,CAAC,OAAO;YAAE,SAAS;QAC/B,IAAI,OAAO,CAAC,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,OAAO,KAAK,UAAU,EAAE;YACrE,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE;gBACxD,IAAI,CAAC,MAAM,CAAC,IAAA,6BAAqB,EAAC,OAAO,CAAC,CAAC,CAAC;aAC7C;SACF;KACF;AACH,CAAC;AAxBD,wCAwBC"}

package/src/__tests__/build-query-plan-fragmentization.feature

@@ -1,282 +0,0 @@
-Feature: Build Query Plan > Auto-fragmentization
-
-Scenario: experimental compression to downstream services should generate fragments internally to downstream requests
-  Given query
-    """
-    query {
-      topReviews {
-        body
-        author
-        product {
-          name
-          price
-          details {
-            country
-          }
-        }
-      }
-    }
-    """
-  When using autofragmentization
-  Then query plan
-    """
-    {
-      "kind": "QueryPlan",
-      "node": {
-        "kind": "Sequence",
-        "nodes": [
-          {
-            "kind": "Fetch",
-            "serviceName": "reviews",
-            "variableUsages": [],
-            "operation": "{topReviews{...__QueryPlanFragment_1__}}fragment __QueryPlanFragment_1__ on Review{body author product{...__QueryPlanFragment_0__}}fragment __QueryPlanFragment_0__ on Product{__typename ...on Book{__typename isbn}...on Furniture{__typename upc}}"
-          },
-          {
-            "kind": "Parallel",
-            "nodes": [
-              {
-                "kind": "Sequence",
-                "nodes": [
-                  {
-                    "kind": "Flatten",
-                    "path": ["topReviews", "@", "product"],
-                    "node": {
-                      "kind": "Fetch",
-                      "serviceName": "books",
-                      "requires": [
-                        {
-                          "kind": "InlineFragment",
-                          "typeCondition": "Book",
-                          "selections": [
-                            { "kind": "Field", "name": "__typename" },
-                            { "kind": "Field", "name": "isbn" }
-                          ]
-                        }
-                      ],
-                      "variableUsages": [],
-                      "operation": "query($representations:[_Any!]!){_entities(representations:$representations){...on Book{__typename isbn title year}}}"
-                    }
-                  },
-                  {
-                    "kind": "Flatten",
-                    "path": ["topReviews", "@", "product"],
-                    "node": {
-                      "kind": "Fetch",
-                      "serviceName": "product",
-                      "requires": [
-                        {
-                          "kind": "InlineFragment",
-                          "typeCondition": "Book",
-                          "selections": [
-                            { "kind": "Field", "name": "__typename" },
-                            { "kind": "Field", "name": "isbn" },
-                            { "kind": "Field", "name": "title" },
-                            { "kind": "Field", "name": "year" }
-                          ]
-                        }
-                      ],
-                      "variableUsages": [],
-                      "operation": "query($representations:[_Any!]!){_entities(representations:$representations){...on Book{name}}}"
-                    }
-                  }
-                ]
-              },
-              {
-                "kind": "Flatten",
-                "path": ["topReviews", "@", "product"],
-                "node": {
-                  "kind": "Fetch",
-                  "serviceName": "product",
-                  "requires": [
-                    {
-                      "kind": "InlineFragment",
-                      "typeCondition": "Furniture",
-                      "selections": [
-                        { "kind": "Field", "name": "__typename" },
-                        { "kind": "Field", "name": "upc" }
-                      ]
-                    },
-                    {
-                      "kind": "InlineFragment",
-                      "typeCondition": "Book",
-                      "selections": [
-                        { "kind": "Field", "name": "__typename" },
-                        { "kind": "Field", "name": "isbn" }
-                      ]
-                    }
-                  ],
-                  "variableUsages": [],
-                  "operation": "query($representations:[_Any!]!){_entities(representations:$representations){...on Furniture{name price details{country}}...on Book{price details{country}}}}"
-                }
-              }
-            ]
-          }
-        ]
-      }
-    }
-    """
-
-Scenario: experimental compression to downstream services shouldn't generate fragments for selection sets of length 2 or less
-  Given query
-    """
-    query {
-      topReviews {
-        body
-        author
-      }
-    }
-    """
-  When using autofragmentization
-  Then query plan
-    """
-    {
-      "kind": "QueryPlan",
-      "node": {
-        "kind": "Fetch",
-        "serviceName": "reviews",
-        "variableUsages": [],
-        "operation": "{topReviews{body author}}"
-      }
-    }
-    """
-
-Scenario: experimental compression to downstream services should generate fragments for selection sets of length 3 or greater
-  Given query
-    """
-    query {
-      topReviews {
-        id
-        body
-        author
-      }
-    }
-    """
-  When using autofragmentization
-  Then query plan
-    """
-    {
-      "kind": "QueryPlan",
-      "node": {
-        "kind": "Fetch",
-        "serviceName": "reviews",
-        "variableUsages": [],
-        "operation": "{topReviews{...__QueryPlanFragment_0__}}fragment __QueryPlanFragment_0__ on Review{id body author}"
-      }
-    }
-    """
-
-Scenario: experimental compression to downstream services should generate fragments correctly when aliases are used
-  Given query
-    """
-    query {
-      reviews: topReviews {
-        content: body
-        author
-        product {
-          name
-          cost: price
-          details {
-            origin: country
-          }
-        }
-      }
-    }
-    """
-  When using autofragmentization
-  Then query plan
-    """
-    {
-      "kind": "QueryPlan",
-      "node": {
-        "kind": "Sequence",
-        "nodes": [
-          {
-            "kind": "Fetch",
-            "serviceName": "reviews",
-            "variableUsages": [],
-            "operation": "{reviews:topReviews{...__QueryPlanFragment_1__}}fragment __QueryPlanFragment_1__ on Review{content:body author product{...__QueryPlanFragment_0__}}fragment __QueryPlanFragment_0__ on Product{__typename ...on Book{__typename isbn}...on Furniture{__typename upc}}"
-          },
-          {
-            "kind": "Parallel",
-            "nodes": [
-              {
-                "kind": "Sequence",
-                "nodes": [
-                  {
-                    "kind": "Flatten",
-                    "path": ["reviews", "@", "product"],
-                    "node": {
-                      "kind": "Fetch",
-                      "serviceName": "books",
-                      "requires": [
-                        {
-                          "kind": "InlineFragment",
-                          "typeCondition": "Book",
-                          "selections": [
-                            { "kind": "Field", "name": "__typename" },
-                            { "kind": "Field", "name": "isbn" }
-                          ]
-                        }
-                      ],
-                      "variableUsages": [],
-                      "operation": "query($representations:[_Any!]!){_entities(representations:$representations){...on Book{__typename isbn title year}}}"
-                    }
-                  },
-                  {
-                    "kind": "Flatten",
-                    "path": ["reviews", "@", "product"],
-                    "node": {
-                      "kind": "Fetch",
-                      "serviceName": "product",
-                      "requires": [
-                        {
-                          "kind": "InlineFragment",
-                          "typeCondition": "Book",
-                          "selections": [
-                            { "kind": "Field", "name": "__typename" },
-                            { "kind": "Field", "name": "isbn" },
-                            { "kind": "Field", "name": "title" },
-                            { "kind": "Field", "name": "year" }
-                          ]
-                        }
-                      ],
-                      "variableUsages": [],
-                      "operation": "query($representations:[_Any!]!){_entities(representations:$representations){...on Book{name}}}"
-                    }
-                  }
-                ]
-              },
-              {
-                "kind": "Flatten",
-                "path": ["reviews", "@", "product"],
-                "node": {
-                  "kind": "Fetch",
-                  "serviceName": "product",
-                  "requires": [
-                    {
-                      "kind": "InlineFragment",
-                      "typeCondition": "Furniture",
-                      "selections": [
-                        { "kind": "Field", "name": "__typename" },
-                        { "kind": "Field", "name": "upc" }
-                      ]
-                    },
-                    {
-                      "kind": "InlineFragment",
-                      "typeCondition": "Book",
-                      "selections": [
-                        { "kind": "Field", "name": "__typename" },
-                        { "kind": "Field", "name": "isbn" }
-                      ]
-                    }
-                  ],
-                  "variableUsages": [],
-                  "operation": "query($representations:[_Any!]!){_entities(representations:$representations){...on Furniture{name cost:price details{origin:country}}...on Book{cost:price details{origin:country}}}}"
-                }
-              }
-            ]
-          }
-        ]
-      }
-    }
-    """