@apollo/gateway 2.0.1 → 2.0.2-alpha.2

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

@@ -4,6 +4,7 @@ import {
   GraphQLExecutionResult,
   GraphQLRequestContextExecutionDidStart,
 } from 'apollo-server-types';
+import { createHash } from '@apollo/utils.createhash';
 import type { Logger } from '@apollo/utils.logger';
 import { InMemoryLRUCache } from 'apollo-server-caching';
 import {
@@ -26,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,
@@ -53,14 +52,20 @@ import {
 } from './config';
 import { SpanStatusCode } from '@opentelemetry/api';
 import { OpenTelemetrySpanNames, tracer } from './utilities/opentelemetry';
-import { createHash } from './utilities/createHash';
+import { addExtensions } from './schema-helper/addExtensions';
 import {
   IntrospectAndCompose,
   UplinkFetcher,
   LegacyFetcher,
   LocalCompose,
 } from './supergraphManagers';
-import { buildSupergraphSchema, operationFromDocument, Schema, ServiceDefinition } from '@apollo/federation-internals';
+import {
+  buildSupergraphSchema,
+  operationFromDocument,
+  Schema,
+  ServiceDefinition,
+} from '@apollo/federation-internals';
+import { Fetcher } from '@apollo/utils.fetcher';
 
 type DataSourceMap = {
   [serviceName: string]: { url?: string; dataSource: GraphQLDataSource };
@@ -75,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 =
@@ -164,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;
 
@@ -192,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 =
@@ -426,6 +407,8 @@ export class ApolloGateway implements GraphQLService {
       }`,
     );
 
+    addExtensions(this.schema!);
+
     return {
       schema: this.schema!,
       executor: this.executor,
@@ -635,8 +618,8 @@ export class ApolloGateway implements GraphQLService {
   ): void {
     if (this.queryPlanStore) this.queryPlanStore.flush();
     this.apiSchema = coreSchema.toAPISchema();
-    this.schema = wrapSchemaWithAliasResolver(
-      this.apiSchema.toGraphQLJSSchema(),
+    this.schema = addExtensions(
+      wrapSchemaWithAliasResolver(this.apiSchema.toGraphQLJSSchema()),
     );
     this.queryPlanner = new QueryPlanner(coreSchema);
 

package/src/schema-helper/__tests__/addExtensions.test.ts

@@ -0,0 +1,11 @@
+import { buildSchema } from 'graphql';
+import { addExtensions } from '../addExtensions';
+const { version } = require('../../../package.json');
+
+describe('addExtensions', () => {
+  it('adds gateway extensions to a schema', async () => {
+    const schema = buildSchema('type Query { hello: String }');
+    expect(schema.extensions).toEqual({});
+    expect(addExtensions(schema).extensions).toEqual({ apollo: { gateway: { version: version } } });
+  });
+});

package/src/schema-helper/addExtensions.ts

@@ -0,0 +1,17 @@
+import { GraphQLSchema } from 'graphql';
+const { version } = require('../../package.json');
+
+export function addExtensions(schema: GraphQLSchema): GraphQLSchema {
+  schema.extensions = {
+    ...schema.extensions,
+    apollo: {
+      ...schema.extensions.apollo,
+      gateway: {
+        ...schema.extensions.apollo?.gateway,
+        version,
+      }
+    },
+  };
+
+  return schema;
+}

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,
         });
       },
     });