@apollo/gateway 2.1.0-alpha.0 → 2.1.0-alpha.3

package/src/index.ts

@@ -1,12 +1,7 @@
 import { deprecate } from 'util';
-import { GraphQLService, Unsubscriber } from 'apollo-server-core';
-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 LRUCache from 'lru-cache';
 import {
   isObjectType,
   isIntrospectionType,
@@ -63,6 +58,7 @@ import {
   ServiceDefinition,
 } from '@apollo/federation-internals';
 import { getDefaultLogger } from './logger';
+import {GatewayInterface, GatewayUnsubscriber, GatewayGraphQLRequestContext, GatewayExecutionResult} from '@apollo/server-gateway-interface';
 
 type DataSourceMap = {
   [serviceName: string]: { url?: string; dataSource: GraphQLDataSource };
@@ -118,7 +114,7 @@ interface GraphQLServiceEngineConfig {
   graphVariant?: string;
 }
 
-export class ApolloGateway implements GraphQLService {
+export class ApolloGateway implements GatewayInterface {
   public schema?: GraphQLSchema;
   // Same as a `schema` but as a `Schema` to avoid reconverting when we need it.
   // TODO(sylvain): if we add caching in `Schema.toGraphQLJSSchema`, we could maybe only keep `apiSchema`
@@ -130,7 +126,7 @@ export class ApolloGateway implements GraphQLService {
   private serviceMap: DataSourceMap = Object.create(null);
   private config: GatewayConfig;
   private logger: Logger;
-  private queryPlanStore: InMemoryLRUCache<QueryPlan>;
+  private queryPlanStore: LRUCache<string, QueryPlan>;
   private apolloConfig?: ApolloConfigFromAS3;
   private onSchemaChangeListeners = new Set<(schema: GraphQLSchema) => void>();
   private onSchemaLoadOrUpdateListeners = new Set<
@@ -142,6 +138,7 @@ export class ApolloGateway implements GraphQLService {
   private warnedStates: WarnedStates = Object.create(null);
   private queryPlanner?: QueryPlanner;
   private supergraphSdl?: string;
+  private supergraphSchema?: GraphQLSchema;
   private compositionId?: string;
   private state: GatewayState;
   private _supergraphManager?: SupergraphManager;
@@ -195,34 +192,18 @@ export class ApolloGateway implements GraphQLService {
   }
 
   private initQueryPlanStore(approximateQueryPlanStoreMiB?: number) {
-    return new InMemoryLRUCache<QueryPlan>({
+    return new LRUCache<string, QueryPlan>({
       // Create ~about~ a 30MiB InMemoryLRUCache.  This is less than precise
       // since the technique to calculate the size of a DocumentNode is
       // only using JSON.stringify on the DocumentNode (and thus doesn't account
       // for unicode characters, etc.), but it should do a reasonable job at
       // providing a caching document store for most operations.
       maxSize: Math.pow(2, 20) * (approximateQueryPlanStoreMiB || 30),
-      sizeCalculator: approximateObjectSize,
+      sizeCalculation: approximateObjectSize,
     });
   }
 
   private issueConfigurationWarningsIfApplicable() {
-    // Warn against a pollInterval of < 10s in managed mode and reset it to 10s
-    if (
-      isManagedConfig(this.config) &&
-      this.pollIntervalInMs &&
-      this.pollIntervalInMs < 10000
-    ) {
-      this.pollIntervalInMs = 10000;
-      this.logger.warn(
-        'Polling Apollo services at a frequency of less than once per 10 ' +
-          'seconds (10000) is disallowed. Instead, the minimum allowed ' +
-          'pollInterval of 10000 will be used. Please reconfigure your ' +
-          '`fallbackPollIntervalInMs` accordingly. If this is problematic for ' +
-          'your team, please contact support.',
-      );
-    }
-
     // Warn against using the pollInterval and a serviceList simultaneously
     // TODO(trevor:removeServiceList)
     if (this.pollIntervalInMs && isServiceListConfig(this.config)) {
@@ -375,6 +356,7 @@ export class ApolloGateway implements GraphQLService {
           uplinkEndpoints:
             this.config.uplinkEndpoints ?? schemaDeliveryEndpoints,
           maxRetries: this.config.uplinkMaxRetries,
+          fetcher: this.config.fetcher,
           logger: this.logger,
           fallbackPollIntervalInMs: this.pollIntervalInMs,
         }),
@@ -522,7 +504,7 @@ export class ApolloGateway implements GraphQLService {
     // In the case that it throws, the gateway will:
     //   * on initial load, throw the error
     //   * on update, log the error and don't update
-    const { schema, supergraphSdl } = this.createSchemaFromSupergraphSdl(
+    const { supergraphSchema, supergraphSdl } = this.createSchemaFromSupergraphSdl(
       result.supergraphSdl,
     );
 
@@ -531,25 +513,26 @@ export class ApolloGateway implements GraphQLService {
     const previousCompositionId = this.compositionId;
 
     if (previousSchema) {
-      this.logger.info('Updated Supergraph SDL was found.');
+      this.logger.info(`Updated Supergraph SDL was found [Composition ID ${this.compositionId} => ${result.id}]`);
     }
 
     this.compositionId = result.id;
     this.supergraphSdl = supergraphSdl;
+    this.supergraphSchema = supergraphSchema.toGraphQLJSSchema();
 
     if (!supergraphSdl) {
       this.logger.error(
         "A valid schema couldn't be composed. Falling back to previous schema.",
       );
     } else {
-      this.updateWithSchemaAndNotify(schema, supergraphSdl);
+      this.updateWithSchemaAndNotify(supergraphSchema, supergraphSdl);
 
       if (this.experimental_didUpdateSupergraph) {
         this.experimental_didUpdateSupergraph(
           {
             compositionId: result.id,
             supergraphSdl,
-            schema: schema.toGraphQLJSSchema(),
+            schema: this.schema!,
           },
           previousCompositionId && previousSupergraphSdl && previousSchema
             ? {
@@ -572,12 +555,12 @@ export class ApolloGateway implements GraphQLService {
     // Once we remove the deprecated onSchemaChange() method, we can remove this.
     legacyDontNotifyOnSchemaChangeListeners: boolean = false,
   ): void {
-    if (this.queryPlanStore) this.queryPlanStore.flush();
+    this.queryPlanStore.clear();
     this.apiSchema = coreSchema.toAPISchema();
     this.schema = addExtensions(
       wrapSchemaWithAliasResolver(this.apiSchema.toGraphQLJSSchema()),
     );
-    this.queryPlanner = new QueryPlanner(coreSchema);
+    this.queryPlanner = new QueryPlanner(coreSchema, this.config.queryPlannerConfig);
 
     // Notify onSchemaChange listeners of the updated schema
     if (!legacyDontNotifyOnSchemaChangeListeners) {
@@ -654,7 +637,7 @@ export class ApolloGateway implements GraphQLService {
     this.createServices(serviceList);
 
     return {
-      schema,
+      supergraphSchema: schema,
       supergraphSdl,
     };
   }
@@ -664,7 +647,7 @@ export class ApolloGateway implements GraphQLService {
    */
   public onSchemaChange(
     callback: (schema: GraphQLSchema) => void,
-  ): Unsubscriber {
+  ): GatewayUnsubscriber {
     this.onSchemaChangeListeners.add(callback);
 
     return () => {
@@ -677,7 +660,7 @@ export class ApolloGateway implements GraphQLService {
       apiSchema: GraphQLSchema;
       coreSupergraphSdl: string;
     }) => void,
-  ): Unsubscriber {
+  ): GatewayUnsubscriber {
     this.onSchemaLoadOrUpdateListeners.add(callback);
 
     return () => {
@@ -757,9 +740,9 @@ export class ApolloGateway implements GraphQLService {
   // ApolloServerPluginUsageReporting) assumes that. In fact, errors talking to backends
   // are unlikely to show up as GraphQLErrors. Do we need to use
   // formatApolloErrors or something?
-  public executor = async <TContext>(
-    requestContext: GraphQLRequestContextExecutionDidStart<TContext>,
-  ): Promise<GraphQLExecutionResult> => {
+  public executor = async (
+    requestContext: GatewayGraphQLRequestContext,
+  ): Promise<GatewayExecutionResult> => {
     const spanAttributes = requestContext.operationName
       ? { operationName: requestContext.operationName }
       : {};
@@ -788,10 +771,7 @@ export class ApolloGateway implements GraphQLService {
             span.setStatus({ code: SpanStatusCode.ERROR });
             return { errors: validationErrors };
           }
-          let queryPlan: QueryPlan | undefined;
-          if (this.queryPlanStore) {
-            queryPlan = await this.queryPlanStore.get(queryPlanStoreKey);
-          }
+          let queryPlan = this.queryPlanStore.get(queryPlanStoreKey);
 
           if (!queryPlan) {
             queryPlan = tracer.startActiveSpan(
@@ -814,25 +794,11 @@ export class ApolloGateway implements GraphQLService {
               },
             );
 
-            if (this.queryPlanStore) {
-              // The underlying cache store behind the `documentStore` returns a
-              // `Promise` which is resolved (or rejected), eventually, based on the
-              // success or failure (respectively) of the cache save attempt.  While
-              // it's certainly possible to `await` this `Promise`, we don't care about
-              // whether or not it's successful at this point.  We'll instead proceed
-              // to serve the rest of the request and just hope that this works out.
-              // If it doesn't work, the next request will have another opportunity to
-              // try again.  Errors will surface as warnings, as appropriate.
-              //
-              // While it shouldn't normally be necessary to wrap this `Promise` in a
-              // `Promise.resolve` invocation, it seems that the underlying cache store
-              // is returning a non-native `Promise` (e.g. Bluebird, etc.).
-              Promise.resolve(
-                this.queryPlanStore.set(queryPlanStoreKey, queryPlan),
-              ).catch((err) =>
-                this.logger.warn(
-                  'Could not store queryPlan' + ((err && err.message) || err),
-                ),
+            try {
+              this.queryPlanStore.set(queryPlanStoreKey, queryPlan);
+            } catch (err) {
+              this.logger.warn(
+                'Could not store queryPlan' + ((err && err.message) || err),
               );
             }
           }
@@ -854,11 +820,12 @@ export class ApolloGateway implements GraphQLService {
             });
           }
 
-          const response = await executeQueryPlan<TContext>(
+          const response = await executeQueryPlan(
             queryPlan,
             serviceMap,
             requestContext,
             operationContext,
+            this.supergraphSchema!,
           );
 
           const shouldShowQueryPlan =
@@ -911,8 +878,8 @@ export class ApolloGateway implements GraphQLService {
     );
   };
 
-  private validateIncomingRequest<TContext>(
-    requestContext: GraphQLRequestContextExecutionDidStart<TContext>,
+  private validateIncomingRequest(
+    requestContext: GatewayGraphQLRequestContext,
     operationContext: OperationContext,
   ) {
     return tracer.startActiveSpan(OpenTelemetrySpanNames.VALIDATE, (span) => {
@@ -1076,5 +1043,4 @@ export {
   FailureToFetchSupergraphSdlAfterInit,
   FailureToFetchSupergraphSdlDuringInit,
   FailureToFetchSupergraphSdlFunctionParams,
-  DEFAULT_UPLINK_ENDPOINTS,
 } from './supergraphManagers';

package/src/logger.ts

@@ -1,7 +1,7 @@
 import loglevel from 'loglevel';
 import type { Logger } from '@apollo/utils.logger';
 
-export function getDefaultLogger(debug: boolean = true): Logger {
+export function getDefaultLogger(debug: boolean = false): Logger {
   const logger = loglevel.getLogger('apollo-gateway');
 
   const level = debug === true ? loglevel.levels.DEBUG : loglevel.levels.WARN;

package/src/operationContext.ts

@@ -1,7 +1,7 @@
+import { ERRORS } from '@apollo/federation-internals';
 import {
   DocumentNode,
   FragmentDefinitionNode,
-  GraphQLError,
   GraphQLSchema,
   Kind,
   OperationDefinitionNode,
@@ -37,7 +37,7 @@ export function buildOperationContext({
       case Kind.OPERATION_DEFINITION:
         operationCount++;
         if (!operationName && operationCount > 1) {
-          throw new GraphQLError(
+          throw ERRORS.INVALID_GRAPHQL.err(
             'Must provide operation name if query contains ' +
               'multiple operations.',
           );
@@ -55,11 +55,9 @@ export function buildOperationContext({
     }
   });
   if (!operation) {
-    if (operationName) {
-      throw new GraphQLError(`Unknown operation named "${operationName}".`);
-    } else {
-      throw new GraphQLError('Must provide an operation.');
-    }
+    throw ERRORS.INVALID_GRAPHQL.err(
+      operationName ? `Unknown operation named "${operationName}".` : 'Must provide an operation.'
+    );
   }
 
   return {

package/src/supergraphManagers/IntrospectAndCompose/index.ts

@@ -1,5 +1,5 @@
 import type { Logger } from '@apollo/utils.logger';
-import { HeadersInit } from 'node-fetch';
+import type { HeadersInit } from 'node-fetch';
 import resolvable from '@josephg/resolvable';
 import {
   ServiceEndpointDefinition,

package/src/supergraphManagers/IntrospectAndCompose/loadServicesFromRemoteEndpoint.ts

@@ -1,10 +1,10 @@
-import { GraphQLRequest } from 'apollo-server-types';
 import { parse } from 'graphql';
-import { Headers, HeadersInit } from 'node-fetch';
+import { Headers, type HeadersInit } from 'node-fetch';
 import { ServiceDefinition } from '@apollo/federation-internals';
 import { GraphQLDataSource, GraphQLDataSourceRequestKind } from '../../datasources/types';
 import { SERVICE_DEFINITION_QUERY } from '../..';
 import { ServiceDefinitionUpdate, ServiceEndpointDefinition } from '../../config';
+import { GatewayGraphQLRequest } from '@apollo/server-gateway-interface';
 
 export type Service = ServiceEndpointDefinition & {
   dataSource: GraphQLDataSource;
@@ -35,7 +35,7 @@ export async function loadServicesFromRemoteEndpoint({
         `Tried to load schema for '${name}' but no 'url' was specified.`);
     }
 
-    const request: GraphQLRequest = {
+    const request: GatewayGraphQLRequest = {
       query: SERVICE_DEFINITION_QUERY,
       http: {
         url,

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

@@ -2,8 +2,6 @@ import mockedEnv from 'mocked-env';
 
 import { UplinkSupergraphManager } from '@apollo/gateway';
 
-import { DEFAULT_UPLINK_ENDPOINTS } from '..';
-
 let cleanUp: (() => void) | undefined;
 
 const logger = {
@@ -31,7 +29,7 @@ describe('UplinkSupergraphManager', () => {
     it('uses default uplink URLs', async () => {
       const manager = new UplinkSupergraphManager({ apiKey, graphRef, logger });
 
-      expect(manager.uplinkEndpoints).toEqual(DEFAULT_UPLINK_ENDPOINTS);
+      expect(manager.uplinkEndpoints).toEqual(UplinkSupergraphManager.DEFAULT_UPLINK_ENDPOINTS);
     });
 
     it('can set uplink URLs via config', async () => {

package/src/supergraphManagers/UplinkSupergraphManager/__tests__/loadSupergraphSdlFromStorage.test.ts

@@ -22,6 +22,15 @@ import {
   nockBeforeEach,
 } from '../../../__tests__/nockAssertions';
 
+const logger = {
+  warn: jest.fn(),
+  debug: jest.fn(),
+  error: jest.fn(),
+  info: jest.fn(),
+};
+
+const requestTimeoutMs = 100;
+
 describe('loadSupergraphSdlFromStorage', () => {
   beforeEach(nockBeforeEach);
   afterEach(nockAfterEach);
@@ -34,7 +43,9 @@ describe('loadSupergraphSdlFromStorage', () => {
       endpoint: mockCloudConfigUrl1,
       errorReportingEndpoint: undefined,
       fetcher,
+      requestTimeoutMs,
       compositionId: null,
+      logger,
     });
     expect(result).toMatchObject({
       id: 'originalId-1234',
@@ -66,10 +77,11 @@ describe('loadSupergraphSdlFromStorage', () => {
       endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
       errorReportingEndpoint: undefined,
       fetcher,
+      requestTimeoutMs,
       compositionId: 'originalId-1234',
       maxRetries: 1,
       roundRobinSeed: 0,
-      earliestFetchTime: null,
+      logger,
     });
 
     expect(result).toMatchObject({
@@ -92,10 +104,11 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
         errorReportingEndpoint: undefined,
         fetcher,
+        requestTimeoutMs,
         compositionId: 'originalId-1234',
         maxRetries: 1,
         roundRobinSeed: 0,
-        earliestFetchTime: null,
+        logger,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
@@ -115,7 +128,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -140,7 +155,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -160,7 +177,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -181,7 +200,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -200,7 +221,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -220,7 +243,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -240,7 +265,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -260,7 +287,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           endpoint: mockCloudConfigUrl1,
           errorReportingEndpoint: mockOutOfBandReporterUrl,
           fetcher,
+          requestTimeoutMs,
           compositionId: null,
+          logger,
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
@@ -281,7 +310,9 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoint: mockCloudConfigUrl1,
         errorReportingEndpoint: mockOutOfBandReporterUrl,
         fetcher,
+        requestTimeoutMs,
         compositionId: null,
+        logger,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
@@ -301,7 +332,9 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoint: mockCloudConfigUrl1,
         errorReportingEndpoint: mockOutOfBandReporterUrl,
         fetcher,
+        requestTimeoutMs,
         compositionId: null,
+        logger,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
@@ -321,7 +354,9 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoint: mockCloudConfigUrl1,
         errorReportingEndpoint: mockOutOfBandReporterUrl,
         fetcher,
+        requestTimeoutMs,
         compositionId: null,
+        logger,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
@@ -341,7 +376,9 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoint: mockCloudConfigUrl1,
         errorReportingEndpoint: mockOutOfBandReporterUrl,
         fetcher,
+        requestTimeoutMs,
         compositionId: null,
+        logger,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
@@ -359,7 +396,9 @@ describe('loadSupergraphSdlFromStorage', () => {
       endpoint: mockCloudConfigUrl1,
       errorReportingEndpoint: mockOutOfBandReporterUrl,
       fetcher,
+      requestTimeoutMs,
       compositionId: 'id-1234',
+      logger,
     });
     expect(result).toBeNull();
   });
@@ -382,20 +421,20 @@ describe('loadSupergraphSdlFromUplinks', () => {
         calls++;
         return fetcher(...args);
       },
+      requestTimeoutMs,
       compositionId: 'id-1234',
       maxRetries: 5,
       roundRobinSeed: 0,
-      earliestFetchTime: null,
+      logger,
     });
 
     expect(result).toBeNull();
     expect(calls).toBe(1);
   });
 
-  it('Waits the correct time before retrying', async () => {
-    const timeoutSpy = jest.spyOn(global, 'setTimeout');
-
+  it('Retries on error', async () => {
     mockSupergraphSdlRequest('originalId-1234', mockCloudConfigUrl1).reply(500);
+    const supergraphSdl = getTestingSupergraphSdl();
     mockSupergraphSdlRequestIfAfter(
       'originalId-1234',
       mockCloudConfigUrl2,
@@ -406,29 +445,25 @@ describe('loadSupergraphSdlFromUplinks', () => {
           routerConfig: {
             __typename: 'RouterConfigResult',
             id: 'originalId-1234',
-            supergraphSdl: getTestingSupergraphSdl(),
+            supergraphSdl,
           },
         },
       }),
     );
 
-    await loadSupergraphSdlFromUplinks({
+    const result = await loadSupergraphSdlFromUplinks({
       graphRef,
       apiKey,
       endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
       errorReportingEndpoint: undefined,
-      fetcher: fetcher,
+      fetcher,
+      requestTimeoutMs,
       compositionId: 'originalId-1234',
       maxRetries: 1,
       roundRobinSeed: 0,
-      earliestFetchTime: new Date(Date.now() + 1000),
+      logger,
     });
 
-    // test if setTimeout was called with a value in range to deal with time jitter
-    const setTimeoutCall = timeoutSpy.mock.calls[1][1];
-    expect(setTimeoutCall).toBeLessThanOrEqual(1000);
-    expect(setTimeoutCall).toBeGreaterThanOrEqual(900);
-
-    timeoutSpy.mockRestore();
+    expect(result?.supergraphSdl).toEqual(supergraphSdl);
   });
 });