@apollo/gateway 0.35.0-alpha.1 → 0.37.0

package/src/datasources/RemoteGraphQLDataSource.ts

@@ -3,23 +3,25 @@ import {
   GraphQLResponse,
   ValueOrPromise,
   GraphQLRequest,
+  CacheHint,
+  CacheScope,
+  CachePolicy,
 } from 'apollo-server-types';
 import {
   ApolloError,
   AuthenticationError,
   ForbiddenError,
 } from 'apollo-server-errors';
-import {
-  fetch,
-  Request,
-  Headers,
-  Response,
-} from 'apollo-server-env';
+import { fetch, Request, Headers, Response } from 'apollo-server-env';
 import { isObject } from '../utilities/predicates';
-import { GraphQLDataSource } from './types';
+import { GraphQLDataSource, GraphQLDataSourceProcessOptions, GraphQLDataSourceRequestKind } from './types';
 import createSHA from 'apollo-server-core/dist/utils/createSHA';
+import { parseCacheControlHeader } from './parseCacheControlHeader';
 
-export class RemoteGraphQLDataSource<TContext extends Record<string, any> = Record<string, any>> implements GraphQLDataSource<TContext> {
+export class RemoteGraphQLDataSource<
+  TContext extends Record<string, any> = Record<string, any>,
+> implements GraphQLDataSource<TContext>
+{
   fetcher: typeof fetch = fetch;
 
   constructor(
@@ -54,12 +56,25 @@ export class RemoteGraphQLDataSource<TContext extends Record<string, any> = Reco
    */
   apq: boolean = false;
 
-  async process({
-    request,
-    context,
-  }: Pick<GraphQLRequestContext<TContext>, 'request' | 'context'>): Promise<
-    GraphQLResponse
-  > {
+  /**
+   * Should cache-control response headers from subgraphs affect the operation's
+   * cache policy? If it shouldn't, set this to false.
+   */
+  honorSubgraphCacheControlHeader: boolean = true;
+
+  async process(
+    options: GraphQLDataSourceProcessOptions<TContext>,
+  ): Promise<GraphQLResponse> {
+    const { request, context: originalContext } = options;
+    // Deal with a bit of a hairy situation in typings: when doing health checks
+    // and schema checks we always pass in `{}` as the context even though it's
+    // not really guaranteed to be a `TContext`, and then we pass it to various
+    // methods on this object. The reason this "works" is that the DataSourceMap
+    // and Service types aren't generic-ized on TContext at all (so `{}` is in
+    // practice always legal there)... ie, the genericness of this class is
+    // questionable in the first place.
+    const context = originalContext as TContext;
+
     // Respect incoming http headers (eg, apollo-federation-include-trace).
     const headers = (request.http && request.http.headers) || new Headers();
     headers.set('Content-Type', 'application/json');
@@ -71,24 +86,27 @@ export class RemoteGraphQLDataSource<TContext extends Record<string, any> = Reco
     };
 
     if (this.willSendRequest) {
-      await this.willSendRequest({ request, context });
+      await this.willSendRequest(options);
     }
 
     if (!request.query) {
-      throw new Error("Missing query");
+      throw new Error('Missing query');
     }
 
     const { query, ...requestWithoutQuery } = request;
 
-    const respond = (response: GraphQLResponse, request: GraphQLRequest) =>
-      typeof this.didReceiveResponse === "function"
-        ? this.didReceiveResponse({ response, request, context })
-        : response;
+    // Special handling of cache-control headers in response. Requires
+    // Apollo Server 3, so we check to make sure the method we want is
+    // there.
+    const overallCachePolicy =
+      this.honorSubgraphCacheControlHeader &&
+      options.kind === GraphQLDataSourceRequestKind.INCOMING_OPERATION &&
+      options.incomingRequestContext.overallCachePolicy?.restrict
+        ? options.incomingRequestContext.overallCachePolicy
+        : null;
 
     if (this.apq) {
-      const apqHash = createSHA('sha256')
-        .update(request.query)
-        .digest('hex');
+      const apqHash = createSHA('sha256').update(request.query).digest('hex');
 
       // Take the original extensions and extend them with
       // the necessary "extensions" for APQ handshaking.
@@ -100,17 +118,25 @@ export class RemoteGraphQLDataSource<TContext extends Record<string, any> = Reco
         },
       };
 
-      const apqOptimisticResponse =
-        await this.sendRequest(requestWithoutQuery, context);
+      const apqOptimisticResponse = await this.sendRequest(
+        requestWithoutQuery,
+        context,
+      );
 
       // If we didn't receive notice to retry with APQ, then let's
       // assume this is the best result we'll get and return it!
       if (
         !apqOptimisticResponse.errors ||
-        !apqOptimisticResponse.errors.find(error =>
-          error.message === 'PersistedQueryNotFound')
+        !apqOptimisticResponse.errors.find(
+          (error) => error.message === 'PersistedQueryNotFound',
+        )
       ) {
-        return respond(apqOptimisticResponse, requestWithoutQuery);
+        return this.respond({
+          response: apqOptimisticResponse,
+          request: requestWithoutQuery,
+          context,
+          overallCachePolicy,
+        });
       }
     }
 
@@ -122,18 +148,22 @@ export class RemoteGraphQLDataSource<TContext extends Record<string, any> = Reco
       ...requestWithoutQuery,
     };
     const response = await this.sendRequest(requestWithQuery, context);
-    return respond(response, requestWithQuery);
+    return this.respond({
+      response,
+      request: requestWithQuery,
+      context,
+      overallCachePolicy,
+    });
   }
 
   private async sendRequest(
     request: GraphQLRequest,
     context: TContext,
   ): Promise<GraphQLResponse> {
-
     // This would represent an internal programming error since this shouldn't
     // be possible in the way that this method is invoked right now.
     if (!request.http) {
-      throw new Error("Internal error: Only 'http' requests are supported.")
+      throw new Error("Internal error: Only 'http' requests are supported.");
     }
 
     // We don't want to serialize the `http` properties into the body that is
@@ -177,16 +207,54 @@ export class RemoteGraphQLDataSource<TContext extends Record<string, any> = Reco
   }
 
   public willSendRequest?(
-    requestContext: Pick<
-      GraphQLRequestContext<TContext>,
-      'request' | 'context'
-    >,
+    options: GraphQLDataSourceProcessOptions<TContext>,
   ): ValueOrPromise<void>;
 
+  private async respond({
+    response,
+    request,
+    context,
+    overallCachePolicy,
+  }: {
+    response: GraphQLResponse;
+    request: GraphQLRequest;
+    context: TContext;
+    overallCachePolicy: CachePolicy | null;
+  }): Promise<GraphQLResponse> {
+    const processedResponse =
+      typeof this.didReceiveResponse === 'function'
+        ? await this.didReceiveResponse({ response, request, context })
+        : response;
+
+    if (overallCachePolicy) {
+      const parsed = parseCacheControlHeader(
+        response.http?.headers.get('cache-control'),
+      );
+
+      // If the subgraph does not specify a max-age, we assume its response (and
+      // thus the overall response) is uncacheable. (If you don't like this, you
+      // can tweak the `cache-control` header in your `didReceiveResponse`
+      // method.)
+      const hint: CacheHint = { maxAge: 0 };
+      const maxAge = parsed['max-age'];
+      if (typeof maxAge === 'string' && maxAge.match(/^[0-9]+$/)) {
+        hint.maxAge = +maxAge;
+      }
+      if (parsed['private'] === true) {
+        hint.scope = CacheScope.Private;
+      }
+      if (parsed['public'] === true) {
+        hint.scope = CacheScope.Public;
+      }
+      overallCachePolicy.restrict(hint);
+    }
+
+    return processedResponse;
+  }
+
   public didReceiveResponse?(
-    requestContext: Required<Pick<
-      GraphQLRequestContext<TContext>,
-      'request' | 'response' | 'context'>
+    requestContext: Required<
+      Pick<GraphQLRequestContext<TContext>, 'request' | 'response' | 'context'>
     >,
   ): ValueOrPromise<GraphQLResponse>;
 

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

@@ -2,6 +2,8 @@ import { LocalGraphQLDataSource } from '../LocalGraphQLDataSource';
 import { buildFederatedSchema } from '@apollo/federation';
 import gql from 'graphql-tag';
 import { GraphQLResolverMap } from 'apollo-graphql';
+import { GraphQLRequestContext } from 'apollo-server-types';
+import { GraphQLDataSourceRequestKind } from '../types';
 
 describe('constructing requests', () => {
   it('accepts context', async () => {
@@ -25,7 +27,7 @@ describe('constructing requests', () => {
               name: 'someoneElse',
             },
           ];
-          return users.find(user => user.id === userId);
+          return users.find((user) => user.id === userId);
         },
       },
     };
@@ -34,9 +36,13 @@ describe('constructing requests', () => {
     const DataSource = new LocalGraphQLDataSource(schema);
 
     const { data } = await DataSource.process({
+      kind: GraphQLDataSourceRequestKind.INCOMING_OPERATION,
       request: {
         query: '{ me { name } }',
       },
+      incomingRequestContext: {
+        context: { userId: 2 },
+      } as GraphQLRequestContext<{userId: number}>,
       context: { userId: 2 },
     });
 

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

@@ -10,11 +10,20 @@ import {
 import { RemoteGraphQLDataSource } from '../RemoteGraphQLDataSource';
 import { Headers } from 'apollo-server-env';
 import { GraphQLRequestContext } from 'apollo-server-types';
+import { GraphQLDataSourceRequestKind } from '../types';
 
 beforeEach(() => {
   fetch.mockReset();
 });
 
+// Right now, none of these tests care what's on incomingRequestContext, so we
+// pass this fake one in.
+const defaultProcessOptions = {
+  kind: GraphQLDataSourceRequestKind.INCOMING_OPERATION,
+  incomingRequestContext: {} as any,
+  context: {},
+};
+
 describe('constructing requests', () => {
   describe('without APQ', () => {
     it('stringifies a request with a query', async () => {
@@ -26,8 +35,8 @@ describe('constructing requests', () => {
       fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
       const { data } = await DataSource.process({
+        ...defaultProcessOptions,
         request: { query: '{ me { name } }' },
-        context: {},
       });
 
       expect(data).toEqual({ me: 'james' });
@@ -46,11 +55,11 @@ describe('constructing requests', () => {
       fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
       const { data } = await DataSource.process({
+        ...defaultProcessOptions,
         request: {
           query: '{ me { name } }',
           variables: { id: '1' },
         },
-        context: {},
       });
 
       expect(data).toEqual({ me: 'james' });
@@ -96,8 +105,8 @@ describe('constructing requests', () => {
         fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
         const { data } = await DataSource.process({
+          ...defaultProcessOptions,
           request: { query },
-          context: {},
         });
 
         expect(data).toEqual({ me: 'james' });
@@ -135,11 +144,11 @@ describe('constructing requests', () => {
         fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
         const { data } = await DataSource.process({
+          ...defaultProcessOptions,
           request: {
             query,
             variables: { id: '1' },
           },
-          context: {},
         });
 
         expect(data).toEqual({ me: 'james' });
@@ -180,8 +189,8 @@ describe('constructing requests', () => {
         fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
         const { data } = await DataSource.process({
+          ...defaultProcessOptions,
           request: { query },
-          context: {},
         });
 
         expect(data).toEqual({ me: 'james' });
@@ -207,11 +216,11 @@ describe('constructing requests', () => {
         fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
         const { data } = await DataSource.process({
+          ...defaultProcessOptions,
           request: {
             query,
             variables: { id: '1' },
           },
-          context: {},
         });
 
         expect(data).toEqual({ me: 'james' });
@@ -243,11 +252,11 @@ describe('fetcher', () => {
     });
 
     const { data } = await DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
         variables: { id: '1' },
       },
-      context: {},
     });
 
     expect(injectedFetch).toHaveBeenCalled();
@@ -264,11 +273,11 @@ describe('fetcher', () => {
     });
 
     const { data } = await DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
         variables: { id: '1' },
       },
-      context: {},
     });
 
     expect(injectedFetch).toHaveBeenCalled();
@@ -288,11 +297,11 @@ describe('willSendRequest', () => {
     fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
     const { data } = await DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
         variables: { id: '1' },
       },
-      context: {},
     });
 
     expect(data).toEqual({ me: 'james' });
@@ -307,14 +316,20 @@ describe('willSendRequest', () => {
   it('accepts context', async () => {
     const DataSource = new RemoteGraphQLDataSource({
       url: 'https://api.example.com/foo',
-      willSendRequest: ({ request, context }) => {
-        request.http?.headers.set('x-user-id', context.userId);
+      willSendRequest: (options) => {
+        if (options.kind === GraphQLDataSourceRequestKind.INCOMING_OPERATION) {
+          options.request.http?.headers.set(
+            'x-user-id',
+            options.context.userId,
+          );
+        }
       },
     });
 
     fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
     const { data } = await DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
         variables: { id: '1' },
@@ -368,6 +383,7 @@ describe('didReceiveResponse', () => {
 
     const context: MyContext = { surrogateKeys: [] };
     await DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
         variables: { id: '1' },
@@ -405,11 +421,11 @@ describe('didReceiveResponse', () => {
     fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
     await DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
         variables: { id: '1' },
       },
-      context: {},
     });
 
     expect(spyDidReceiveResponse).toHaveBeenCalledTimes(1);
@@ -439,11 +455,11 @@ describe('didReceiveResponse', () => {
     fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
     await DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
         variables: { id: '1' },
       },
-      context: {},
     });
 
     expect(spyDidReceiveResponse).toHaveBeenCalledTimes(1);
@@ -471,15 +487,19 @@ describe('didEncounterError', () => {
 
     const context: MyContext = { timingData: [] };
     const result = DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
       },
+      incomingRequestContext: {
+        context,
+      } as GraphQLRequestContext<MyContext>,
       context,
     });
 
     await expect(result).rejects.toThrow(AuthenticationError);
     expect(context).toMatchObject({
-      timingData: [{ time: 1616446845234 }]
+      timingData: [{ time: 1616446845234 }],
     });
   });
 });
@@ -493,8 +513,8 @@ describe('error handling', () => {
     fetch.mockResponseOnce('Invalid token', undefined, 401);
 
     const result = DataSource.process({
+      ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
-      context: {},
     });
     await expect(result).rejects.toThrow(AuthenticationError);
     await expect(result).rejects.toMatchObject({
@@ -516,8 +536,8 @@ describe('error handling', () => {
     fetch.mockResponseOnce('No access', undefined, 403);
 
     const result = DataSource.process({
+      ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
-      context: {},
     });
     await expect(result).rejects.toThrow(ForbiddenError);
     await expect(result).rejects.toMatchObject({
@@ -539,8 +559,8 @@ describe('error handling', () => {
     fetch.mockResponseOnce('Oops', undefined, 500);
 
     const result = DataSource.process({
+      ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
-      context: {},
     });
     await expect(result).rejects.toThrow(ApolloError);
     await expect(result).rejects.toMatchObject({
@@ -571,8 +591,8 @@ describe('error handling', () => {
     );
 
     const result = DataSource.process({
+      ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
-      context: {},
     });
     await expect(result).rejects.toThrow(ApolloError);
     await expect(result).rejects.toMatchObject({

package/src/datasources/index.ts

@@ -1,3 +1,3 @@
 export { LocalGraphQLDataSource } from './LocalGraphQLDataSource';
 export { RemoteGraphQLDataSource } from './RemoteGraphQLDataSource';
-export { GraphQLDataSource } from './types';
+export { GraphQLDataSource, GraphQLDataSourceProcessOptions } from './types';

package/src/datasources/parseCacheControlHeader.ts

@@ -0,0 +1,43 @@
+// Adapted from https://github.com/kornelski/http-cache-semantics
+//
+// Copyright 2016-2018 Kornel Lesiński
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in
+//    the documentation and/or other materials provided with the
+//    distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+// WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+export function parseCacheControlHeader(
+  header: string | null | undefined,
+): Record<string, string | true> {
+  const cc: Record<string, string | true> = {};
+  if (!header) return cc;
+
+  const parts = header.trim().split(/\s*,\s*/);
+  for (const part of parts) {
+    const [k, v] = part.split(/\s*=\s*/, 2);
+    cc[k] = v === undefined ? true : v.replace(/^"|"$/g, '');
+  }
+
+  return cc;
+}

package/src/datasources/types.ts

@@ -1,7 +1,52 @@
 import { GraphQLResponse, GraphQLRequestContext } from 'apollo-server-types';
 
-export interface GraphQLDataSource<TContext extends Record<string, any> = Record<string, any>> {
+export interface GraphQLDataSource<
+  TContext extends Record<string, any> = Record<string, any>,
+> {
   process(
-    request: Pick<GraphQLRequestContext<TContext>, 'request' | 'context'>,
+    options: GraphQLDataSourceProcessOptions<TContext>,
   ): Promise<GraphQLResponse>;
 }
+
+export enum GraphQLDataSourceRequestKind {
+  INCOMING_OPERATION = 'incoming operation',
+  HEALTH_CHECK = 'health check',
+  LOADING_SCHEMA = 'loading schema',
+}
+
+export type GraphQLDataSourceProcessOptions<
+  TContext extends Record<string, any> = Record<string, any>,
+> = {
+  /**
+   * The request to send to the subgraph.
+   */
+  request: GraphQLRequestContext<TContext>['request'];
+} & (
+  | {
+      kind: GraphQLDataSourceRequestKind.INCOMING_OPERATION;
+      /**
+       * The GraphQLRequestContext for the operation received by the gateway, or
+       * one of the strings if this operation is generated by the gateway without an
+       * incoming request.
+       */
+      incomingRequestContext: GraphQLRequestContext<TContext>;
+      /**
+       * Equivalent to incomingRequestContext.context (provided here for
+       * backwards compatibility): the object created by the Apollo Server
+       * `context` function.
+       *
+       * @deprecated Use `incomingRequestContext.context` instead (after
+       * checking `kind`).
+       */
+      context: GraphQLRequestContext<TContext>['context'];
+    }
+  | {
+      kind:
+        | GraphQLDataSourceRequestKind.HEALTH_CHECK
+        | GraphQLDataSourceRequestKind.LOADING_SCHEMA;
+      /**
+       * Mostly provided for historical reasons.
+       */
+      context: {};
+    }
+);

package/src/executeQueryPlan.ts

@@ -15,7 +15,7 @@ import {
 } from 'graphql';
 import { Trace, google } from 'apollo-reporting-protobuf';
 import { defaultRootOperationNameLookup } from '@apollo/federation';
-import { GraphQLDataSource } from './datasources/types';
+import { GraphQLDataSource, GraphQLDataSourceRequestKind } from './datasources/types';
 import { OperationContext } from './operationContext';
 import {
   FetchNode,
@@ -374,11 +374,13 @@ async function executeFetch<TContext>(
     }
 
     const response = await service.process({
+      kind: GraphQLDataSourceRequestKind.INCOMING_OPERATION,
       request: {
         query: source,
         variables,
         http,
       },
+      incomingRequestContext: context.requestContext,
       context: context.requestContext.context,
     });
 

package/src/index.ts

@@ -29,7 +29,7 @@ import {
 } from './executeQueryPlan';
 
 import { getServiceDefinitionsFromRemoteEndpoint } from './loadServicesFromRemoteEndpoint';
-import { GraphQLDataSource } from './datasources/types';
+import { GraphQLDataSource, GraphQLDataSourceRequestKind } from './datasources/types';
 import { RemoteGraphQLDataSource } from './datasources/RemoteGraphQLDataSource';
 import { getVariableValues } from 'graphql/execution/values';
 import fetcher from 'make-fetch-happen';
@@ -699,7 +699,11 @@ export class ApolloGateway implements GraphQLService {
     return Promise.all(
       Object.entries(serviceMap).map(([name, { dataSource }]) =>
         dataSource
-          .process({ request: { query: HEALTH_CHECK_QUERY }, context: {} })
+          .process({
+            kind: GraphQLDataSourceRequestKind.HEALTH_CHECK,
+            request: { query: HEALTH_CHECK_QUERY },
+            context: {},
+          })
           .then((response) => ({ name, response }))
           .catch((e) => {
             throw new Error(`[${name}]: ${e.message}`);
@@ -1014,8 +1018,13 @@ export class ApolloGateway implements GraphQLService {
   public executor = async <TContext>(
     requestContext: GraphQLRequestContextExecutionDidStart<TContext>,
   ): Promise<GraphQLExecutionResult> => {
+    const spanAttributes = requestContext.operationName
+      ? { operationName: requestContext.operationName }
+      : {};
+
     return tracer.startActiveSpan(
       OpenTelemetrySpanNames.REQUEST,
+      { attributes: spanAttributes },
       async (span) => {
         try {
           const { request, document, queryHash } = requestContext;