@apollo/gateway 0.42.0 → 0.43.0

package/src/__tests__/executeQueryPlan.test.ts

@@ -7,7 +7,7 @@ import {
 } from 'graphql';
 import { addResolversToSchema, GraphQLResolverMap } from 'apollo-graphql';
 import gql from 'graphql-tag';
-import { GraphQLRequestContext } from 'apollo-server-types';
+import { GraphQLRequestContext, VariableValues } from 'apollo-server-types';
 import { AuthenticationError } from 'apollo-server-core';
 import { buildOperationContext } from '../operationContext';
 import { executeQueryPlan } from '../executeQueryPlan';
@@ -26,10 +26,6 @@ expect.addSnapshotSerializer(astSerializer);
 expect.addSnapshotSerializer(queryPlanSerializer);
 
 describe('executeQueryPlan', () => {
-  let serviceMap: {
-    [serviceName: string]: LocalGraphQLDataSource;
-  };
-
   function overrideResolversInService(
     serviceName: string,
     resolvers: GraphQLResolverMap,
@@ -44,6 +40,9 @@ describe('executeQueryPlan', () => {
     return jest.spyOn(entitiesField, 'resolve');
   }
 
+  let serviceMap: {
+    [serviceName: string]: LocalGraphQLDataSource;
+  };
   let schema: GraphQLSchema;
   let queryPlanner: QueryPlanner;
   beforeEach(() => {
@@ -53,13 +52,15 @@ describe('executeQueryPlan', () => {
     ).not.toThrow();
   });
 
-  function buildRequestContext(): GraphQLRequestContext {
+  function buildRequestContext(
+    variables: VariableValues = {},
+  ): GraphQLRequestContext {
     // @ts-ignore
     return {
       cache: undefined as any,
       context: {},
       request: {
-        variables: {},
+        variables,
       },
     };
   }
@@ -1379,4 +1380,260 @@ describe('executeQueryPlan', () => {
       // `);
     });
   });
+
+  describe('top-level @skip / @include usages', () => {
+    it(`top-level skip never calls reviews service (using literals)`, async () => {
+      const operationDocument = gql`
+        query {
+          topReviews @skip(if: true) {
+            body
+          }
+        }
+      `;
+
+      const operationContext = buildOperationContext({
+        schema,
+        operationDocument,
+      });
+
+      const queryPlan = queryPlanner.buildQueryPlan(operationContext);
+
+      const response = await executeQueryPlan(
+        queryPlan,
+        serviceMap,
+        buildRequestContext(),
+        operationContext,
+      );
+
+      expect(response.data).toMatchInlineSnapshot(`Object {}`);
+      expect(queryPlan).not.toCallService('reviews');
+    });
+
+    it(`top-level skip never calls reviews service (using variables)`, async () => {
+      const operationDocument = gql`
+        query TopReviews($shouldSkip: Boolean!) {
+          topReviews @skip(if: $shouldSkip) {
+            body
+          }
+        }
+      `;
+
+      const operationContext = buildOperationContext({
+        schema,
+        operationDocument,
+      });
+
+      const queryPlan = queryPlanner.buildQueryPlan(operationContext);
+
+      const variables = { shouldSkip: true };
+      const response = await executeQueryPlan(
+        queryPlan,
+        serviceMap,
+        buildRequestContext(variables),
+        operationContext,
+      );
+
+      expect(response.data).toMatchInlineSnapshot(`Object {}`);
+      expect({ queryPlan, variables }).not.toCallService('reviews');
+    });
+
+    it(`call to service isn't skipped unless all top-level fields are skipped`, async () => {
+      const operationDocument = gql`
+        query {
+          user(id: "1") @skip(if: true) {
+            username
+          }
+          me @include(if: true) {
+            username
+          }
+        }
+      `;
+
+      const operationContext = buildOperationContext({
+        schema,
+        operationDocument,
+      });
+
+      const queryPlan = queryPlanner.buildQueryPlan(operationContext);
+
+      const response = await executeQueryPlan(
+        queryPlan,
+        serviceMap,
+        buildRequestContext(),
+        operationContext,
+      );
+
+      expect(response.data).toMatchObject({
+        me: {
+          username: '@ada',
+        },
+      });
+      expect(queryPlan).toCallService('accounts');
+    });
+
+    it(`call to service is skipped when all top-level fields are skipped`, async () => {
+      const operationDocument = gql`
+        query {
+          user(id: "1") @skip(if: true) {
+            username
+          }
+          me @include(if: false) {
+            username
+          }
+        }
+      `;
+
+      const operationContext = buildOperationContext({
+        schema,
+        operationDocument,
+      });
+
+      const queryPlan = queryPlanner.buildQueryPlan(operationContext);
+
+      const response = await executeQueryPlan(
+        queryPlan,
+        serviceMap,
+        buildRequestContext(),
+        operationContext,
+      );
+
+      expect(response.data).toMatchObject({});
+      expect(queryPlan).not.toCallService('accounts');
+    });
+
+    describe('@skip and @include combinations', () => {
+      it(`include: false, skip: false`, async () => {
+        const operationDocument = gql`
+          query TopReviews($shouldInclude: Boolean!, $shouldSkip: Boolean!) {
+            topReviews @include(if: $shouldInclude) @skip(if: $shouldSkip) {
+              body
+            }
+          }
+        `;
+
+        const operationContext = buildOperationContext({
+          schema,
+          operationDocument,
+        });
+
+        const queryPlan = queryPlanner.buildQueryPlan(operationContext);
+
+        const variables = { shouldInclude: false, shouldSkip: false };
+        const response = await executeQueryPlan(
+          queryPlan,
+          serviceMap,
+          buildRequestContext(variables),
+          operationContext,
+        );
+
+        expect(response.data).toMatchObject({});
+        expect({ queryPlan, variables }).not.toCallService('reviews');
+      });
+
+      it(`include: false, skip: true`, async () => {
+        const operationDocument = gql`
+          query TopReviews($shouldInclude: Boolean!, $shouldSkip: Boolean!) {
+            topReviews @include(if: $shouldInclude) @skip(if: $shouldSkip) {
+              body
+            }
+          }
+        `;
+
+        const operationContext = buildOperationContext({
+          schema,
+          operationDocument,
+        });
+
+        const queryPlan = queryPlanner.buildQueryPlan(operationContext);
+
+        const variables = { shouldInclude: false, shouldSkip: true };
+        const response = await executeQueryPlan(
+          queryPlan,
+          serviceMap,
+          buildRequestContext(variables),
+          operationContext,
+        );
+
+        expect(response.data).toMatchObject({});
+        expect({ queryPlan, variables }).not.toCallService('reviews');
+      });
+
+      it(`include: true, skip: false`, async () => {
+        const operationDocument = gql`
+          query TopReviews($shouldInclude: Boolean!, $shouldSkip: Boolean!) {
+            topReviews(first: 2) @include(if: $shouldInclude) @skip(if: $shouldSkip) {
+              body
+            }
+          }
+        `;
+
+        const operationContext = buildOperationContext({
+          schema,
+          operationDocument,
+        });
+
+        const queryPlan = queryPlanner.buildQueryPlan(operationContext);
+
+        const variables = { shouldInclude: true, shouldSkip: false };
+        const response = await executeQueryPlan(
+          queryPlan,
+          serviceMap,
+          buildRequestContext(variables),
+          operationContext,
+        );
+
+        expect(response.data).toMatchObject({
+          topReviews: [
+            {
+              body: 'Love it!',
+            },
+            {
+              body: 'Too expensive.',
+            },
+          ],
+        });
+        expect({ queryPlan, variables }).toCallService('reviews');
+      });
+
+      it(`include: true, skip: true`, async () => {
+        const operationDocument = gql`
+          query TopReviews($shouldInclude: Boolean!, $shouldSkip: Boolean!) {
+            topReviews @include(if: $shouldInclude) @skip(if: $shouldSkip) {
+              body
+            }
+          }
+        `;
+
+        const operationContext = buildOperationContext({
+          schema,
+          operationDocument,
+        });
+
+        const queryPlan = queryPlanner.buildQueryPlan(operationContext);
+
+        const variables = { shouldInclude: true, shouldSkip: true };
+        const response = await executeQueryPlan(
+          queryPlan,
+          serviceMap,
+          buildRequestContext(variables),
+          operationContext,
+        );
+
+        expect(response.data).toMatchObject({});
+        expect(queryPlan).toMatchInlineSnapshot(`
+          QueryPlan {
+            Fetch(service: "reviews", inclusionConditions: [{ include: "shouldInclude", skip: "shouldSkip" }]) {
+              {
+                topReviews @include(if: $shouldInclude) @skip(if: $shouldSkip) {
+                  body
+                }
+              }
+            },
+          }
+        `);
+
+        expect({ queryPlan, variables }).not.toCallService('reviews');
+      });
+    });
+  });
 });

package/src/__tests__/execution-utils.ts

@@ -6,11 +6,10 @@ import {
 import { GraphQLRequest, GraphQLExecutionResult, Logger } from 'apollo-server-types';
 import {
   composeAndValidate,
-  buildSubgraphSchema,
   ServiceDefinition,
   compositionHasErrors,
 } from '@apollo/federation';
-
+import { buildSubgraphSchema } from '@apollo/subgraph';
 import {
   executeQueryPlan,
   buildOperationContext,
@@ -111,7 +110,11 @@ export function getTestingSupergraphSdl(services: typeof fixtures = fixtures) {
   if (!compositionHasErrors(compositionResult)) {
     return compositionResult.supergraphSdl;
   }
-  throw new Error("Testing fixtures don't compose properly!");
+  throw new Error(
+    `Testing fixtures don't compose properly!\n${compositionResult.errors.join(
+      '\t\n',
+    )}`,
+  );
 }
 
 export function wait(ms: number) {

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

@@ -1,5 +1,5 @@
 import { GraphQLSchemaModule } from 'apollo-graphql';
-import { buildFederatedSchema } from '@apollo/federation';
+import { buildSubgraphSchema } from '@apollo/subgraph';
 import { ApolloServer } from 'apollo-server';
 import fetch from 'node-fetch';
 import { ApolloGateway } from '../..';
@@ -7,7 +7,7 @@ import { fixtures } from 'apollo-federation-integration-testsuite';
 import { ApolloServerPluginInlineTrace } from 'apollo-server-core';
 
 async function startFederatedServer(modules: GraphQLSchemaModule[]) {
-  const schema = buildFederatedSchema(modules);
+  const schema = buildSubgraphSchema(modules);
   const server = new ApolloServer({
     schema,
     // Manually installing the inline trace plugin means it doesn't log a message.

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

@@ -4,7 +4,7 @@ import {fixtures, spanSerializer} from 'apollo-federation-integration-testsuite'
 import {fetch} from '../../__mocks__/apollo-server-env';
 import {InMemorySpanExporter, SimpleSpanProcessor} from '@opentelemetry/tracing'
 import {NodeTracerProvider} from '@opentelemetry/node';
-import { buildSubgraphSchema } from '@apollo/federation';
+import { buildSubgraphSchema } from '@apollo/subgraph';
 
 expect.addSnapshotSerializer(spanSerializer);
 

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

@@ -1,6 +1,6 @@
 import gql from 'graphql-tag';
 import { ApolloServerBase as ApolloServer } from 'apollo-server-core';
-import { buildSubgraphSchema } from '@apollo/federation';
+import { buildSubgraphSchema } from '@apollo/subgraph';
 
 import { LocalGraphQLDataSource } from '../../datasources/LocalGraphQLDataSource';
 import { ApolloGateway } from '../../';

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

@@ -2,7 +2,7 @@ import { gunzipSync } from 'zlib';
 import nock from 'nock';
 import { GraphQLSchemaModule } from 'apollo-graphql';
 import gql from 'graphql-tag';
-import { buildSubgraphSchema } from '@apollo/federation';
+import { buildSubgraphSchema } from '@apollo/subgraph';
 import { ApolloServer } from 'apollo-server';
 import { ApolloServerPluginUsageReporting } from 'apollo-server-core';
 import { execute, toPromise } from 'apollo-link';

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

@@ -1,6 +1,6 @@
 import { execute } from '../execution-utils';
 import { ApolloServerBase as ApolloServer } from 'apollo-server-core';
-import { buildSubgraphSchema } from '@apollo/federation';
+import { buildSubgraphSchema } from '@apollo/subgraph';
 import { LocalGraphQLDataSource } from '../../datasources/LocalGraphQLDataSource';
 import { ApolloGateway } from '../../';
 import { fixtures } from 'apollo-federation-integration-testsuite';

package/src/datasources/__tests__/LocalGraphQLDataSource.test.ts

@@ -1,5 +1,5 @@
 import { LocalGraphQLDataSource } from '../LocalGraphQLDataSource';
-import { buildSubgraphSchema } from '@apollo/federation';
+import { buildSubgraphSchema } from '@apollo/subgraph';
 import gql from 'graphql-tag';
 import { GraphQLResolverMap } from 'apollo-graphql';
 import { GraphQLRequestContext } from 'apollo-server-types';

package/src/executeQueryPlan.ts

@@ -1,6 +1,7 @@
 import {
   GraphQLExecutionResult,
   GraphQLRequestContext,
+  VariableValues,
 } from 'apollo-server-types';
 import { Headers } from 'apollo-server-env';
 import {
@@ -232,6 +233,10 @@ 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.
@@ -252,6 +257,31 @@ 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,
@@ -308,17 +338,17 @@ async function executeFetch<TContext>(
         const representations: ResultMap[] = [];
         const representationToEntity: number[] = [];
 
-    entities.forEach((entity, index) => {
-      const representation = executeSelectionSet(
-        context.operationContext,
-        entity,
-        requires,
-      );
-      if (representation && representation[TypeNameMetaFieldDef.name]) {
-        representations.push(representation);
-        representationToEntity.push(index);
-      }
-    });
+        entities.forEach((entity, index) => {
+          const representation = executeSelectionSet(
+            context.operationContext,
+            entity,
+            requires,
+          );
+          if (representation && representation[TypeNameMetaFieldDef.name]) {
+            representations.push(representation);
+            representationToEntity.push(index);
+          }
+        });
 
         // If there are no representations, that means the type conditions in
         // the requires don't match any entities.

package/src/index.ts

@@ -1,3 +1,4 @@
+import { deprecate } from 'util';
 import { GraphQLService, Unsubscriber } from 'apollo-server-core';
 import {
   GraphQLExecutionResult,
@@ -117,7 +118,10 @@ export function getDefaultFetcher() {
  * TODO(trevor:cloudconfig): Stop exporting this
  * @deprecated This will be removed in a future version of @apollo/gateway
  */
-export const getDefaultGcsFetcher = getDefaultFetcher;
+export const getDefaultGcsFetcher = deprecate(
+  getDefaultFetcher,
+  `'getDefaultGcsFetcher' is deprecated. Use 'getDefaultFetcher' instead.`,
+);
 /**
  * TODO(trevor:cloudconfig): Stop exporting this
  * @deprecated This will be removed in a future version of @apollo/gateway
@@ -1270,6 +1274,11 @@ export class ApolloGateway implements GraphQLService {
   }
 }
 
+ApolloGateway.prototype.onSchemaChange = deprecate(
+  ApolloGateway.prototype.onSchemaChange,
+  `'ApolloGateway.prototype.onSchemaChange' is deprecated. Use 'ApolloGateway.prototype.onSchemaLoadOrUpdate' instead.`,
+);
+
 function approximateObjectSize<T>(obj: T): number {
   return Buffer.byteLength(JSON.stringify(obj), 'utf8');
 }

package/src/utilities/graphql.ts

@@ -8,12 +8,8 @@ import {
   Kind,
   ListTypeNode,
   NamedTypeNode,
-  OperationDefinitionNode,
-  parse,
-  SelectionNode,
   TypeNode,
 } from 'graphql';
-import { assert } from './assert';
 
 export function getResponseName(node: FieldNode): string {
   return node.alias ? node.alias.value : node.name.value;
@@ -41,21 +37,3 @@ export function astFromType(type: GraphQLType): TypeNode {
     };
   }
 }
-
-/**
- * For lack of a "home of federation utilities", this function is copy/pasted
- * verbatim across the federation, gateway, and query-planner packages. Any changes
- * made here should be reflected in the other two locations as well.
- *
- * @param source A string representing a FieldSet
- * @returns A parsed FieldSet
- */
-export function parseSelections(source: string): ReadonlyArray<SelectionNode> {
-  const parsed = parse(`{${source}}`);
-  assert(
-    parsed.definitions.length === 1,
-    `Invalid FieldSet provided: '${source}'. FieldSets may not contain operations within them.`,
-  );
-  return (parsed.definitions[0] as OperationDefinitionNode).selectionSet
-    .selections;
-}