@apollo/gateway 0.51.0 → 0.52.0

package/src/index.ts

@@ -1,11 +1,6 @@
 import { deprecate } from 'util';
-import { GraphQLService, Unsubscriber } from 'apollo-server-core';
-import {
-  GraphQLExecutionResult,
-  GraphQLRequestContextExecutionDidStart,
-} from 'apollo-server-types';
 import type { Logger } from '@apollo/utils.logger';
-import { InMemoryLRUCache } from 'apollo-server-caching';
+import LRUCache from 'lru-cache';
 import {
   isObjectType,
   isIntrospectionType,
@@ -68,6 +63,7 @@ import {
   LocalCompose,
 } from './supergraphManagers';
 import { Fetcher } from '@apollo/utils.fetcher';
+import {GatewayInterface, GatewayUnsubscriber, GatewayGraphQLRequestContext, GatewayExecutionResult} from '@apollo/server-gateway-interface';
 
 type DataSourceMap = {
   [serviceName: string]: { url?: string; dataSource: GraphQLDataSource };
@@ -123,12 +119,12 @@ interface GraphQLServiceEngineConfig {
   graphVariant?: string;
 }
 
-export class ApolloGateway implements GraphQLService {
+export class ApolloGateway implements GatewayInterface {
   public schema?: GraphQLSchema;
   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<
@@ -210,14 +206,14 @@ 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,
     });
   }
 
@@ -607,7 +603,7 @@ 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.schema = toAPISchema(coreSchema);
     this.queryPlanner = new QueryPlanner(coreSchema);
 
@@ -718,7 +714,7 @@ export class ApolloGateway implements GraphQLService {
    */
   public onSchemaChange(
     callback: (schema: GraphQLSchema) => void,
-  ): Unsubscriber {
+  ): GatewayUnsubscriber {
     this.onSchemaChangeListeners.add(callback);
 
     return () => {
@@ -731,7 +727,7 @@ export class ApolloGateway implements GraphQLService {
       apiSchema: GraphQLSchema;
       coreSupergraphSdl: string;
     }) => void,
-  ): Unsubscriber {
+  ): GatewayUnsubscriber {
     this.onSchemaLoadOrUpdateListeners.add(callback);
 
     return () => {
@@ -811,9 +807,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 }
       : {};
@@ -843,10 +839,7 @@ export class ApolloGateway implements GraphQLService {
             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(
@@ -868,25 +861,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),
               );
             }
           }
@@ -908,7 +887,7 @@ export class ApolloGateway implements GraphQLService {
             });
           }
 
-          const response = await executeQueryPlan<TContext>(
+          const response = await executeQueryPlan(
             queryPlan,
             serviceMap,
             requestContext,
@@ -965,8 +944,8 @@ export class ApolloGateway implements GraphQLService {
     );
   };
 
-  private validateIncomingRequest<TContext>(
-    requestContext: GraphQLRequestContextExecutionDidStart<TContext>,
+  private validateIncomingRequest(
+    requestContext: GatewayGraphQLRequestContext,
     operationContext: OperationContext,
   ) {
     return tracer.startActiveSpan(OpenTelemetrySpanNames.VALIDATE, (span) => {

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 { GraphQLDataSource, GraphQLDataSourceRequestKind } from '../../datasources/types';
 import { SERVICE_DEFINITION_QUERY } from '../..';
 import { ServiceDefinitionUpdate, ServiceEndpointDefinition } from '../../config';
 import { ServiceDefinition } from '@apollo/federation';
+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,