@apollo/gateway 2.3.4 → 2.4.0-alpha.1

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

@@ -0,0 +1,101 @@
+import gql from 'graphql-tag';
+import { startSubgraphsAndGateway, Services } from './testUtils'
+
+let services: Services;
+
+afterEach(async () => {
+  if (services) {
+    await services.stop();
+  }
+});
+
+describe('`debug.bypassPlannerForSingleSubgraph` config', () => {
+  const subgraph = {
+    name: 'A',
+    url: 'https://A',
+    typeDefs: gql`
+      type Query {
+        a: A
+      }
+
+      type A {
+        b: B
+      }
+
+      type B {
+        x: Int
+        y: String
+      }
+    `,
+    resolvers: {
+      Query: {
+        a: () => ({
+          b: {
+            x: 1,
+            y: 'foo',
+          }
+        }),
+      }
+    }
+  };
+
+  const query = `
+    {
+      a {
+        b {
+          x
+          y
+        }
+      }
+    }
+  `;
+
+  const expectedResult = `
+    Object {
+      "data": Object {
+        "a": Object {
+          "b": Object {
+            "x": 1,
+            "y": "foo",
+          },
+        },
+      },
+    }
+  `;
+
+  it('is disabled by default', async () => {
+    services = await startSubgraphsAndGateway([subgraph]);
+
+    const response = await services.queryGateway(query);
+    const result = await response.json();
+    expect(result).toMatchInlineSnapshot(expectedResult);
+
+    const queryPlanner = services.gateway.__testing().queryPlanner!;
+    // If the query planner is genuinely used, we shoud have evaluated 1 plan.
+    expect(queryPlanner.lastGeneratedPlanStatistics()?.evaluatedPlanCount).toBe(1);
+  });
+
+  it('works when enabled', async () => {
+    services = await startSubgraphsAndGateway(
+      [subgraph],
+      {
+        gatewayConfig: {
+          queryPlannerConfig: {
+            debug: {
+              bypassPlannerForSingleSubgraph: true,
+            }
+          }
+        }
+      }
+    );
+
+    const response = await services.queryGateway(query);
+    const result = await response.json();
+    expect(result).toMatchInlineSnapshot(expectedResult);
+
+    const queryPlanner = services.gateway.__testing().queryPlanner!;
+    // The `bypassPlannerForSingleSubgraph` doesn't evaluate anything. It's use is the only case where `evaluatedPlanCount` can be 0.
+    expect(queryPlanner.lastGeneratedPlanStatistics()?.evaluatedPlanCount).toBe(0);
+  });
+});
+

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

@@ -1,20 +1,17 @@
 import { gunzipSync } from 'zlib';
 import nock from 'nock';
 import gql from 'graphql-tag';
-import { buildSubgraphSchema } from '@apollo/subgraph';
-import { ApolloServer } from 'apollo-server';
-import { ApolloServerPluginUsageReporting } from 'apollo-server-core';
+import { ApolloServerPluginUsageReporting } from '@apollo/server/plugin/usageReporting';
 import { execute } from '@apollo/client/link/core';
 import { toPromise } from '@apollo/client/link/utils';
 import { createHttpLink } from '@apollo/client/link/http';
 import fetch from 'node-fetch';
-import { ApolloGateway } from '../..';
 import { Plugin, Config, Refs } from 'pretty-format';
 import { Report, Trace } from '@apollo/usage-reporting-protobuf';
 import { fixtures } from 'apollo-federation-integration-testsuite';
 import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
-import { GraphQLSchemaModule } from '@apollo/subgraph/src/schema-helper';
 import resolvable, { Resolvable } from '@josephg/resolvable';
+import { startSubgraphsAndGateway, Services } from './testUtils';
 
 // Normalize specific fields that change often (eg timestamps) to static values,
 // to make snapshot testing viable.  (If these helpers are more generally
@@ -80,17 +77,8 @@ expect.addSnapshotSerializer(
   }),
 );
 
-async function startFederatedServer(modules: GraphQLSchemaModule[]) {
-  const schema = buildSubgraphSchema(modules);
-  const server = new ApolloServer({ schema });
-  const { url } = await server.listen({ port: 0 });
-  return { url, server };
-}
-
 describe('reporting', () => {
-  let backendServers: ApolloServer[];
-  let gatewayServer: ApolloServer;
-  let gatewayUrl: string;
+  let services: Services;
   let reportPromise: Resolvable<any>;
 
   beforeEach(async () => {
@@ -104,38 +92,27 @@ describe('reporting', () => {
         return 'ok';
       });
 
-    backendServers = [];
-    const serviceList = [];
-    for (const fixture of fixtures) {
-      const { server, url } = await startFederatedServer([fixture]);
-      backendServers.push(server);
-      serviceList.push({ name: fixture.name, url });
-    }
-
-    const gateway = new ApolloGateway({ serviceList });
-    const { schema, executor } = await gateway.load();
-    gatewayServer = new ApolloServer({
-      schema,
-      executor,
-      apollo: {
-        key: 'service:foo:bar',
-        graphRef: 'foo@current',
-      },
-      plugins: [
-        ApolloServerPluginUsageReporting({
-          sendReportsImmediately: true,
-        }),
-      ],
-    });
-    ({ url: gatewayUrl } = await gatewayServer.listen({ port: 0 }));
+    services = await startSubgraphsAndGateway(
+      fixtures,
+      {
+        gatewayServerConfig: {
+          apollo: {
+            key: 'service:foo:bar',
+            graphRef: 'foo@current',
+          },
+          plugins: [
+            ApolloServerPluginUsageReporting({
+              sendReportsImmediately: true,
+            }),
+          ],
+        },
+      }
+    );
   });
 
   afterEach(async () => {
-    for (const server of backendServers) {
-      await server.stop();
-    }
-    if (gatewayServer) {
-      await gatewayServer.stop();
+    if (services) {
+      await services.stop();
     }
 
     nockAfterEach();
@@ -157,7 +134,7 @@ describe('reporting', () => {
     `;
 
     const result = await toPromise(
-      execute(createHttpLink({ uri: gatewayUrl, fetch: fetch as any }), {
+      execute(createHttpLink({ uri: services.gatewayUrl, fetch: fetch as any }), {
         query,
       }),
     );
@@ -632,6 +609,7 @@ describe('reporting', () => {
             ],
           },
         },
+        "tracesPreAggregated": false,
       }
     `);
   });

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

@@ -6,13 +6,15 @@ import {
 } from '@apollo/gateway';
 import { accounts, fixturesWithUpdate } from 'apollo-federation-integration-testsuite';
 import { createHash } from '@apollo/utils.createhash';
-import { ApolloServer } from 'apollo-server';
+import { ApolloServer } from '@apollo/server';
+import { startStandaloneServer } from '@apollo/server/standalone';
 import type { Logger } from '@apollo/utils.logger';
 import { getTestingSupergraphSdl } from '../execution-utils';
 import { mockAllServicesHealthCheckSuccess } from '../integration/nockMocks';
 import resolvable from '@josephg/resolvable';
 import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
 import nock from 'nock';
+import { unwrapSingleResultKind } from '../gateway/testUtils';
 
 async function getSupergraphSdlGatewayServer() {
   const server = new ApolloServer({
@@ -26,7 +28,7 @@ async function getSupergraphSdlGatewayServer() {
     }),
   });
 
-  await server.listen({ port: 0 });
+  await startStandaloneServer(server, { listen: { port: 0 } });
   return server;
 }
 
@@ -67,7 +69,7 @@ describe('Using supergraphSdl static configuration', () => {
       query: '{ me { username } }',
     });
 
-    expect(result.data).toMatchInlineSnapshot(`
+    expect(unwrapSingleResultKind(result).data).toMatchInlineSnapshot(`
       Object {
         "me": Object {
           "username": "@jbaxleyiii",

package/src/__tests__/gateway/testUtils.ts

@@ -0,0 +1,89 @@
+import { buildSubgraphSchema } from '@apollo/subgraph';
+import {
+  ApolloServer,
+  ApolloServerOptionsWithGateway,
+  BaseContext,
+  GraphQLResponse,
+} from '@apollo/server';
+import { startStandaloneServer } from '@apollo/server/standalone';
+import { ApolloServerPluginInlineTrace } from '@apollo/server/plugin/inlineTrace';
+import { GraphQLSchemaModule } from '@apollo/subgraph/src/schema-helper';
+import { ApolloGateway, GatewayConfig } from '../..';
+import { ServiceDefinition } from '@apollo/federation-internals';
+import fetch, { Response } from 'node-fetch';
+import { assert } from '@apollo/federation-internals';
+
+export class Services {
+  constructor(
+    readonly subgraphServers: ApolloServer[],
+    readonly gateway: ApolloGateway,
+    readonly gatewayServer: ApolloServer,
+    readonly gatewayUrl: string,
+  ) {
+  }
+
+  async queryGateway(query: string): Promise<Response> {
+    return fetch(this.gatewayUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ query }),
+    });
+  }
+
+  async stop() {
+    for (const server of this.subgraphServers) {
+      await server.stop();
+    }
+    await this.gatewayServer.stop();
+  }
+}
+
+async function startFederatedServer(modules: GraphQLSchemaModule[]) {
+  const schema = buildSubgraphSchema(modules);
+  const server = new ApolloServer({
+    schema,
+    // Manually installing the inline trace plugin means it doesn't log a message.
+    plugins: [ApolloServerPluginInlineTrace()],
+  });
+  const { url } = await startStandaloneServer(server, { listen: { port: 0 } });
+  return { url, server };
+}
+
+export async function startSubgraphsAndGateway(
+  servicesDefs: ServiceDefinition[],
+  config?: {
+    gatewayConfig?: GatewayConfig;
+    gatewayServerConfig?: Partial<ApolloServerOptionsWithGateway<BaseContext>>;
+  },
+): Promise<Services> {
+  const backendServers = [];
+  const serviceList = [];
+  for (const serviceDef of servicesDefs) {
+    const { server, url } = await startFederatedServer([serviceDef]);
+    backendServers.push(server);
+    serviceList.push({ name: serviceDef.name, url });
+  }
+
+  const gateway = new ApolloGateway({
+    serviceList,
+    ...config?.gatewayConfig,
+  });
+  const gatewayServer = new ApolloServer({
+    gateway,
+    ...config?.gatewayServerConfig,
+  });
+  const { url: gatewayUrl } = await startStandaloneServer(gatewayServer, {
+    listen: { port: 0 },
+  });
+  return new Services(backendServers, gateway, gatewayServer, gatewayUrl);
+}
+
+export function unwrapSingleResultKind(response: GraphQLResponse) {
+  assert(
+    response.body.kind === 'single',
+    `Expected single result, got ${response.body.kind}`,
+  );
+  return response.body.singleResult;
+}

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

@@ -1,9 +1,10 @@
 import { execute } from '../execution-utils';
-import { ApolloServerBase as ApolloServer } from 'apollo-server-core';
+import { ApolloServer } from '@apollo/server';
 import { buildSubgraphSchema } from '@apollo/subgraph';
 import { LocalGraphQLDataSource } from '../../datasources/LocalGraphQLDataSource';
 import { ApolloGateway } from '../../';
 import { fixtures } from 'apollo-federation-integration-testsuite';
+import { unwrapSingleResultKind } from '../gateway/testUtils';
 
 it('supports simple aliases', async () => {
   const query = `#graphql
@@ -155,9 +156,8 @@ it('supports aliases when using ApolloServer', async () => {
     },
   });
 
-  const { schema, executor } = await gateway.load();
-
-  const server = new ApolloServer({ schema, executor });
+  const server = new ApolloServer({ gateway });
+  await server.start();
 
   const upc = '1';
 
@@ -172,7 +172,7 @@ it('supports aliases when using ApolloServer', async () => {
     variables: { upc },
   });
 
-  expect(result.data).toEqual({
+  expect(unwrapSingleResultKind(result).data).toEqual({
     product: {
       title: 'Table',
     },

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

@@ -4,8 +4,6 @@ import { astSerializer, queryPlanSerializer } from 'apollo-federation-integratio
 expect.addSnapshotSerializer(astSerializer);
 expect.addSnapshotSerializer(queryPlanSerializer);
 
-// TODO: right now the query planner doesn't prune known skip and include points
-// eventually we want to do this to prevent downstream fetches that aren't needed
 describe('@skip', () => {
   it('supports @skip when a boolean condition is met', async () => {
     const query = `#graphql
@@ -35,8 +33,8 @@ describe('@skip', () => {
       ],
     });
 
-    expect(queryPlan).toCallService('accounts');
     expect(queryPlan).toCallService('reviews');
+    expect(queryPlan).not.toCallService('accounts');
   });
 
   it('supports @skip when a boolean condition is met (variable driven)', async () => {
@@ -122,7 +120,7 @@ describe('@skip', () => {
     `;
 
     const skip = false;
-    const { data, queryPlan } = await execute({
+    const { data, queryPlan, operation } = await execute({
       query,
       variables: { skip },
     });
@@ -137,8 +135,9 @@ describe('@skip', () => {
       ],
     });
 
-    expect(queryPlan).toCallService('accounts');
-    expect(queryPlan).toCallService('reviews');
+    const variables = { definitions: operation.variableDefinitions, values: {skip} };
+    expect(queryPlan).toCallService('reviews', variables);
+    expect(queryPlan).toCallService('accounts', variables);
   });
 });
 
@@ -258,7 +257,7 @@ describe('@include', () => {
     `;
 
     const include = true;
-    const { data, queryPlan } = await execute({
+    const { data, queryPlan, operation } = await execute({
       query,
       variables: { include },
     });
@@ -273,7 +272,8 @@ describe('@include', () => {
       ],
     });
 
-    expect(queryPlan).toCallService('accounts');
-    expect(queryPlan).toCallService('reviews');
+    const variables = { definitions: operation.variableDefinitions, values: {include} };
+    expect(queryPlan).toCallService('accounts', variables);
+    expect(queryPlan).toCallService('reviews', variables);
   });
 });

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

@@ -2,8 +2,9 @@ import mockedEnv from 'mocked-env';
 import fetcher from 'make-fetch-happen';
 
 import { ApolloGateway, UplinkSupergraphManager } from '@apollo/gateway';
-import { ApolloServer } from 'apollo-server';
-import { ApolloServerPluginUsageReportingDisabled } from 'apollo-server-core';
+import { ApolloServer } from '@apollo/server';
+import { startStandaloneServer } from '@apollo/server/standalone';
+import { ApolloServerPluginUsageReportingDisabled } from '@apollo/server/plugin/disabled';
 import type { FetcherRequestInit } from '@apollo/utils.fetcher';
 
 import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
@@ -62,7 +63,7 @@ describe('minimal gateway', () => {
       gateway,
       plugins: [ApolloServerPluginUsageReportingDisabled()],
     });
-    await server.listen({ port: 0 });
+    await startStandaloneServer(server, { listen: { port: 0 } });
     expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
   });
 
@@ -80,7 +81,7 @@ describe('minimal gateway', () => {
       gateway,
       plugins: [ApolloServerPluginUsageReportingDisabled()],
     });
-    await server.listen({ port: 0 });
+    await startStandaloneServer(server, { listen: { port: 0 } });
     expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
     const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
     expect(uplinkManager.uplinkEndpoints).toEqual([uplinkEndpoint]);
@@ -100,7 +101,7 @@ describe('minimal gateway', () => {
       gateway,
       plugins: [ApolloServerPluginUsageReportingDisabled()],
     });
-    await server.listen({ port: 0 });
+    await startStandaloneServer(server, { listen: { port: 0 } });
     expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
     const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
     expect(uplinkManager.uplinkEndpoints).toEqual([
@@ -127,7 +128,7 @@ describe('minimal gateway', () => {
       gateway,
       plugins: [ApolloServerPluginUsageReportingDisabled()],
     });
-    await server.listen({ port: 0 });
+    await startStandaloneServer(server, { listen: { port: 0 } });
 
     expect(calls).toEqual(1);
   });
@@ -180,7 +181,7 @@ describe('Managed gateway with explicit UplinkSupergraphManager', () => {
 
     const supergraphSchema = getTestingSupergraphSdl();
     let hasFired;
-    let uplinkManager = new UplinkSupergraphManager({
+    const uplinkManager = new UplinkSupergraphManager({
       apiKey,
       graphRef,
       logger,
@@ -246,7 +247,7 @@ describe('Managed gateway with explicit UplinkSupergraphManager', () => {
         .reply(500);
 
       let hasFired;
-      let uplinkManager = new UplinkSupergraphManager({
+      const uplinkManager = new UplinkSupergraphManager({
         apiKey,
         graphRef,
         logger,
@@ -285,7 +286,7 @@ describe('Managed gateway with explicit UplinkSupergraphManager', () => {
         .reply(500);
 
       let hasFired;
-      let uplinkManager = new UplinkSupergraphManager({
+      const uplinkManager = new UplinkSupergraphManager({
         apiKey,
         graphRef,
         logger,

package/src/executeQueryPlan.ts

@@ -28,12 +28,13 @@ import {
   getResponseName,
   FetchDataInputRewrite,
   FetchDataOutputRewrite,
+  evaluateCondition,
 } from '@apollo/query-planner';
 import { deepMerge } from './utilities/deepMerge';
 import { isNotNullOrUndefined } from './utilities/array';
 import { SpanStatusCode } from "@opentelemetry/api";
 import { OpenTelemetrySpanNames, tracer } from "./utilities/opentelemetry";
-import { assert, defaultRootName, errorCodeDef, ERRORS, isDefined, operationFromDocument, Schema } from '@apollo/federation-internals';
+import { assert, defaultRootName, errorCodeDef, ERRORS, isDefined, Operation, operationFromDocument, Schema } from '@apollo/federation-internals';
 import { GatewayGraphQLRequestContext, GatewayExecutionResult } from '@apollo/server-gateway-interface';
 import { computeResponse } from './resultShaping';
 
@@ -64,6 +65,7 @@ type ResultCursor = {
 interface ExecutionContext {
   queryPlan: QueryPlan;
   operationContext: OperationContext;
+  operation: Operation,
   serviceMap: ServiceMap;
   requestContext: GatewayGraphQLRequestContext;
   supergraphSchema: GraphQLSchema;
@@ -114,9 +116,39 @@ export async function executeQueryPlan(
     try {
       const errors: GraphQLError[] = [];
 
+      let operation: Operation;
+      try {
+        operation = operationFromDocument(
+          apiSchema,
+          {
+            kind: Kind.DOCUMENT,
+            definitions: [
+              operationContext.operation,
+              ...Object.values(operationContext.fragments),
+            ],
+          },
+          {
+            validate: false,
+          }
+        );
+      } catch (err) {
+        // We shouldn't really have errors as the operation should already have been validated, but if something still
+        // happens, we should report it properly (plus, some of our tests call this method directly and blow up if we don't
+        // handle this correctly).
+        // TODO: we are doing some duplicate work by building both `OperationContext` and this `Operation`. Ideally we
+        // would remove `OperationContext`, pass the `Operation` directly to this method, and only use that. This would change
+        // the signature of this method though and it is exported so ... maybe later ?
+        //
+        if (err instanceof GraphQLError) {
+          return { errors: [err] };
+        }
+        throw err;
+      }
+
       const context: ExecutionContext = {
         queryPlan,
         operationContext,
+        operation,
         serviceMap,
         requestContext,
         supergraphSchema,
@@ -129,6 +161,10 @@ export async function executeQueryPlan(
           requestContext.metrics && requestContext.metrics.captureTraces
       );
 
+      if (queryPlan.node?.kind === 'Subscription') {
+        throw new Error('Execution of subscriptions not supported by gateway');
+      }
+
       if (queryPlan.node) {
         const traceNode = await executeNode(
           context,
@@ -148,20 +184,6 @@ export async function executeQueryPlan(
       const result = await tracer.startActiveSpan(OpenTelemetrySpanNames.POST_PROCESSING, async (span) => {
         let data;
         try {
-          const operation = operationFromDocument(
-            apiSchema,
-            {
-              kind: Kind.DOCUMENT,
-              definitions: [
-                operationContext.operation,
-                ...Object.values(operationContext.fragments),
-              ],
-            },
-            {
-              validate: false,
-            }
-          );
-
           let postProcessingErrors: GraphQLError[];
           ({ data, errors: postProcessingErrors } = computeResponse({
             operation,
@@ -326,12 +348,30 @@ async function executeNode(
       }
       return new Trace.QueryPlanNode({ fetch: traceNode });
     }
+    case 'Condition': {
+      const condition = evaluateCondition(node, context.operation.variableDefinitions, context.requestContext.request.variables); 
+      const pickedBranch = condition ? node.ifClause : node.elseClause;
+      let branchTraceNode: Trace.QueryPlanNode | undefined = undefined;
+      if (pickedBranch) {
+        branchTraceNode = await executeNode(
+          context,
+          pickedBranch,
+          currentCursor,
+          captureTraces
+        );
+      }
+
+      return new Trace.QueryPlanNode({
+        condition: new Trace.QueryPlanNode.ConditionNode({
+          condition: node.condition,
+          ifClause: condition ? branchTraceNode : undefined,
+          elseClause: condition ? undefined : branchTraceNode,
+        }),
+      });
+    }
     case 'Defer': {
       assert(false, `@defer support is not available in the gateway`);
     }
-    case 'Condition': {
-      assert(false, `Condition nodes are not available in the gateway`);
-    }
   }
 }