@apollo/gateway 0.300.0-alpha.2 → 2.0.0-alpha.2

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

@@ -1,4 +1,5 @@
-import { fetch } from '__mocks__/apollo-server-env';
+import { fetch } from '../../__mocks__/apollo-server-env';
+import { makeFetchHappenFetcher } from '../../__mocks__/make-fetch-happen-fetcher';
 
 import {
   ApolloError,
@@ -9,12 +10,20 @@ import {
 import { RemoteGraphQLDataSource } from '../RemoteGraphQLDataSource';
 import { Headers } from 'apollo-server-env';
 import { GraphQLRequestContext } from 'apollo-server-types';
-import { Response } from '../../../../../../apollo-tooling/packages/apollo-env/lib';
+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,14 +35,13 @@ describe('constructing requests', () => {
       fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
       const { data } = await DataSource.process({
+        ...defaultProcessOptions,
         request: { query: '{ me { name } }' },
-        context: {},
       });
 
       expect(data).toEqual({ me: 'james' });
       expect(fetch).toBeCalledTimes(1);
-      expect(fetch).toHaveFetched({
-        url: 'https://api.example.com/foo',
+      expect(fetch).toHaveFetched('https://api.example.com/foo', {
         body: { query: '{ me { name } }' },
       });
     });
@@ -47,17 +55,16 @@ 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' });
       expect(fetch).toBeCalledTimes(1);
-      expect(fetch).toHaveFetched({
-        url: 'https://api.example.com/foo',
+      expect(fetch).toHaveFetched('https://api.example.com/foo', {
         body: { query: '{ me { name } }', variables: { id: '1' } },
       });
     });
@@ -69,21 +76,23 @@ describe('constructing requests', () => {
 
     // This is a SHA-256 hash of `query` above.
     const sha256Hash =
-      "b8d9506e34c83b0e53c2aa463624fcea354713bc38f95276e6f0bd893ffb5b88";
+      'b8d9506e34c83b0e53c2aa463624fcea354713bc38f95276e6f0bd893ffb5b88';
 
     describe('miss', () => {
       const apqNotFoundResponse = {
-        "errors": [
+        errors: [
           {
-            "message": "PersistedQueryNotFound",
-            "extensions": {
-              "code": "PERSISTED_QUERY_NOT_FOUND",
-              "exception": {
-                "stacktrace": ["PersistedQueryNotFoundError: PersistedQueryNotFound"]
-              }
-            }
-          }
-        ]
+            message: 'PersistedQueryNotFound',
+            extensions: {
+              code: 'PERSISTED_QUERY_NOT_FOUND',
+              exception: {
+                stacktrace: [
+                  'PersistedQueryNotFoundError: PersistedQueryNotFound',
+                ],
+              },
+            },
+          },
+        ],
       };
 
       it('stringifies a request with a query', async () => {
@@ -96,33 +105,31 @@ describe('constructing requests', () => {
         fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
         const { data } = await DataSource.process({
+          ...defaultProcessOptions,
           request: { query },
-          context: {},
         });
 
         expect(data).toEqual({ me: 'james' });
         expect(fetch).toBeCalledTimes(2);
-        expect(fetch).toHaveFetchedNth(1, {
-          url: 'https://api.example.com/foo',
+        expect(fetch).toHaveFetchedNth(1, 'https://api.example.com/foo', {
           body: {
             extensions: {
               persistedQuery: {
                 version: 1,
                 sha256Hash,
-              }
-            }
+              },
+            },
           },
         });
-        expect(fetch).toHaveFetchedNth(2, {
-          url: 'https://api.example.com/foo',
+        expect(fetch).toHaveFetchedNth(2, 'https://api.example.com/foo', {
           body: {
             query,
             extensions: {
               persistedQuery: {
                 version: 1,
                 sha256Hash,
-              }
-            }
+              },
+            },
           },
         });
       });
@@ -137,30 +144,27 @@ 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' });
         expect(fetch).toBeCalledTimes(2);
-        expect(fetch).toHaveFetchedNth(1, {
-          url: 'https://api.example.com/foo',
+        expect(fetch).toHaveFetchedNth(1, 'https://api.example.com/foo', {
           body: {
             variables: { id: '1' },
             extensions: {
               persistedQuery: {
                 version: 1,
                 sha256Hash,
-              }
-            }
+              },
+            },
           },
         });
-
-        expect(fetch).toHaveFetchedNth(2, {
-          url: 'https://api.example.com/foo',
+        expect(fetch).toHaveFetchedNth(2, 'https://api.example.com/foo', {
           body: {
             query,
             variables: { id: '1' },
@@ -168,8 +172,8 @@ describe('constructing requests', () => {
               persistedQuery: {
                 version: 1,
                 sha256Hash,
-              }
-            }
+              },
+            },
           },
         });
       });
@@ -185,21 +189,20 @@ describe('constructing requests', () => {
         fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
         const { data } = await DataSource.process({
+          ...defaultProcessOptions,
           request: { query },
-          context: {},
         });
 
         expect(data).toEqual({ me: 'james' });
         expect(fetch).toBeCalledTimes(1);
-        expect(fetch).toHaveFetched({
-          url: 'https://api.example.com/foo',
+        expect(fetch).toHaveFetched('https://api.example.com/foo', {
           body: {
             extensions: {
               persistedQuery: {
                 version: 1,
                 sha256Hash,
-              }
-            }
+              },
+            },
           },
         });
       });
@@ -213,25 +216,24 @@ 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' });
         expect(fetch).toBeCalledTimes(1);
-        expect(fetch).toHaveFetched({
-          url: 'https://api.example.com/foo',
+        expect(fetch).toHaveFetched('https://api.example.com/foo', {
           body: {
             variables: { id: '1' },
             extensions: {
               persistedQuery: {
                 version: 1,
                 sha256Hash,
-              }
-            }
+              },
+            },
           },
         });
       });
@@ -241,25 +243,46 @@ describe('constructing requests', () => {
 
 describe('fetcher', () => {
   it('uses a custom provided `fetcher`', async () => {
-    const injectedFetch = fetch.mockJSONResponseOnce({ data: { injected: true } });
+    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' },
       },
-      context: {},
     });
 
     expect(injectedFetch).toHaveBeenCalled();
-    expect(data).toEqual({injected: true});
-
+    expect(data).toEqual({ injected: true });
   });
 
+  it('supports a custom fetcher, like `make-fetch-happen`', async () => {
+    const injectedFetch = makeFetchHappenFetcher.mockJSONResponseOnce({
+      data: { me: 'james' },
+    });
+    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({ me: 'james' });
+  });
 });
 
 describe('willSendRequest', () => {
@@ -267,26 +290,25 @@ describe('willSendRequest', () => {
     const DataSource = new RemoteGraphQLDataSource({
       url: 'https://api.example.com/foo',
       willSendRequest: ({ request }) => {
-        request.variables = JSON.stringify(request.variables);
+        request.variables = { id: '2' };
       },
     });
 
     fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
     const { data } = await DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
         variables: { id: '1' },
       },
-      context: {},
     });
 
     expect(data).toEqual({ me: 'james' });
-    expect(fetch).toHaveFetched({
-      url: 'https://api.example.com/foo',
+    expect(fetch).toHaveFetched('https://api.example.com/foo', {
       body: {
         query: '{ me { name } }',
-        variables: JSON.stringify({ id: '1' }),
+        variables: { id: '2' },
       },
     });
   });
@@ -294,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' },
@@ -310,8 +338,7 @@ describe('willSendRequest', () => {
     });
 
     expect(data).toEqual({ me: 'james' });
-    expect(fetch).toHaveFetched({
-      url: 'https://api.example.com/foo',
+    expect(fetch).toHaveFetched('https://api.example.com/foo', {
       body: {
         query: '{ me { name } }',
         variables: { id: '1' },
@@ -335,10 +362,12 @@ describe('didReceiveResponse', () => {
       didReceiveResponse<MyContext>({
         request,
         response,
-      }: Required<Pick<
-        GraphQLRequestContext<MyContext>,
+      }: Required<
+        Pick<
+          GraphQLRequestContext<MyContext>,
           'request' | 'response' | 'context'
-      >>) {
+        >
+      >) {
         const surrogateKeys =
           request.http && request.http.headers.get('surrogate-keys');
         if (surrogateKeys) {
@@ -354,6 +383,7 @@ describe('didReceiveResponse', () => {
 
     const context: MyContext = { surrogateKeys: [] };
     await DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
         variables: { id: '1' },
@@ -375,30 +405,30 @@ describe('didReceiveResponse', () => {
 
       didReceiveResponse<MyContext>({
         response,
-      }: Required<Pick<
-        GraphQLRequestContext<MyContext>,
+      }: Required<
+        Pick<
+          GraphQLRequestContext<MyContext>,
           'request' | 'response' | 'context'
-      >>) {
+        >
+      >) {
         return response;
       }
     }
 
     const DataSource = new MyDataSource();
-    const spyDidReceiveResponse =
-      jest.spyOn(DataSource, 'didReceiveResponse');
+    const spyDidReceiveResponse = jest.spyOn(DataSource, 'didReceiveResponse');
 
     fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
     await DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
         variables: { id: '1' },
       },
-      context: {},
     });
 
     expect(spyDidReceiveResponse).toHaveBeenCalledTimes(1);
-
   });
 
   // APQ makes two requests, so make sure only one calls the response hook.
@@ -409,10 +439,12 @@ describe('didReceiveResponse', () => {
 
       didReceiveResponse<MyContext>({
         response,
-      }: Required<Pick<
-        GraphQLRequestContext<MyContext>,
+      }: Required<
+        Pick<
+          GraphQLRequestContext<MyContext>,
           'request' | 'response' | 'context'
-      >>) {
+        >
+      >) {
         return response;
       }
     }
@@ -423,15 +455,52 @@ describe('didReceiveResponse', () => {
     fetch.mockJSONResponseOnce({ data: { me: 'james' } });
 
     await DataSource.process({
+      ...defaultProcessOptions,
       request: {
         query: '{ me { name } }',
         variables: { id: '1' },
       },
-      context: {},
     });
 
     expect(spyDidReceiveResponse).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('didEncounterError', () => {
+  it('can accept and modify context', async () => {
+    interface MyContext {
+      timingData: { time: number }[];
+    }
+
+    class MyDataSource extends RemoteGraphQLDataSource<MyContext> {
+      url = 'https://api.example.com/foo';
 
+      didEncounterError() {
+        // a timestamp a la `Date.now()`
+        context.timingData.push({ time: 1616446845234 });
+      }
+    }
+
+    const DataSource = new MyDataSource();
+
+    fetch.mockResponseOnce('Invalid token', undefined, 401);
+
+    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 }],
+    });
   });
 });
 
@@ -444,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({
@@ -467,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({
@@ -490,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({
@@ -522,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/__tests__/tsconfig.json

@@ -1,7 +1,9 @@
 {
-  "extends": "../../../../../tsconfig.test.base",
+  "extends": "../../../tsconfig.test",
   "include": ["**/*"],
   "references": [
-    { "path": "../../../" },
+    { "path": "../../.." },
+    { "path": "../../__mocks__" },
+    { "path": "../../../../federation-integration-testsuite-js" },
   ]
 }

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: Record<string, any>;
+    }
+);