@apollo/gateway 2.3.3 → 2.4.0-alpha.0

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/__tests__/resultShaping.test.ts

@@ -249,7 +249,7 @@ describe('gateway post-processing', () => {
         }
       `);
 
-      let res = computeResponse({
+      const res = computeResponse({
         operation: operationNonNullable,
         input,
         introspectionHandling,
@@ -280,7 +280,7 @@ describe('gateway post-processing', () => {
         }
       `);
 
-      let res = computeResponse({
+      const res = computeResponse({
         operation: operationNonNullable,
         input,
         introspectionHandling,
@@ -365,7 +365,7 @@ describe('gateway post-processing', () => {
     `);
 
     const input = {
-      "x": 'foo', 
+      "x": 'foo',
     }
 
     const operation = parseOperation(schema, `
@@ -530,4 +530,76 @@ describe('gateway post-processing', () => {
       }
     `);
   });
+
+  test('Handles defaulted `if` conditions', () => {
+    const schema = buildSchemaFromAST(gql`
+      type Query {
+        hello: String!
+      }
+    `);
+
+    const input = {
+      skipped: 'world',
+      included: 'world',
+    };
+
+    const operation = parseOperation(schema, `#graphql
+      query DefaultedIfCondition($if: Boolean = true) {
+        skipped: hello @skip(if: $if)
+        included: hello @include(if: $if)
+      }
+    `);
+
+    expect(
+      computeResponse({
+        operation,
+        input,
+        introspectionHandling,
+      }),
+    ).toMatchInlineSnapshot(`
+      Object {
+        "data": Object {
+          "included": "world",
+        },
+        "errors": Array [],
+      }
+    `);
+  });
+
+  test('Provided variables overwrite defaulted variable values', () => {
+    const schema = buildSchemaFromAST(gql`
+      type Query {
+        hello: String!
+      }
+    `);
+
+    const input = {
+      skipped: 'world',
+      included: 'world',
+    };
+
+    const operation = parseOperation(schema, `#graphql
+        # note that the default conditional is inverted from the previous test
+      query DefaultedIfCondition($if: Boolean = false) {
+        skipped: hello @skip(if: $if)
+        included: hello @include(if: $if)
+      }
+    `);
+
+    expect(
+      computeResponse({
+        operation,
+        input,
+        variables: { if: true },
+        introspectionHandling,
+      }),
+    ).toMatchInlineSnapshot(`
+      Object {
+        "data": Object {
+          "included": "world",
+        },
+        "errors": Array [],
+      }
+    `);
+  });
 })