@apollo/gateway 2.0.2-alpha.0 → 2.0.2

package/src/datasources/RemoteGraphQLDataSource.ts

@@ -12,17 +12,19 @@ import {
   AuthenticationError,
   ForbiddenError,
 } from 'apollo-server-errors';
-import { fetch, Request, Headers, Response } from 'apollo-server-env';
 import { isObject } from '../utilities/predicates';
 import { GraphQLDataSource, GraphQLDataSourceProcessOptions, GraphQLDataSourceRequestKind } from './types';
 import { createHash } from '@apollo/utils.createhash';
 import { parseCacheControlHeader } from './parseCacheControlHeader';
 import fetcher from 'make-fetch-happen';
+import { Headers as NodeFetchHeaders, Request as NodeFetchRequest } from 'node-fetch';
+import { Fetcher, FetcherRequestInit, FetcherResponse } from '@apollo/utils.fetcher';
+
 export class RemoteGraphQLDataSource<
   TContext extends Record<string, any> = Record<string, any>,
 > implements GraphQLDataSource<TContext>
 {
-  fetcher: typeof fetch;
+  fetcher: Fetcher;
 
   constructor(
     config?: Partial<RemoteGraphQLDataSource<TContext>> &
@@ -30,6 +32,11 @@ export class RemoteGraphQLDataSource<
       ThisType<RemoteGraphQLDataSource<TContext>>,
   ) {
     this.fetcher = fetcher.defaults({
+      // Allow an arbitrary number of sockets per subgraph. This is the default
+      // behavior of Node's http.Agent as well as the npm package agentkeepalive
+      // which wraps it, but is not the default behavior of make-fetch-happen
+      // which wraps agentkeepalive (that package sets this to 15 by default).
+      maxSockets: Infinity,
       // although this is the default, we want to take extra care and be very
       // explicity to ensure that mutations cannot be retried. please leave this
       // intact.
@@ -82,7 +89,12 @@ export class RemoteGraphQLDataSource<
     const context = originalContext as TContext;
 
     // Respect incoming http headers (eg, apollo-federation-include-trace).
-    const headers = (request.http && request.http.headers) || new Headers();
+    const headers = new NodeFetchHeaders();
+    if (request.http?.headers) {
+      for (const [name, value] of request.http.headers) {
+        headers.append(name, value);
+      }
+    }
     headers.set('Content-Type', 'application/json');
 
     request.http = {
@@ -177,20 +189,24 @@ export class RemoteGraphQLDataSource<
     // we're accessing (e.g. url) and what we access it with (e.g. headers).
     const { http, ...requestWithoutHttp } = request;
     const stringifiedRequestWithoutHttp = JSON.stringify(requestWithoutHttp);
-    const fetchRequest = new Request(http.url, {
-      ...http,
+    const requestInit: FetcherRequestInit = {
+      method: http.method,
+      headers: Object.fromEntries(http.headers),
       body: stringifiedRequestWithoutHttp,
-    });
+    };
+    // Note that we don't actually send this Request object to the fetcher; it
+    // is merely sent to methods on this object that might be overridden by users.
+    // We are careful to only send data to the overridable fetcher function that uses
+    // plain JS objects --- some fetch implementations don't know how to handle
+    // Request or Headers objects created by other fetch implementations.
+    const fetchRequest = new NodeFetchRequest(http.url, requestInit);
 
-    let fetchResponse: Response | undefined;
+    let fetchResponse: FetcherResponse | undefined;
 
     try {
       // Use our local `fetcher` to allow for fetch injection
       // Use the fetcher's `Request` implementation for compatibility
-      fetchResponse = await this.fetcher(http.url, {
-        ...http,
-        body: stringifiedRequestWithoutHttp,
-      });
+      fetchResponse = await this.fetcher(http.url, requestInit);
 
       if (!fetchResponse.ok) {
         throw await this.errorFromResponse(fetchResponse);
@@ -266,16 +282,16 @@ export class RemoteGraphQLDataSource<
 
   public didEncounterError(
     error: Error,
-    _fetchRequest: Request,
-    _fetchResponse?: Response,
+    _fetchRequest: NodeFetchRequest,
+    _fetchResponse?: FetcherResponse,
     _context?: TContext,
   ) {
     throw error;
   }
 
   public parseBody(
-    fetchResponse: Response,
-    _fetchRequest?: Request,
+    fetchResponse: FetcherResponse,
+    _fetchRequest?: NodeFetchRequest,
     _context?: TContext,
   ): Promise<object | string> {
     const contentType = fetchResponse.headers.get('Content-Type');
@@ -286,7 +302,7 @@ export class RemoteGraphQLDataSource<
     }
   }
 
-  public async errorFromResponse(response: Response) {
+  public async errorFromResponse(response: FetcherResponse) {
     const message = `${response.status}: ${response.statusText}`;
 
     let error: ApolloError;

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

@@ -1,6 +1,3 @@
-import { fetch as customFetcher } from '../../__mocks__/apollo-server-env';
-import { fetch } from '../../__mocks__/make-fetch-happen-fetcher';
-
 import {
   ApolloError,
   AuthenticationError,
@@ -8,13 +5,18 @@ import {
 } from 'apollo-server-errors';
 
 import { RemoteGraphQLDataSource } from '../RemoteGraphQLDataSource';
-import { Headers } from 'apollo-server-env';
+import { Response, Headers } from 'node-fetch';
 import { GraphQLRequestContext } from 'apollo-server-types';
 import { GraphQLDataSourceRequestKind } from '../types';
+import { nockBeforeEach, nockAfterEach } from '../../__tests__/nockAssertions';
+import nock from 'nock';
 
-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 +34,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 +44,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 +52,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 +65,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 +99,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 +118,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 +135,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 +144,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 +156,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 +178,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 +203,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 +224,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 +248,6 @@ describe('fetcher', () => {
       },
     });
 
-    expect(injectedFetch).toHaveBeenCalled();
     expect(data).toEqual({ me: 'james' });
   });
 });
@@ -294,7 +261,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 +274,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 +289,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 +305,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',
-      },
-    });
   });
 });
 
@@ -379,7 +337,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({
@@ -418,7 +378,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,
@@ -452,7 +414,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 +447,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({
@@ -510,7 +474,7 @@ describe('error handling', () => {
       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,
@@ -533,7 +497,7 @@ describe('error handling', () => {
       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,
@@ -556,7 +520,7 @@ describe('error handling', () => {
       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,
@@ -578,17 +542,19 @@ 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,

package/src/executeQueryPlan.ts

@@ -2,7 +2,7 @@ import {
   GraphQLExecutionResult,
   GraphQLRequestContext,
 } from 'apollo-server-types';
-import { Headers } from 'apollo-server-env';
+import { Headers } from 'node-fetch';
 import {
   execute,
   GraphQLError,
@@ -380,6 +380,10 @@ async function executeFetch<TContext>(
   ): 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

package/src/index.ts

@@ -27,8 +27,6 @@ import {
 import { RemoteGraphQLDataSource } from './datasources/RemoteGraphQLDataSource';
 import { getVariableValues } from 'graphql/execution/values';
 import fetcher from 'make-fetch-happen';
-import { HttpRequestCache } from './cache';
-import { fetch } from 'apollo-server-env';
 import {
   QueryPlanner,
   QueryPlan,
@@ -67,6 +65,7 @@ import {
   Schema,
   ServiceDefinition,
 } from '@apollo/federation-internals';
+import { Fetcher } from '@apollo/utils.fetcher';
 
 type DataSourceMap = {
   [serviceName: string]: { url?: string; dataSource: GraphQLDataSource };
@@ -81,30 +80,6 @@ type WarnedStates = {
   remoteWithLocalConfig?: boolean;
 };
 
-export function getDefaultFetcher() {
-  const { name, version } = require('../package.json');
-  return fetcher.defaults({
-    cacheManager: new HttpRequestCache(),
-    // All headers should be lower-cased here, as `make-fetch-happen`
-    // treats differently cased headers as unique (unlike the `Headers` object).
-    // @see: https://git.io/JvRUa
-    headers: {
-      'apollographql-client-name': name,
-      'apollographql-client-version': version,
-      'user-agent': `${name}/${version}`,
-      'content-type': 'application/json',
-    },
-    retry: {
-      retries: 5,
-      // The default factor: expected attempts at 0, 1, 3, 7, 15, and 31 seconds elapsed
-      factor: 2,
-      // 1 second
-      minTimeout: 1000,
-      randomize: true,
-    },
-  });
-}
-
 export const HEALTH_CHECK_QUERY =
   'query __ApolloServiceHealthCheck__ { __typename }';
 export const SERVICE_DEFINITION_QUERY =
@@ -170,7 +145,7 @@ export class ApolloGateway implements GraphQLService {
   private warnedStates: WarnedStates = Object.create(null);
   private queryPlanner?: QueryPlanner;
   private supergraphSdl?: string;
-  private fetcher: typeof fetch;
+  private fetcher: Fetcher;
   private compositionId?: string;
   private state: GatewayState;
 
@@ -198,7 +173,7 @@ export class ApolloGateway implements GraphQLService {
     this.queryPlanStore = this.initQueryPlanStore(
       config?.experimental_approximateQueryPlanStoreMiB,
     );
-    this.fetcher = config?.fetcher || getDefaultFetcher();
+    this.fetcher = config?.fetcher || fetcher;
 
     // set up experimental observability callbacks and config settings
     this.experimental_didResolveQueryPlan =

package/src/supergraphManagers/IntrospectAndCompose/__tests__/IntrospectAndCompose.test.ts

@@ -119,11 +119,6 @@ describe('IntrospectAndCompose', () => {
 
   // TODO: useFakeTimers (though I'm struggling to get this to work as expected)
   it("doesn't call `update` when there's no change to the supergraph", async () => {
-    const fetcher =
-      jest.requireActual<typeof import('apollo-server-env')>(
-        'apollo-server-env',
-      ).fetch;
-
     // mock for initial load and a few polls against an unchanging schema
     mockAllServicesSdlQuerySuccess();
     mockAllServicesSdlQuerySuccess();
@@ -144,7 +139,6 @@ describe('IntrospectAndCompose', () => {
       getDataSource({ url }) {
         return new RemoteGraphQLDataSource({
           url,
-          fetcher,
         });
       },
     });