@apollo/gateway 0.42.2 → 0.44.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

@@ -110,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__/integration/networkRequests.test.ts

@@ -13,6 +13,8 @@ import {
   mockSupergraphSdlRequest,
   mockApolloConfig,
   mockCloudConfigUrl,
+  mockSupergraphSdlRequestIfAfter,
+  mockSupergraphSdlRequestSuccessIfAfter,
 } from './nockMocks';
 import {
   accounts,
@@ -130,7 +132,11 @@ it('Fetches Supergraph SDL from remote storage using a configured env variable',
 
 it('Updates Supergraph SDL from remote storage', async () => {
   mockSupergraphSdlRequestSuccess();
-  mockSupergraphSdlRequestSuccess(getTestingSupergraphSdl(fixturesWithUpdate), 'updatedId-5678');
+  mockSupergraphSdlRequestSuccessIfAfter(
+    'originalId-1234',
+    'updatedId-5678',
+    getTestingSupergraphSdl(fixturesWithUpdate),
+  );
 
   // This test is only interested in the second time the gateway notifies of an
   // update, since the first happens on load.
@@ -183,7 +189,7 @@ describe('Supergraph SDL update failures', () => {
 
   it('Handles arbitrary fetch failures (non 200 response)', async () => {
     mockSupergraphSdlRequestSuccess();
-    mockSupergraphSdlRequest().reply(500);
+    mockSupergraphSdlRequestIfAfter('originalId-1234').reply(500);
 
     // Spy on logger.error so we can just await once it's been called
     let errorLogged: Function;
@@ -208,7 +214,7 @@ describe('Supergraph SDL update failures', () => {
 
   it('Handles GraphQL errors', async () => {
     mockSupergraphSdlRequestSuccess();
-    mockSupergraphSdlRequest().reply(200, {
+    mockSupergraphSdlRequest('originalId-1234').reply(200, {
       errors: [
         {
           message: 'Cannot query field "fail" on type "Query".',
@@ -242,7 +248,7 @@ describe('Supergraph SDL update failures', () => {
 
   it("Doesn't update and logs on receiving unparseable Supergraph SDL", async () => {
     mockSupergraphSdlRequestSuccess();
-    mockSupergraphSdlRequest().reply(
+    mockSupergraphSdlRequestIfAfter('originalId-1234').reply(
       200,
       JSON.stringify({
         data: {
@@ -314,8 +320,12 @@ describe('Supergraph SDL update failures', () => {
 it('Rollsback to a previous schema when triggered', async () => {
   // Init
   mockSupergraphSdlRequestSuccess();
-  mockSupergraphSdlRequestSuccess(getTestingSupergraphSdl(fixturesWithUpdate), 'updatedId-5678');
-  mockSupergraphSdlRequestSuccess();
+  mockSupergraphSdlRequestSuccessIfAfter(
+    'originalId-1234',
+    'updatedId-5678',
+    getTestingSupergraphSdl(fixturesWithUpdate),
+  );
+  mockSupergraphSdlRequestSuccessIfAfter('updatedId-5678');
 
   let firstResolve: Function;
   let secondResolve: Function;
@@ -480,9 +490,10 @@ describe('Downstream service health checks', () => {
       mockAllServicesHealthCheckSuccess();
 
       // Update
-      mockSupergraphSdlRequestSuccess(
-        getTestingSupergraphSdl(fixturesWithUpdate),
+      mockSupergraphSdlRequestSuccessIfAfter(
+        'originalId-1234',
         'updatedId-5678',
+        getTestingSupergraphSdl(fixturesWithUpdate),
       );
       mockAllServicesHealthCheckSuccess();
 
@@ -523,9 +534,10 @@ describe('Downstream service health checks', () => {
       mockAllServicesHealthCheckSuccess();
 
       // Update (with one health check failure)
-      mockSupergraphSdlRequestSuccess(
-        getTestingSupergraphSdl(fixturesWithUpdate),
+      mockSupergraphSdlRequestSuccessIfAfter(
+        'originalId-1234',
         'updatedId-5678',
+        getTestingSupergraphSdl(fixturesWithUpdate),
       );
       mockServiceHealthCheck(accounts).reply(500);
       mockServiceHealthCheckSuccess(books);

package/src/__tests__/integration/nockMocks.ts

@@ -70,21 +70,30 @@ export const mockCloudConfigUrl =
 export const mockOutOfBandReporterUrl =
   'https://example.outofbandreporter.com/monitoring/';
 
-export function mockSupergraphSdlRequest() {
+export function mockSupergraphSdlRequestIfAfter(ifAfter: string | null) {
   return gatewayNock(mockCloudConfigUrl).post('/', {
     query: SUPERGRAPH_SDL_QUERY,
     variables: {
       ref: graphRef,
       apiKey: apiKey,
+      ifAfterId: ifAfter,
     },
   });
 }
 
-export function mockSupergraphSdlRequestSuccess(
-  supergraphSdl = getTestingSupergraphSdl(),
-  id = 'originalId-1234',
+export function mockSupergraphSdlRequest(ifAfter: string | null = null) {
+  return mockSupergraphSdlRequestIfAfter(ifAfter);
+}
+
+export function mockSupergraphSdlRequestSuccessIfAfter(
+  ifAfter: string | null = null,
+  id: string = 'originalId-1234',
+  supergraphSdl: string = getTestingSupergraphSdl(),
 ) {
-  return mockSupergraphSdlRequest().reply(
+  if (supergraphSdl == null) {
+    supergraphSdl = getTestingSupergraphSdl();
+  }
+  return mockSupergraphSdlRequestIfAfter(ifAfter).reply(
     200,
     JSON.stringify({
       data: {
@@ -98,6 +107,25 @@ export function mockSupergraphSdlRequestSuccess(
   );
 }
 
+export function mockSupergraphSdlRequestIfAfterUnchanged(
+    ifAfter: string | null = null,
+) {
+  return mockSupergraphSdlRequestIfAfter(ifAfter).reply(
+      200,
+      JSON.stringify({
+        data: {
+          routerConfig: {
+            __typename: 'Unchanged',
+          },
+        },
+      }),
+  );
+}
+
+export function mockSupergraphSdlRequestSuccess() {
+  return mockSupergraphSdlRequestSuccessIfAfter(null);
+}
+
 export function mockOutOfBandReportRequest() {
   return gatewayNock(mockOutOfBandReporterUrl).post('/', () => true);
 }

package/src/__tests__/loadSupergraphSdlFromStorage.test.ts

@@ -8,6 +8,7 @@ import {
   mockOutOfBandReporterUrl,
   mockOutOfBandReportRequestSuccess,
   mockSupergraphSdlRequestSuccess,
+  mockSupergraphSdlRequestIfAfterUnchanged,
 } from './integration/nockMocks';
 import mockedEnv from 'mocked-env';
 
@@ -30,6 +31,8 @@ describe('loadSupergraphSdlFromStorage', () => {
       apiKey,
       endpoint: mockCloudConfigUrl,
       fetcher,
+      compositionId: null,
+
     });
 
     expect(result).toMatchInlineSnapshot(`
@@ -358,6 +361,8 @@ describe('loadSupergraphSdlFromStorage', () => {
           apiKey,
           endpoint: mockCloudConfigUrl,
           fetcher,
+          compositionId: null,
+
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
         `"An error occurred while fetching your schema from Apollo: 200 invalid json response body at https://example.cloud-config-url.com/cloudconfig/ reason: Unexpected token I in JSON at position 0"`,
@@ -380,6 +385,7 @@ describe('loadSupergraphSdlFromStorage', () => {
           apiKey,
           endpoint: mockCloudConfigUrl,
           fetcher,
+          compositionId: null,
         }),
       ).rejects.toThrowError(message);
     });
@@ -394,6 +400,7 @@ describe('loadSupergraphSdlFromStorage', () => {
           apiKey,
           endpoint: mockCloudConfigUrl,
           fetcher,
+          compositionId: null,
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
         `"An error occurred while fetching your schema from Apollo: 500 Internal Server Error"`,
@@ -412,6 +419,7 @@ describe('loadSupergraphSdlFromStorage', () => {
           apiKey,
           endpoint: mockCloudConfigUrl,
           fetcher,
+          compositionId: null,
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
         `"An error occurred while fetching your schema from Apollo: 400 invalid json response body at https://example.cloud-config-url.com/cloudconfig/ reason: Unexpected end of JSON input"`,
@@ -433,6 +441,7 @@ describe('loadSupergraphSdlFromStorage', () => {
           apiKey,
           endpoint: mockCloudConfigUrl,
           fetcher,
+          compositionId: null,
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
         `"An error occurred while fetching your schema from Apollo: 400 invalid json response body at https://example.cloud-config-url.com/cloudconfig/ reason: Unexpected end of JSON input"`,
@@ -454,6 +463,7 @@ describe('loadSupergraphSdlFromStorage', () => {
           apiKey,
           endpoint: mockCloudConfigUrl,
           fetcher,
+          compositionId: null,
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
         `"An error occurred while fetching your schema from Apollo: 413 Payload Too Large"`,
@@ -475,6 +485,7 @@ describe('loadSupergraphSdlFromStorage', () => {
           apiKey,
           endpoint: mockCloudConfigUrl,
           fetcher,
+          compositionId: null,
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
         `"An error occurred while fetching your schema from Apollo: 422 Unprocessable Entity"`,
@@ -496,6 +507,7 @@ describe('loadSupergraphSdlFromStorage', () => {
           apiKey,
           endpoint: mockCloudConfigUrl,
           fetcher,
+          compositionId: null,
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
         `"An error occurred while fetching your schema from Apollo: 408 Request Timeout"`,
@@ -518,6 +530,7 @@ describe('loadSupergraphSdlFromStorage', () => {
         apiKey,
         endpoint: mockCloudConfigUrl,
         fetcher,
+        compositionId: null,
       }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(
       `"An error occurred while fetching your schema from Apollo: 504 Gateway Timeout"`,
@@ -539,6 +552,7 @@ describe('loadSupergraphSdlFromStorage', () => {
         apiKey,
         endpoint: mockCloudConfigUrl,
         fetcher,
+        compositionId: null,
       }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(
       `"An error occurred while fetching your schema from Apollo: request to https://example.cloud-config-url.com/cloudconfig/ failed, reason: no response"`,
@@ -560,6 +574,7 @@ describe('loadSupergraphSdlFromStorage', () => {
         apiKey,
         endpoint: mockCloudConfigUrl,
         fetcher,
+        compositionId: null,
       }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(
       `"An error occurred while fetching your schema from Apollo: 502 Bad Gateway"`,
@@ -581,9 +596,24 @@ describe('loadSupergraphSdlFromStorage', () => {
         apiKey,
         endpoint: mockCloudConfigUrl,
         fetcher,
+        compositionId: null,
       }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(
       `"An error occurred while fetching your schema from Apollo: 503 Service Unavailable"`,
     );
   });
+
+  it('successfully responds to SDL unchanged by returning null', async () => {
+    mockSupergraphSdlRequestIfAfterUnchanged("id-1234");
+
+    const fetcher = getDefaultFetcher();
+    const result = await loadSupergraphSdlFromStorage({
+        graphRef,
+        apiKey,
+        endpoint: mockCloudConfigUrl,
+        fetcher,
+        compositionId: "id-1234",
+    });
+    expect(result).toBeNull();
+  });
 });

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,

package/src/index.ts

@@ -193,6 +193,7 @@ export class ApolloGateway implements GraphQLService {
   private serviceSdlCache = new Map<string, string>();
   private warnedStates: WarnedStates = Object.create(null);
   private queryPlanner?: QueryPlanner;
+  private supergraphSdl?: string;
   private parsedSupergraphSdl?: DocumentNode;
   private fetcher: typeof fetch;
   private compositionId?: string;
@@ -447,6 +448,7 @@ export class ApolloGateway implements GraphQLService {
         : 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' };
@@ -576,6 +578,7 @@ export class ApolloGateway implements GraphQLService {
     await this.maybePerformServiceHealthCheck(result);
 
     this.compositionId = result.id;
+    this.supergraphSdl = result.supergraphSdl;
     this.parsedSupergraphSdl = parsedSupergraphSdl;
 
     const { schema, supergraphSdl } = this.createSchemaFromSupergraphSdl(
@@ -979,12 +982,18 @@ export class ApolloGateway implements GraphQLService {
 
     // TODO(trevor:cloudconfig): This condition goes away completely
     if (isPrecomposedManagedConfig(config)) {
-      return loadSupergraphSdlFromStorage({
+      const result = await loadSupergraphSdlFromStorage({
         graphRef: this.apolloConfig!.graphRef!,
         apiKey: this.apolloConfig!.key!,
         endpoint: this.schemaConfigDeliveryEndpoint!,
         fetcher: this.fetcher,
+        compositionId: this.compositionId ?? null,
       });
+
+      return result ?? {
+        id: this.compositionId!,
+        supergraphSdl: this.supergraphSdl!,
+      }
     } else if (isLegacyManagedConfig(config)) {
       return getServiceDefinitionsFromStorage({
         graphRef: this.apolloConfig!.graphRef!,