@apollo/gateway 2.0.6-rc.0 → 2.1.0-alpha.1

package/src/__tests__/integration/managed.test.ts

@@ -0,0 +1,292 @@
+import mockedEnv from 'mocked-env';
+
+import { ApolloGateway, UplinkSupergraphManager } from '@apollo/gateway';
+import { ApolloServer } from 'apollo-server';
+import { ApolloServerPluginUsageReportingDisabled } from 'apollo-server-core';
+
+import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
+import {
+  mockSupergraphSdlRequestSuccess,
+  graphRef,
+  apiKey,
+  mockSupergraphSdlRequest,
+} from '../integration/nockMocks';
+import { getTestingSupergraphSdl } from '../execution-utils';
+
+let gateway: ApolloGateway | undefined;
+let server: ApolloServer | undefined;
+let cleanUp: (() => void) | undefined;
+
+beforeEach(() => {
+  nockBeforeEach();
+});
+
+afterEach(async () => {
+  if (server) {
+    await server.stop();
+    server = undefined;
+  }
+
+  if (gateway) {
+    await gateway.stop();
+    gateway = undefined;
+  }
+
+  nockAfterEach();
+
+  if (cleanUp) {
+    cleanUp();
+    cleanUp = undefined;
+  }
+});
+
+const logger = {
+  warn: jest.fn(),
+  debug: jest.fn(),
+  error: jest.fn(),
+  info: jest.fn(),
+};
+
+describe('minimal gateway', () => {
+  it('uses managed federation', async () => {
+    cleanUp = mockedEnv({
+      APOLLO_KEY: apiKey,
+      APOLLO_GRAPH_REF: graphRef,
+    });
+    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ });
+
+    gateway = new ApolloGateway({ logger });
+    server = new ApolloServer({
+      gateway,
+      plugins: [ApolloServerPluginUsageReportingDisabled()],
+    });
+    await server.listen({ port: 0 });
+    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
+  });
+
+  it('fetches from provided `uplinkEndpoints`', async () => {
+    cleanUp = mockedEnv({
+      APOLLO_KEY: apiKey,
+      APOLLO_GRAPH_REF: graphRef,
+    });
+
+    const uplinkEndpoint = 'https://example.com';
+    mockSupergraphSdlRequestSuccess({ url: uplinkEndpoint });
+
+    gateway = new ApolloGateway({ logger, uplinkEndpoints: [uplinkEndpoint] });
+    server = new ApolloServer({
+      gateway,
+      plugins: [ApolloServerPluginUsageReportingDisabled()],
+    });
+    await server.listen({ port: 0 });
+    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
+    const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
+    expect(uplinkManager.uplinkEndpoints).toEqual([uplinkEndpoint]);
+  });
+
+  it('fetches from (deprecated) provided `schemaConfigDeliveryEndpoint`', async () => {
+    cleanUp = mockedEnv({
+      APOLLO_KEY: apiKey,
+      APOLLO_GRAPH_REF: graphRef,
+    });
+
+    const schemaConfigDeliveryEndpoint = 'https://example.com';
+    mockSupergraphSdlRequestSuccess({ url: schemaConfigDeliveryEndpoint });
+
+    gateway = new ApolloGateway({ logger, schemaConfigDeliveryEndpoint });
+    server = new ApolloServer({
+      gateway,
+      plugins: [ApolloServerPluginUsageReportingDisabled()],
+    });
+    await server.listen({ port: 0 });
+    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
+    const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
+    expect(uplinkManager.uplinkEndpoints).toEqual([
+      schemaConfigDeliveryEndpoint,
+    ]);
+  });
+});
+
+describe('Managed gateway with explicit UplinkSupergraphManager', () => {
+  it('waits for supergraph schema to load', async () => {
+    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ });
+
+    gateway = new ApolloGateway({
+      logger,
+      supergraphSdl: new UplinkSupergraphManager({
+        apiKey,
+        graphRef,
+        logger,
+      }),
+    });
+    await expect(gateway.load()).resolves.not.toThrow();
+  });
+
+  it('invokes callback if uplink throws an error during init', async () => {
+    mockSupergraphSdlRequest(null, /.*?apollographql.com/).reply(500);
+
+    const supergraphSchema = getTestingSupergraphSdl();
+    let hasFired;
+    gateway = new ApolloGateway({
+      logger,
+      supergraphSdl: new UplinkSupergraphManager({
+        apiKey,
+        graphRef,
+        logger,
+        maxRetries: 0,
+        async onFailureToFetchSupergraphSdlDuringInit() {
+          hasFired = true;
+          return supergraphSchema;
+        },
+      }),
+    });
+
+    await expect(gateway.load()).resolves.not.toThrow();
+    expect(gateway.__testing().supergraphSdl).toBe(supergraphSchema);
+    expect(hasFired).toBeTruthy();
+  });
+
+  it('invokes callback if uplink throws an error after init', async () => {
+    // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
+    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
+      .post('/')
+      .reply(500);
+
+    const supergraphSchema = getTestingSupergraphSdl();
+    let hasFired;
+    let uplinkManager = new UplinkSupergraphManager({
+      apiKey,
+      graphRef,
+      logger,
+      maxRetries: 0,
+      async onFailureToFetchSupergraphSdlAfterInit() {
+        hasFired = true;
+        return supergraphSchema;
+      },
+    });
+    // Set pollIntervalMs lower than the typically allowed value so we don't wait 10s between polling
+    uplinkManager['pollIntervalMs'] = 0;
+
+    gateway = new ApolloGateway({
+      logger,
+      supergraphSdl: uplinkManager,
+    });
+
+    await expect(gateway.load()).resolves.not.toThrow();
+    expect(hasFired).toBeFalsy();
+
+    await uplinkManager.nextFetch();
+
+    expect(hasFired).toBeTruthy();
+  });
+
+  it.each([
+    ['x', 'Syntax Error: Unexpected Name "x".'],
+    ['', 'Invalid supergraph schema supplied during initialization.'],
+    [' ', 'Syntax Error: Unexpected <EOF>.'],
+    ['type Query {hi: String}', 'Invalid supergraph: must be a core schema'],
+  ])(
+    'throws if invalid supergraph schema returned from callback during init: %p',
+    async (schemaText, expectedMessage) => {
+      mockSupergraphSdlRequest(null, /.*?apollographql.com/).reply(500);
+
+      gateway = new ApolloGateway({
+        logger,
+        supergraphSdl: new UplinkSupergraphManager({
+          apiKey,
+          graphRef,
+          logger,
+          maxRetries: 0,
+          async onFailureToFetchSupergraphSdlDuringInit() {
+            return schemaText;
+          },
+        }),
+      });
+
+      await expect(gateway.load()).rejects.toThrowError(expectedMessage);
+    },
+  );
+
+  it.each([
+    ['x', 'Syntax Error: Unexpected Name "x".'],
+    [' ', 'Syntax Error: Unexpected <EOF>.'],
+    ['type Query {hi: String}', 'Invalid supergraph: must be a core schema'],
+  ])(
+    'throws if invalid supergraph schema returned from callback after init: %p',
+    async (schemaText, expectedMessage) => {
+      // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
+      mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
+        .post('/')
+        .reply(500);
+
+      let hasFired;
+      let uplinkManager = new UplinkSupergraphManager({
+        apiKey,
+        graphRef,
+        logger,
+        maxRetries: 0,
+        async onFailureToFetchSupergraphSdlAfterInit() {
+          hasFired = true;
+          return schemaText;
+        },
+      });
+      // Set pollIntervalMs lower than the typically allowed value so we don't wait 10s between polling
+      uplinkManager['pollIntervalMs'] = 0;
+
+      gateway = new ApolloGateway({
+        logger,
+        supergraphSdl: uplinkManager
+      });
+
+      await expect(gateway.load()).resolves.not.toThrow();
+      expect(hasFired).toBeFalsy();
+
+      await uplinkManager.nextFetch();
+
+      expect(hasFired).toBeTruthy();
+      expect(logger.error).toBeCalledWith(
+        `UplinkSupergraphManager failed to update supergraph with the following error: ${expectedMessage}`,
+      );
+    },
+  );
+
+  it.each([null, ''])(
+    'uses existing supergraph schema if false-y value returned from callback after init: %p',
+    async (schemaText) => {
+      // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
+      mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
+        .post('/')
+        .reply(500);
+
+      let hasFired;
+      let uplinkManager = new UplinkSupergraphManager({
+        apiKey,
+        graphRef,
+        logger,
+        maxRetries: 0,
+
+        async onFailureToFetchSupergraphSdlAfterInit() {
+          hasFired = true;
+          return schemaText;
+        },
+      });
+      // Set pollIntervalMs lower than the typically allowed value so we don't wait 10s between polling
+      uplinkManager['pollIntervalMs'] = 0;
+
+      gateway = new ApolloGateway({
+        logger,
+        supergraphSdl: uplinkManager,
+      });
+
+      await expect(gateway.load()).resolves.not.toThrow();
+      expect(hasFired).toBeFalsy();
+
+      await uplinkManager.nextFetch();
+
+      expect(hasFired).toBeTruthy();
+
+      const supergraphSchema = getTestingSupergraphSdl();
+      expect(gateway.__testing().supergraphSdl).toBe(supergraphSchema);
+    },
+  );
+});

package/src/__tests__/integration/networkRequests.test.ts

@@ -2,7 +2,7 @@ import gql from 'graphql-tag';
 import { GraphQLObjectType, GraphQLSchema } from 'graphql';
 import mockedEnv from 'mocked-env';
 import type { Logger } from '@apollo/utils.logger';
-import { ApolloGateway } from '../..';
+import { ApolloGateway, UplinkSupergraphManager } from '../..';
 import {
   mockSdlQuerySuccess,
   mockServiceHealthCheckSuccess,
@@ -56,8 +56,12 @@ function getRootQueryFields(schema?: GraphQLSchema): string[] {
 let logger: Logger;
 let gateway: ApolloGateway | null = null;
 let cleanUp: (() => void) | null = null;
+let originalMinPollInterval = UplinkSupergraphManager.MIN_POLL_INTERVAL_MS;
 
 beforeEach(() => {
+  // Set the min poll interval artificially low so we're not waiting during tests
+  // @ts-ignore
+  UplinkSupergraphManager['MIN_POLL_INTERVAL_MS'] = 100;
   nockBeforeEach();
 
   const warn = jest.fn();
@@ -74,13 +78,15 @@ beforeEach(() => {
 });
 
 afterEach(async () => {
-  nockAfterEach();
-
+  // @ts-ignore
+  UplinkSupergraphManager['MIN_POLL_INTERVAL_MS'] = originalMinPollInterval;
   if (gateway) {
     await gateway.stop();
     gateway = null;
   }
 
+  nockAfterEach();
+
   if (cleanUp) {
     cleanUp();
     cleanUp = null;
@@ -90,7 +96,7 @@ afterEach(async () => {
 it('Queries remote endpoints for their SDLs', async () => {
   mockSdlQuerySuccess(simpleService);
 
-  gateway = new ApolloGateway({ serviceList: [simpleService] });
+  gateway = new ApolloGateway({ serviceList: [simpleService], logger });
   await gateway.load();
   expect(gateway.schema!.getType('User')!.description).toBe('This is my User');
 });
@@ -139,8 +145,6 @@ it('Updates Supergraph SDL from remote storage', async () => {
     logger,
     uplinkEndpoints: [mockCloudConfigUrl1],
   });
-  // for testing purposes, a short pollInterval is ideal so we'll override here
-  gateway['pollIntervalInMs'] = 100;
 
   const schemas: GraphQLSchema[] = [];
   gateway.onSchemaLoadOrUpdate(({ apiSchema }) => {
@@ -183,13 +187,6 @@ describe('Supergraph SDL update failures', () => {
     ).rejects.toThrowErrorMatchingInlineSnapshot(
       `"An error occurred while fetching your schema from Apollo: 401 Unauthorized"`,
     );
-
-    await expect(gateway.stop()).rejects.toThrowErrorMatchingInlineSnapshot(
-      `"ApolloGateway.stop does not need to be called before ApolloGateway.load is called successfully"`,
-    );
-    // Set to `null` so we don't try to call `stop` on it in the `afterEach`,
-    // which triggers a different error that we're not testing for here.
-    gateway = null;
   });
 
   it('Handles arbitrary fetch failures (non 200 response)', async () => {
@@ -206,14 +203,11 @@ describe('Supergraph SDL update failures', () => {
       uplinkMaxRetries: 0,
     });
 
-    // for testing purposes, a short pollInterval is ideal so we'll override here
-    gateway['pollIntervalInMs'] = 100;
-
     await gateway.load(mockApolloConfig);
     await errorLoggedPromise;
 
     expect(logger.error).toHaveBeenCalledWith(
-      'UplinkFetcher failed to update supergraph with the following error: An error occurred while fetching your schema from Apollo: 500 Internal Server Error',
+      'UplinkSupergraphManager failed to update supergraph with the following error: An error occurred while fetching your schema from Apollo: 500 Internal Server Error',
     );
   });
 
@@ -238,14 +232,12 @@ describe('Supergraph SDL update failures', () => {
       uplinkEndpoints: [mockCloudConfigUrl1],
       uplinkMaxRetries: 0,
     });
-    // for testing purposes, a short pollInterval is ideal so we'll override here
-    gateway['pollIntervalInMs'] = 100;
 
     await gateway.load(mockApolloConfig);
     await errorLoggedPromise;
 
     expect(logger.error).toHaveBeenCalledWith(
-      `UplinkFetcher failed to update supergraph with the following error: An error occurred while fetching your schema from Apollo: \nCannot query field "fail" on type "Query".`,
+      `UplinkSupergraphManager failed to update supergraph with the following error: An error occurred while fetching your schema from Apollo: \nCannot query field "fail" on type "Query".`,
     );
   });
 
@@ -272,14 +264,12 @@ describe('Supergraph SDL update failures', () => {
       logger,
       uplinkEndpoints: [mockCloudConfigUrl1],
     });
-    // for testing purposes, a short pollInterval is ideal so we'll override here
-    gateway['pollIntervalInMs'] = 100;
 
     await gateway.load(mockApolloConfig);
     await errorLoggedPromise;
 
     expect(logger.error).toHaveBeenCalledWith(
-      'UplinkFetcher failed to update supergraph with the following error: Syntax Error: Unexpected Name "Syntax".',
+      'UplinkSupergraphManager failed to update supergraph with the following error: Syntax Error: Unexpected Name "Syntax".',
     );
     expect(gateway.schema).toBeTruthy();
   });
@@ -302,8 +292,6 @@ describe('Supergraph SDL update failures', () => {
       logger,
       uplinkEndpoints: [mockCloudConfigUrl1],
     });
-    // for testing purposes, a short pollInterval is ideal so we'll override here
-    gateway['pollIntervalInMs'] = 100;
 
     await expect(
       gateway.load(mockApolloConfig),
@@ -312,10 +300,6 @@ describe('Supergraph SDL update failures', () => {
     );
 
     expect(gateway['state'].phase).toEqual('failed to load');
-
-    // Set to `null` so we don't try to call `stop` on it in the `afterEach`,
-    // which triggers a different error that we're not testing for here.
-    gateway = null;
   });
 });
 
@@ -343,8 +327,6 @@ it('Rollsback to a previous schema when triggered', async () => {
     logger,
     uplinkEndpoints: [mockCloudConfigUrl1],
   });
-  // for testing purposes, a short pollInterval is ideal so we'll override here
-  gateway['pollIntervalInMs'] = 100;
 
   gateway.onSchemaChange(onChange);
   await gateway.load(mockApolloConfig);
@@ -406,14 +388,6 @@ describe('Downstream service health checks', () => {
         "The gateway subgraphs health check failed. Updating to the provided \`supergraphSdl\` will likely result in future request failures to subgraphs. The following error occurred during the health check:
         [accounts]: 500: Internal Server Error"
       `);
-
-      await expect(gateway.stop()).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"ApolloGateway.stop does not need to be called before ApolloGateway.load is called successfully"`,
-      );
-
-      // Set to `null` so we don't try to call `stop` on it in the `afterEach`,
-      // which triggers a different error that we're not testing for here.
-      gateway = null;
     });
   });
 
@@ -427,8 +401,6 @@ describe('Downstream service health checks', () => {
         logger,
         uplinkEndpoints: [mockCloudConfigUrl1],
       });
-      // for testing purposes, a short pollInterval is ideal so we'll override here
-      gateway['pollIntervalInMs'] = 100;
 
       await gateway.load(mockApolloConfig);
       await gateway.stop();
@@ -471,14 +443,6 @@ describe('Downstream service health checks', () => {
         "The gateway subgraphs health check failed. Updating to the provided \`supergraphSdl\` will likely result in future request failures to subgraphs. The following error occurred during the health check:
         [accounts]: 500: Internal Server Error"
       `);
-
-      await expect(gateway.stop()).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"ApolloGateway.stop does not need to be called before ApolloGateway.load is called successfully"`,
-      );
-
-      // Set to `null` so we don't try to call `stop` on it in the `afterEach`,
-      // which triggers a different error that we're not testing for here.
-      gateway = null;
     });
 
     // This test has been flaky for a long time, and fails consistently after changes
@@ -509,8 +473,6 @@ describe('Downstream service health checks', () => {
         logger,
         uplinkEndpoints: [mockCloudConfigUrl1],
       });
-      // for testing purposes, a short pollInterval is ideal so we'll override here
-      gateway['pollIntervalInMs'] = 100;
 
       gateway.onSchemaChange(onChange);
       await gateway.load(mockApolloConfig);
@@ -553,8 +515,6 @@ describe('Downstream service health checks', () => {
         logger,
         uplinkEndpoints: [mockCloudConfigUrl1],
       });
-      // for testing purposes, a short pollInterval is ideal so we'll override here
-      gateway['pollIntervalInMs'] = 100;
 
       const updateSpy = jest.fn();
       gateway.onSchemaLoadOrUpdate(() => updateSpy());
@@ -568,7 +528,7 @@ describe('Downstream service health checks', () => {
 
       await errorLoggedPromise;
       expect(logger.error).toHaveBeenCalledWith(
-        `UplinkFetcher failed to update supergraph with the following error: The gateway subgraphs health check failed. Updating to the provided \`supergraphSdl\` will likely result in future request failures to subgraphs. The following error occurred during the health check:\n[accounts]: 500: Internal Server Error`,
+        `UplinkSupergraphManager failed to update supergraph with the following error: The gateway subgraphs health check failed. Updating to the provided \`supergraphSdl\` will likely result in future request failures to subgraphs. The following error occurred during the health check:\n[accounts]: 500: Internal Server Error`,
       );
 
       // At this point, the mock update should have been called but the schema

package/src/__tests__/integration/nockMocks.ts

@@ -1,6 +1,6 @@
 import nock from 'nock';
 import { HEALTH_CHECK_QUERY, SERVICE_DEFINITION_QUERY } from '../..';
-import { SUPERGRAPH_SDL_QUERY } from '../../supergraphManagers/UplinkFetcher/loadSupergraphSdlFromStorage';
+import { SUPERGRAPH_SDL_QUERY } from '../../supergraphManagers/UplinkSupergraphManager/loadSupergraphSdlFromStorage';
 import { getTestingSupergraphSdl } from '../../__tests__/execution-utils';
 import { print } from 'graphql';
 import { Fixture, fixtures as testingFixtures } from 'apollo-federation-integration-testsuite';
@@ -83,7 +83,7 @@ export const mockCloudConfigUrl3 =
 export const mockOutOfBandReporterUrl =
   'https://example.outofbandreporter.com/monitoring/';
 
-export function mockSupergraphSdlRequestIfAfter(ifAfter: string | null, url: string = mockCloudConfigUrl1) {
+export function mockSupergraphSdlRequestIfAfter(ifAfter: string | null, url: string | RegExp = mockCloudConfigUrl1) {
   return gatewayNock(url).post('/', {
     query: SUPERGRAPH_SDL_QUERY,
     variables: {
@@ -94,7 +94,7 @@ export function mockSupergraphSdlRequestIfAfter(ifAfter: string | null, url: str
   });
 }
 
-export function mockSupergraphSdlRequest(ifAfter: string | null = null, url: string = mockCloudConfigUrl1) {
+export function mockSupergraphSdlRequest(ifAfter: string | null = null, url: string | RegExp = mockCloudConfigUrl1) {
   return mockSupergraphSdlRequestIfAfter(ifAfter, url);
 }
 
@@ -102,11 +102,12 @@ export function mockSupergraphSdlRequestSuccessIfAfter(
   ifAfter: string | null = null,
   id: string = 'originalId-1234',
   supergraphSdl: string = getTestingSupergraphSdl(),
+  url: string | RegExp = mockCloudConfigUrl1,
 ) {
   if (supergraphSdl == null) {
     supergraphSdl = getTestingSupergraphSdl();
   }
-  return mockSupergraphSdlRequestIfAfter(ifAfter).reply(
+  return mockSupergraphSdlRequestIfAfter(ifAfter, url).reply(
     200,
     JSON.stringify({
       data: {
@@ -136,8 +137,8 @@ export function mockSupergraphSdlRequestIfAfterUnchanged(
   );
 }
 
-export function mockSupergraphSdlRequestSuccess() {
-  return mockSupergraphSdlRequestSuccessIfAfter(null);
+export function mockSupergraphSdlRequestSuccess({supergraphSdl = getTestingSupergraphSdl(), url = mockCloudConfigUrl1}: {supergraphSdl?: string, url?: string | RegExp} = {}) {
+  return mockSupergraphSdlRequestSuccessIfAfter(null, undefined, supergraphSdl, url);
 }
 
 export function mockOutOfBandReportRequest() {

package/src/config.ts

@@ -1,5 +1,5 @@
 import { GraphQLError, GraphQLSchema } from 'graphql';
-import { HeadersInit } from 'node-fetch';
+import type { HeadersInit } from 'node-fetch';
 import { GraphQLRequestContextExecutionDidStart } from 'apollo-server-types';
 import type { Logger } from '@apollo/utils.logger';
 import { GraphQLDataSource } from './datasources/types';
@@ -8,6 +8,7 @@ import { OperationContext } from './operationContext';
 import { ServiceMap } from './executeQueryPlan';
 import { ServiceDefinition } from "@apollo/federation-internals";
 import { Fetcher } from '@apollo/utils.fetcher';
+import { UplinkSupergraphManager } from './supergraphManagers';
 
 export type ServiceEndpointDefinition = Pick<ServiceDefinition, 'name' | 'url'>;
 
@@ -325,6 +326,7 @@ export function isManagedConfig(
     'schemaConfigDeliveryEndpoint' in config ||
     'uplinkEndpoints' in config ||
     'fallbackPollIntervalInMs' in config ||
+    (isSupergraphManagerConfig(config) && config.supergraphSdl instanceof UplinkSupergraphManager) ||
     (!isLocalConfig(config) &&
       !isStaticSupergraphSdlConfig(config) &&
       !isManuallyManagedConfig(config))

package/src/datasources/RemoteGraphQLDataSource.ts

@@ -118,8 +118,7 @@ export class RemoteGraphQLDataSource<
     // there.
     const overallCachePolicy =
       this.honorSubgraphCacheControlHeader &&
-      options.kind === GraphQLDataSourceRequestKind.INCOMING_OPERATION &&
-      options.incomingRequestContext.overallCachePolicy?.restrict
+      options.kind === GraphQLDataSourceRequestKind.INCOMING_OPERATION
         ? options.incomingRequestContext.overallCachePolicy
         : null;
 

package/src/datasources/types.ts

@@ -39,6 +39,10 @@ export type GraphQLDataSourceProcessOptions<
        * checking `kind`).
        */
       context: GraphQLRequestContext<TContext>['context'];
+      /**
+       * The document representation of the request's query being sent to the subgraph, if available.
+       */
+      document?: GraphQLRequestContext<TContext>['document'];
     }
   | {
       kind: