@apollo/gateway 0.50.1 → 0.52.0

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

@@ -1,20 +1,17 @@
-import { fetch as customFetcher } from '../../__mocks__/apollo-server-env';
-import { fetch } from '../../__mocks__/make-fetch-happen-fetcher';
-
-import {
-  ApolloError,
-  AuthenticationError,
-  ForbiddenError,
-} from 'apollo-server-errors';
-
 import { RemoteGraphQLDataSource } from '../RemoteGraphQLDataSource';
-import { Headers } from 'apollo-server-env';
-import { GraphQLRequestContext } from 'apollo-server-types';
+import { Response, Headers } from 'node-fetch';
 import { GraphQLDataSourceRequestKind } from '../types';
+import { nockBeforeEach, nockAfterEach } from '../../__tests__/nockAssertions';
+import nock from 'nock';
+import { GraphQLError } from 'graphql';
+import { GatewayGraphQLRequestContext } from '@apollo/server-gateway-interface';
 
-beforeEach(() => {
-  fetch.mockReset();
-});
+beforeEach(nockBeforeEach);
+afterEach(nockAfterEach);
+
+const replyHeaders = {
+  'content-type': 'application/json',
+};
 
 // Right now, none of these tests care what's on incomingRequestContext, so we
 // pass this fake one in.
@@ -32,7 +29,9 @@ describe('constructing requests', () => {
         apq: false,
       });
 
-      fetch.mockJSONResponseOnce({ data: { me: 'james' } });
+      nock('https://api.example.com')
+        .post('/foo', { query: '{ me { name } }' })
+        .reply(200, { data: { me: 'james' } }, replyHeaders);
 
       const { data } = await DataSource.process({
         ...defaultProcessOptions,
@@ -40,10 +39,6 @@ describe('constructing requests', () => {
       });
 
       expect(data).toEqual({ me: 'james' });
-      expect(fetch).toBeCalledTimes(1);
-      expect(fetch).toHaveFetched('https://api.example.com/foo', {
-        body: { query: '{ me { name } }' },
-      });
     });
 
     it('passes variables', async () => {
@@ -52,7 +47,9 @@ describe('constructing requests', () => {
         apq: false,
       });
 
-      fetch.mockJSONResponseOnce({ data: { me: 'james' } });
+      nock('https://api.example.com')
+        .post('/foo', { query: '{ me { name } }', variables: { id: '1' } })
+        .reply(200, { data: { me: 'james' } }, replyHeaders);
 
       const { data } = await DataSource.process({
         ...defaultProcessOptions,
@@ -63,10 +60,6 @@ describe('constructing requests', () => {
       });
 
       expect(data).toEqual({ me: 'james' });
-      expect(fetch).toBeCalledTimes(1);
-      expect(fetch).toHaveFetched('https://api.example.com/foo', {
-        body: { query: '{ me { name } }', variables: { id: '1' } },
-      });
     });
   });
 
@@ -101,28 +94,18 @@ describe('constructing requests', () => {
           apq: true,
         });
 
-        fetch.mockJSONResponseOnce(apqNotFoundResponse);
-        fetch.mockJSONResponseOnce({ data: { me: 'james' } });
-
-        const { data } = await DataSource.process({
-          ...defaultProcessOptions,
-          request: { query },
-        });
-
-        expect(data).toEqual({ me: 'james' });
-        expect(fetch).toBeCalledTimes(2);
-        expect(fetch).toHaveFetchedNth(1, 'https://api.example.com/foo', {
-          body: {
+        nock('https://api.example.com')
+          .post('/foo', {
             extensions: {
               persistedQuery: {
                 version: 1,
                 sha256Hash,
               },
             },
-          },
-        });
-        expect(fetch).toHaveFetchedNth(2, 'https://api.example.com/foo', {
-          body: {
+          })
+          .reply(200, apqNotFoundResponse, replyHeaders);
+        nock('https://api.example.com')
+          .post('/foo', {
             query,
             extensions: {
               persistedQuery: {
@@ -130,8 +113,15 @@ describe('constructing requests', () => {
                 sha256Hash,
               },
             },
-          },
+          })
+          .reply(200, { data: { me: 'james' } }, replyHeaders);
+
+        const { data } = await DataSource.process({
+          ...defaultProcessOptions,
+          request: { query },
         });
+
+        expect(data).toEqual({ me: 'james' });
       });
 
       it('passes variables', async () => {
@@ -140,21 +130,8 @@ describe('constructing requests', () => {
           apq: true,
         });
 
-        fetch.mockJSONResponseOnce(apqNotFoundResponse);
-        fetch.mockJSONResponseOnce({ data: { me: 'james' } });
-
-        const { data } = await DataSource.process({
-          ...defaultProcessOptions,
-          request: {
-            query,
-            variables: { id: '1' },
-          },
-        });
-
-        expect(data).toEqual({ me: 'james' });
-        expect(fetch).toBeCalledTimes(2);
-        expect(fetch).toHaveFetchedNth(1, 'https://api.example.com/foo', {
-          body: {
+        nock('https://api.example.com')
+          .post('/foo', {
             variables: { id: '1' },
             extensions: {
               persistedQuery: {
@@ -162,10 +139,10 @@ describe('constructing requests', () => {
                 sha256Hash,
               },
             },
-          },
-        });
-        expect(fetch).toHaveFetchedNth(2, 'https://api.example.com/foo', {
-          body: {
+          })
+          .reply(200, apqNotFoundResponse, replyHeaders);
+        nock('https://api.example.com')
+          .post('/foo', {
             query,
             variables: { id: '1' },
             extensions: {
@@ -174,8 +151,18 @@ describe('constructing requests', () => {
                 sha256Hash,
               },
             },
+          })
+          .reply(200, { data: { me: 'james' } }, replyHeaders);
+
+        const { data } = await DataSource.process({
+          ...defaultProcessOptions,
+          request: {
+            query,
+            variables: { id: '1' },
           },
         });
+
+        expect(data).toEqual({ me: 'james' });
       });
     });
 
@@ -186,25 +173,23 @@ describe('constructing requests', () => {
           apq: true,
         });
 
-        fetch.mockJSONResponseOnce({ data: { me: 'james' } });
-
-        const { data } = await DataSource.process({
-          ...defaultProcessOptions,
-          request: { query },
-        });
-
-        expect(data).toEqual({ me: 'james' });
-        expect(fetch).toBeCalledTimes(1);
-        expect(fetch).toHaveFetched('https://api.example.com/foo', {
-          body: {
+        nock('https://api.example.com')
+          .post('/foo', {
             extensions: {
               persistedQuery: {
                 version: 1,
                 sha256Hash,
               },
             },
-          },
+          })
+          .reply(200, { data: { me: 'james' } }, replyHeaders);
+
+        const { data } = await DataSource.process({
+          ...defaultProcessOptions,
+          request: { query },
         });
+
+        expect(data).toEqual({ me: 'james' });
       });
 
       it('passes variables', async () => {
@@ -213,7 +198,17 @@ describe('constructing requests', () => {
           apq: true,
         });
 
-        fetch.mockJSONResponseOnce({ data: { me: 'james' } });
+        nock('https://api.example.com')
+          .post('/foo', {
+            variables: { id: '1' },
+            extensions: {
+              persistedQuery: {
+                version: 1,
+                sha256Hash,
+              },
+            },
+          })
+          .reply(200, { data: { me: 'james' } }, replyHeaders);
 
         const { data } = await DataSource.process({
           ...defaultProcessOptions,
@@ -224,52 +219,20 @@ describe('constructing requests', () => {
         });
 
         expect(data).toEqual({ me: 'james' });
-        expect(fetch).toBeCalledTimes(1);
-        expect(fetch).toHaveFetched('https://api.example.com/foo', {
-          body: {
-            variables: { id: '1' },
-            extensions: {
-              persistedQuery: {
-                version: 1,
-                sha256Hash,
-              },
-            },
-          },
-        });
       });
     });
   });
 });
 
 describe('fetcher', () => {
-  it('uses a custom provided `fetcher`', async () => {
-    const injectedFetch = fetch.mockJSONResponseOnce({
-      data: { injected: true },
-    });
-    const DataSource = new RemoteGraphQLDataSource({
-      url: 'https://api.example.com/foo',
-      fetcher: injectedFetch,
-    });
-
-    const { data } = await DataSource.process({
-      ...defaultProcessOptions,
-      request: {
-        query: '{ me { name } }',
-        variables: { id: '1' },
-      },
-    });
-
-    expect(injectedFetch).toHaveBeenCalled();
-    expect(data).toEqual({ injected: true });
-  });
-
-  it('supports a custom fetcher, like `node-fetch`', async () => {
-    const injectedFetch = customFetcher.mockJSONResponseOnce({
-      data: { me: 'james' },
-    });
+  it('supports a custom fetcher', async () => {
     const DataSource = new RemoteGraphQLDataSource({
       url: 'https://api.example.com/foo',
-      fetcher: injectedFetch,
+      fetcher: async () =>
+        new Response(JSON.stringify({ data: { me: 'james' } }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        }),
     });
 
     const { data } = await DataSource.process({
@@ -280,7 +243,6 @@ describe('fetcher', () => {
       },
     });
 
-    expect(injectedFetch).toHaveBeenCalled();
     expect(data).toEqual({ me: 'james' });
   });
 });
@@ -294,7 +256,9 @@ describe('willSendRequest', () => {
       },
     });
 
-    fetch.mockJSONResponseOnce({ data: { me: 'james' } });
+    nock('https://api.example.com')
+      .post('/foo', { query: '{ me { name } }', variables: { id: '2' } })
+      .reply(200, { data: { me: 'james' } }, replyHeaders);
 
     const { data } = await DataSource.process({
       ...defaultProcessOptions,
@@ -305,12 +269,6 @@ describe('willSendRequest', () => {
     });
 
     expect(data).toEqual({ me: 'james' });
-    expect(fetch).toHaveFetched('https://api.example.com/foo', {
-      body: {
-        query: '{ me { name } }',
-        variables: { id: '2' },
-      },
-    });
   });
 
   it('accepts context', async () => {
@@ -326,7 +284,11 @@ describe('willSendRequest', () => {
       },
     });
 
-    fetch.mockJSONResponseOnce({ data: { me: 'james' } });
+    nock('https://api.example.com', {
+      reqheaders: { 'x-user-id': '1234' },
+    })
+      .post('/foo', { query: '{ me { name } }', variables: { id: '1' } })
+      .reply(200, { data: { me: 'james' } }, replyHeaders);
 
     const { data } = await DataSource.process({
       ...defaultProcessOptions,
@@ -338,15 +300,6 @@ describe('willSendRequest', () => {
     });
 
     expect(data).toEqual({ me: 'james' });
-    expect(fetch).toHaveFetched('https://api.example.com/foo', {
-      body: {
-        query: '{ me { name } }',
-        variables: { id: '1' },
-      },
-      headers: {
-        'x-user-id': '1234',
-      },
-    });
   });
 });
 
@@ -364,7 +317,7 @@ describe('didReceiveResponse', () => {
         response,
       }: Required<
         Pick<
-          GraphQLRequestContext<MyContext>,
+          GatewayGraphQLRequestContext<MyContext>,
           'request' | 'response' | 'context'
         >
       >) {
@@ -379,7 +332,9 @@ describe('didReceiveResponse', () => {
 
     const DataSource = new MyDataSource();
 
-    fetch.mockJSONResponseOnce({ data: { me: 'james' } });
+    nock('https://api.example.com')
+      .post('/foo', { query: '{ me { name } }', variables: { id: '1' } })
+      .reply(200, { data: { me: 'james' } }, replyHeaders);
 
     const context: MyContext = { surrogateKeys: [] };
     await DataSource.process({
@@ -407,7 +362,7 @@ describe('didReceiveResponse', () => {
         response,
       }: Required<
         Pick<
-          GraphQLRequestContext<MyContext>,
+          GatewayGraphQLRequestContext<MyContext>,
           'request' | 'response' | 'context'
         >
       >) {
@@ -418,7 +373,9 @@ describe('didReceiveResponse', () => {
     const DataSource = new MyDataSource();
     const spyDidReceiveResponse = jest.spyOn(DataSource, 'didReceiveResponse');
 
-    fetch.mockJSONResponseOnce({ data: { me: 'james' } });
+    nock('https://api.example.com')
+      .post('/foo', { query: '{ me { name } }', variables: { id: '1' } })
+      .reply(200, { data: { me: 'james' } }, replyHeaders);
 
     await DataSource.process({
       ...defaultProcessOptions,
@@ -441,7 +398,7 @@ describe('didReceiveResponse', () => {
         response,
       }: Required<
         Pick<
-          GraphQLRequestContext<MyContext>,
+          GatewayGraphQLRequestContext<MyContext>,
           'request' | 'response' | 'context'
         >
       >) {
@@ -452,7 +409,9 @@ describe('didReceiveResponse', () => {
     const DataSource = new MyDataSource();
     const spyDidReceiveResponse = jest.spyOn(DataSource, 'didReceiveResponse');
 
-    fetch.mockJSONResponseOnce({ data: { me: 'james' } });
+    nock('https://api.example.com')
+      .post('/foo')
+      .reply(200, { data: { me: 'james' } }, replyHeaders);
 
     await DataSource.process({
       ...defaultProcessOptions,
@@ -483,7 +442,7 @@ describe('didEncounterError', () => {
 
     const DataSource = new MyDataSource();
 
-    fetch.mockResponseOnce('Invalid token', undefined, 401);
+    nock('https://api.example.com').post('/foo').reply(401, 'Invalid token');
 
     const context: MyContext = { timingData: [] };
     const result = DataSource.process({
@@ -493,11 +452,11 @@ describe('didEncounterError', () => {
       },
       incomingRequestContext: {
         context,
-      } as GraphQLRequestContext<MyContext>,
+      } as GatewayGraphQLRequestContext<MyContext>,
       context,
     });
 
-    await expect(result).rejects.toThrow(AuthenticationError);
+    await expect(result).rejects.toThrow(GraphQLError);
     expect(context).toMatchObject({
       timingData: [{ time: 1616446845234 }],
     });
@@ -505,18 +464,18 @@ describe('didEncounterError', () => {
 });
 
 describe('error handling', () => {
-  it('throws an AuthenticationError when the response status is 401', async () => {
+  it('throws error with code UNAUTHENTICATED when the response status is 401', async () => {
     const DataSource = new RemoteGraphQLDataSource({
       url: 'https://api.example.com/foo',
     });
 
-    fetch.mockResponseOnce('Invalid token', undefined, 401);
+    nock('https://api.example.com').post('/foo').reply(401, 'Invalid token');
 
     const result = DataSource.process({
       ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
     });
-    await expect(result).rejects.toThrow(AuthenticationError);
+    await expect(result).rejects.toThrow(GraphQLError);
     await expect(result).rejects.toMatchObject({
       extensions: {
         code: 'UNAUTHENTICATED',
@@ -528,18 +487,18 @@ describe('error handling', () => {
     });
   });
 
-  it('throws a ForbiddenError when the response status is 403', async () => {
+  it('throws an error with code FORBIDDEN when the response status is 403', async () => {
     const DataSource = new RemoteGraphQLDataSource({
       url: 'https://api.example.com/foo',
     });
 
-    fetch.mockResponseOnce('No access', undefined, 403);
+    nock('https://api.example.com').post('/foo').reply(403, 'No access');
 
     const result = DataSource.process({
       ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
     });
-    await expect(result).rejects.toThrow(ForbiddenError);
+    await expect(result).rejects.toThrow(GraphQLError);
     await expect(result).rejects.toMatchObject({
       extensions: {
         code: 'FORBIDDEN',
@@ -551,18 +510,18 @@ describe('error handling', () => {
     });
   });
 
-  it('throws an ApolloError when the response status is 500', async () => {
+  it('throws a GraphQLError when the response status is 500', async () => {
     const DataSource = new RemoteGraphQLDataSource({
       url: 'https://api.example.com/foo',
     });
 
-    fetch.mockResponseOnce('Oops', undefined, 500);
+    nock('https://api.example.com').post('/foo').reply(500, 'Oops');
 
     const result = DataSource.process({
       ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
     });
-    await expect(result).rejects.toThrow(ApolloError);
+    await expect(result).rejects.toThrow(GraphQLError);
     await expect(result).rejects.toMatchObject({
       extensions: {
         response: {
@@ -578,23 +537,25 @@ describe('error handling', () => {
       url: 'https://api.example.com/foo',
     });
 
-    fetch.mockResponseOnce(
-      JSON.stringify({
-        errors: [
-          {
-            message: 'Houston, we have a problem.',
-          },
-        ],
-      }),
-      { 'Content-Type': 'application/json' },
-      500,
-    );
+    nock('https://api.example.com')
+      .post('/foo')
+      .reply(
+        500,
+        {
+          errors: [
+            {
+              message: 'Houston, we have a problem.',
+            },
+          ],
+        },
+        { 'Content-Type': 'application/json' },
+      );
 
     const result = DataSource.process({
       ...defaultProcessOptions,
       request: { query: '{ me { name } }' },
     });
-    await expect(result).rejects.toThrow(ApolloError);
+    await expect(result).rejects.toThrow(GraphQLError);
     await expect(result).rejects.toMatchObject({
       extensions: {
         response: {

package/src/datasources/types.ts

@@ -1,11 +1,11 @@
-import { GraphQLResponse, GraphQLRequestContext } from 'apollo-server-types';
+import { GatewayGraphQLResponse, GatewayGraphQLRequestContext } from '@apollo/server-gateway-interface';
 
 export interface GraphQLDataSource<
   TContext extends Record<string, any> = Record<string, any>,
 > {
   process(
     options: GraphQLDataSourceProcessOptions<TContext>,
-  ): Promise<GraphQLResponse>;
+  ): Promise<GatewayGraphQLResponse>;
 }
 
 export enum GraphQLDataSourceRequestKind {
@@ -20,7 +20,7 @@ export type GraphQLDataSourceProcessOptions<
   /**
    * The request to send to the subgraph.
    */
-  request: GraphQLRequestContext<TContext>['request'];
+  request: GatewayGraphQLRequestContext<TContext>['request'];
 } & (
   | {
       kind: GraphQLDataSourceRequestKind.INCOMING_OPERATION;
@@ -28,8 +28,15 @@ export type GraphQLDataSourceProcessOptions<
        * 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.
+       *
+       * For backwards compatibility with Apollo Server 2, `overallCachePolicy` needs
+       * to be treated as optional.
        */
-      incomingRequestContext: GraphQLRequestContext<TContext>;
+      incomingRequestContext: Omit<
+        GatewayGraphQLRequestContext<TContext>,
+        'overallCachePolicy'
+      > &
+        Pick<Partial<GatewayGraphQLRequestContext<TContext>>, 'overallCachePolicy'>;
       /**
        * Equivalent to incomingRequestContext.context (provided here for
        * backwards compatibility): the object created by the Apollo Server
@@ -38,7 +45,7 @@ export type GraphQLDataSourceProcessOptions<
        * @deprecated Use `incomingRequestContext.context` instead (after
        * checking `kind`).
        */
-      context: GraphQLRequestContext<TContext>['context'];
+      context: GatewayGraphQLRequestContext<TContext>['context'];
     }
   | {
       kind:

package/src/executeQueryPlan.ts

@@ -1,9 +1,4 @@
-import {
-  GraphQLExecutionResult,
-  GraphQLRequestContext,
-  VariableValues,
-} from 'apollo-server-types';
-import { Headers } from 'apollo-server-env';
+import { Headers } from 'node-fetch';
 import {
   execute,
   GraphQLError,
@@ -34,6 +29,7 @@ import { deepMerge } from './utilities/deepMerge';
 import { isNotNullOrUndefined } from './utilities/array';
 import { SpanStatusCode } from "@opentelemetry/api";
 import { OpenTelemetrySpanNames, tracer } from "./utilities/opentelemetry";
+import { GatewayGraphQLRequestContext, GatewayExecutionResult } from '@apollo/server-gateway-interface';
 
 export type ServiceMap = {
   [serviceName: string]: GraphQLDataSource;
@@ -41,20 +37,20 @@ export type ServiceMap = {
 
 type ResultMap = Record<string, any>;
 
-interface ExecutionContext<TContext> {
+interface ExecutionContext {
   queryPlan: QueryPlan;
   operationContext: OperationContext;
   serviceMap: ServiceMap;
-  requestContext: GraphQLRequestContext<TContext>;
+  requestContext: GatewayGraphQLRequestContext;
   errors: GraphQLError[];
 }
 
-export async function executeQueryPlan<TContext>(
+export async function executeQueryPlan(
   queryPlan: QueryPlan,
   serviceMap: ServiceMap,
-  requestContext: GraphQLRequestContext<TContext>,
+  requestContext: GatewayGraphQLRequestContext,
   operationContext: OperationContext,
-): Promise<GraphQLExecutionResult> {
+): Promise<GatewayExecutionResult> {
 
   const logger = requestContext.logger || console;
 
@@ -62,7 +58,7 @@ export async function executeQueryPlan<TContext>(
     try {
       const errors: GraphQLError[] = [];
 
-      const context: ExecutionContext<TContext> = {
+      const context: ExecutionContext = {
         queryPlan,
         operationContext,
         serviceMap,
@@ -171,8 +167,8 @@ export async function executeQueryPlan<TContext>(
 // we're going to ignore it, because it makes the code much simpler and more
 // typesafe. However, it doesn't actually ask for traces from the backend
 // service unless we are capturing traces for Studio.
-async function executeNode<TContext>(
-  context: ExecutionContext<TContext>,
+async function executeNode(
+  context: ExecutionContext,
   node: PlanNode,
   results: ResultMap | ResultMap[],
   path: ResponsePath,
@@ -261,7 +257,7 @@ async function executeNode<TContext>(
 
 export function shouldSkipFetchNode(
   node: FetchNode,
-  variables: VariableValues = {},
+  variables: Record<string, any> = {},
 ) {
   if (!node.inclusionConditions) return false;
 
@@ -284,8 +280,8 @@ export function shouldSkipFetchNode(
   });
 }
 
-async function executeFetch<TContext>(
-  context: ExecutionContext<TContext>,
+async function executeFetch(
+  context: ExecutionContext,
   fetch: FetchNode,
   results: ResultMap | (ResultMap | null | undefined)[],
   _path: ResponsePath,
@@ -404,13 +400,17 @@ async function executeFetch<TContext>(
     }
   });
   async function sendOperation(
-    context: ExecutionContext<TContext>,
+    context: ExecutionContext,
     source: string,
     variables: Record<string, any>,
     operationName: string | undefined,
   ): Promise<ResultMap | void | null> {
     // We declare this as 'any' because it is missing url and method, which
     // GraphQLRequest.http is supposed to have if it exists.
+    // (This is admittedly kinda weird, since we currently do pass url and
+    // method to `process` from the SDL fetching call site, but presumably
+    // existing implementation of the interface don't try to look for these
+    // fields. RemoteGraphQLDataSource just overwrites them.)
     let http: any;
 
     // If we're capturing a trace for Studio, then save the operation text to