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

package/src/executeQueryPlan.ts

@@ -14,6 +14,8 @@ import {
   GraphQLSchema,
   isObjectType,
   isInterfaceType,
+  GraphQLErrorOptions,
+  DocumentNode,
 } from 'graphql';
 import { Trace, google } from 'apollo-reporting-protobuf';
 import { GraphQLDataSource, GraphQLDataSourceRequestKind } from './datasources/types';
@@ -31,7 +33,7 @@ import { deepMerge } from './utilities/deepMerge';
 import { isNotNullOrUndefined } from './utilities/array';
 import { SpanStatusCode } from "@opentelemetry/api";
 import { OpenTelemetrySpanNames, tracer } from "./utilities/opentelemetry";
-import { defaultRootName } from '@apollo/federation-internals';
+import { defaultRootName, errorCodeDef, ERRORS } from '@apollo/federation-internals';
 
 export type ServiceMap = {
   [serviceName: string]: GraphQLDataSource;
@@ -44,6 +46,7 @@ interface ExecutionContext<TContext> {
   operationContext: OperationContext;
   serviceMap: ServiceMap;
   requestContext: GraphQLRequestContext<TContext>;
+  supergraphSchema: GraphQLSchema;
   errors: GraphQLError[];
 }
 
@@ -52,6 +55,7 @@ export async function executeQueryPlan<TContext>(
   serviceMap: ServiceMap,
   requestContext: GraphQLRequestContext<TContext>,
   operationContext: OperationContext,
+  supergraphSchema: GraphQLSchema,
 ): Promise<GraphQLExecutionResult> {
 
   const logger = requestContext.logger || console;
@@ -65,6 +69,7 @@ export async function executeQueryPlan<TContext>(
         operationContext,
         serviceMap,
         requestContext,
+        supergraphSchema,
         errors,
       };
 
@@ -118,11 +123,7 @@ export async function executeQueryPlan<TContext>(
               errors: [
                 new GraphQLError(
                   error.message,
-                  undefined,
-                  undefined,
-                  undefined,
-                  undefined,
-                  error as Error,
+                  { originalError: error },
                 )
               ]
             };
@@ -298,7 +299,8 @@ async function executeFetch<TContext>(
             context,
             fetch.operation,
             variables,
-            fetch.operationName
+            fetch.operationName,
+            fetch.operationDocumentNode
         );
 
         for (const entity of entities) {
@@ -312,7 +314,10 @@ async function executeFetch<TContext>(
 
         entities.forEach((entity, index) => {
           const representation = executeSelectionSet(
-            context.operationContext,
+            // Note that `requires` may include references to inacessible elements, so we should "execute" it using the supergrah
+            // schema, _not_ the API schema (the one in `context.operationContext.schema`). And this is not a security risk since
+            // what we're extracting here is what is sent to subgraphs, and subgraphs knows `@inacessible` elements.
+            context.supergraphSchema,
             entity,
             requires,
           );
@@ -334,7 +339,8 @@ async function executeFetch<TContext>(
             context,
             fetch.operation,
             {...variables, representations},
-            fetch.operationName
+            fetch.operationName,
+            fetch.operationDocumentNode
         );
 
         if (!dataReceivedFromService) {
@@ -376,7 +382,8 @@ async function executeFetch<TContext>(
     context: ExecutionContext<TContext>,
     source: string,
     variables: Record<string, any>,
-    operationName: string | undefined
+    operationName: string | undefined,
+    operationDocumentNode?: DocumentNode
   ): 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.
@@ -414,6 +421,7 @@ async function executeFetch<TContext>(
       },
       incomingRequestContext: context.requestContext,
       context: context.requestContext.context,
+      document: operationDocumentNode
     });
 
     if (response.errors) {
@@ -479,7 +487,7 @@ async function executeFetch<TContext>(
  * @param selectionSet
  */
 function executeSelectionSet(
-  operationContext: OperationContext,
+  schema: GraphQLSchema,
   source: Record<string, any> | null,
   selections: QueryPlanSelectionNode[],
 ): Record<string, any> | null {
@@ -514,12 +522,12 @@ function executeSelectionSet(
         if (Array.isArray(source[responseName])) {
           result[responseName] = source[responseName].map((value: any) =>
             selections
-              ? executeSelectionSet(operationContext, value, selections)
+              ? executeSelectionSet(schema, value, selections)
               : value,
           );
         } else if (selections) {
           result[responseName] = executeSelectionSet(
-            operationContext,
+            schema,
             source[responseName],
             selections,
           );
@@ -533,10 +541,10 @@ function executeSelectionSet(
         const typename = source && source['__typename'];
         if (!typename) continue;
 
-        if (doesTypeConditionMatch(operationContext.schema, selection.typeCondition, typename)) {
+        if (doesTypeConditionMatch(schema, selection.typeCondition, typename)) {
           deepMerge(
             result,
-            executeSelectionSet(operationContext, source, selection.selections),
+            executeSelectionSet(schema, source, selection.selections),
           );
         }
         break;
@@ -593,22 +601,25 @@ function downstreamServiceError(
   if (!message) {
     message = `Error while fetching subquery from service "${serviceName}"`;
   }
-  extensions = {
-    code: 'DOWNSTREAM_SERVICE_ERROR',
-    // XXX The presence of a serviceName in extensions is used to
-    // determine if this error should be captured for metrics reporting.
-    serviceName,
-    ...extensions,
+
+  const errorOptions: GraphQLErrorOptions = {
+    originalError: originalError as Error,
+    extensions: {
+      ...extensions,
+      // XXX The presence of a serviceName in extensions is used to
+      // determine if this error should be captured for metrics reporting.
+      serviceName,
+    }
   };
-  return new GraphQLError(
-    message,
-    undefined,
-    undefined,
-    undefined,
-    undefined,
-    originalError as Error,
-    extensions,
-  );
+
+  let codeDef = errorCodeDef(originalError);
+  // It's possible the orignal has a code, but not one we know about (one generated by the underlying `GraphQLDataSource`,
+  // which we don't control). In that case, we want to use that code (and have thus no `ErrorCodeDefinition` usable).
+  if (!codeDef && extensions?.code) {
+    return new GraphQLError(message, errorOptions);
+  }
+  // Otherwise, we either use the code we found and know, or default to a general downstream error code.
+  return (codeDef ?? ERRORS.DOWNSTREAM_SERVICE_ERROR).err(message, errorOptions);
 }
 
 export const defaultFieldResolverWithAliasSupport: GraphQLFieldResolver<

package/src/index.ts

@@ -13,7 +13,6 @@ import {
   GraphQLSchema,
   VariableDefinitionNode,
 } from 'graphql';
-import loglevel from 'loglevel';
 import { buildOperationContext, OperationContext } from './operationContext';
 import {
   executeQueryPlan,
@@ -26,7 +25,6 @@ import {
 } from './datasources/types';
 import { RemoteGraphQLDataSource } from './datasources/RemoteGraphQLDataSource';
 import { getVariableValues } from 'graphql/execution/values';
-import fetcher from 'make-fetch-happen';
 import {
   QueryPlanner,
   QueryPlan,
@@ -46,7 +44,6 @@ import {
   isManagedConfig,
   SupergraphSdlUpdate,
   isManuallyManagedSupergraphSdlGatewayConfig,
-  ManagedGatewayConfig,
   isStaticSupergraphSdlConfig,
   SupergraphManager,
 } from './config';
@@ -55,7 +52,7 @@ import { OpenTelemetrySpanNames, tracer } from './utilities/opentelemetry';
 import { addExtensions } from './schema-helper/addExtensions';
 import {
   IntrospectAndCompose,
-  UplinkFetcher,
+  UplinkSupergraphManager,
   LegacyFetcher,
   LocalCompose,
 } from './supergraphManagers';
@@ -65,7 +62,7 @@ import {
   Schema,
   ServiceDefinition,
 } from '@apollo/federation-internals';
-import { Fetcher } from '@apollo/utils.fetcher';
+import { getDefaultLogger } from './logger';
 
 type DataSourceMap = {
   [serviceName: string]: { url?: string; dataSource: GraphQLDataSource };
@@ -145,9 +142,10 @@ export class ApolloGateway implements GraphQLService {
   private warnedStates: WarnedStates = Object.create(null);
   private queryPlanner?: QueryPlanner;
   private supergraphSdl?: string;
-  private fetcher: Fetcher;
+  private supergraphSchema?: GraphQLSchema;
   private compositionId?: string;
   private state: GatewayState;
+  private _supergraphManager?: SupergraphManager;
 
   // Observe query plan, service info, and operation info prior to execution.
   // The information made available here will give insight into the resulting
@@ -169,11 +167,10 @@ export class ApolloGateway implements GraphQLService {
       ...config,
     };
 
-    this.logger = this.initLogger();
+    this.logger = this.config.logger ?? getDefaultLogger(this.config.debug);
     this.queryPlanStore = this.initQueryPlanStore(
       config?.experimental_approximateQueryPlanStoreMiB,
     );
-    this.fetcher = config?.fetcher || fetcher;
 
     // set up experimental observability callbacks and config settings
     this.experimental_didResolveQueryPlan =
@@ -194,23 +191,8 @@ export class ApolloGateway implements GraphQLService {
     this.state = { phase: 'initialized' };
   }
 
-  private initLogger() {
-    // Setup logging facilities
-    if (this.config.logger) {
-      return this.config.logger;
-    }
-
-    // If the user didn't provide their own logger, we'll initialize one.
-    const loglevelLogger = loglevel.getLogger(`apollo-gateway`);
-
-    // And also support the `debug` option, if it's truthy.
-    if (this.config.debug === true) {
-      loglevelLogger.setLevel(loglevelLogger.levels.DEBUG);
-    } else {
-      loglevelLogger.setLevel(loglevelLogger.levels.WARN);
-    }
-
-    return loglevelLogger;
+  public get supergraphManager(): SupergraphManager | undefined {
+    return this._supergraphManager;
   }
 
   private initQueryPlanStore(approximateQueryPlanStoreMiB?: number) {
@@ -226,22 +208,6 @@ export class ApolloGateway implements GraphQLService {
   }
 
   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)) {
@@ -381,19 +347,21 @@ export class ApolloGateway implements GraphQLService {
             '`serviceList`, `supergraphSdl`, and `experimental_updateServiceDefinitions`.',
         );
       }
-      const uplinkEndpoints = this.getUplinkEndpoints(this.config);
 
+      const schemaDeliveryEndpoints: string[] | undefined = this.config
+        .schemaConfigDeliveryEndpoint
+        ? [this.config.schemaConfigDeliveryEndpoint]
+        : undefined;
       await this.initializeSupergraphManager(
-        new UplinkFetcher({
+        new UplinkSupergraphManager({
           graphRef: this.apolloConfig!.graphRef!,
           apiKey: this.apolloConfig!.key!,
-          uplinkEndpoints,
-          maxRetries:
-            this.config.uplinkMaxRetries ?? uplinkEndpoints.length * 3 - 1, // -1 for the initial request
-          subgraphHealthCheck: this.config.serviceHealthCheck,
-          fetcher: this.fetcher,
+          shouldRunSubgraphHealthcheck: this.config.serviceHealthCheck,
+          uplinkEndpoints:
+            this.config.uplinkEndpoints ?? schemaDeliveryEndpoints,
+          maxRetries: this.config.uplinkMaxRetries,
           logger: this.logger,
-          fallbackPollIntervalInMs: this.pollIntervalInMs ?? 10000,
+          fallbackPollIntervalInMs: this.pollIntervalInMs,
         }),
       );
     }
@@ -415,29 +383,6 @@ export class ApolloGateway implements GraphQLService {
     };
   }
 
-  private getUplinkEndpoints(config: ManagedGatewayConfig) {
-    /**
-     * Configuration priority order:
-     * 1. `uplinkEndpoints` configuration option
-     * 2. (deprecated) `schemaConfigDeliveryEndpoint` configuration option
-     * 3. APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT environment variable
-     * 4. default (GCP and AWS)
-     */
-    const rawEndpointsString =
-      process.env.APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT;
-    const envEndpoints = rawEndpointsString?.split(',') ?? null;
-    return (
-      config.uplinkEndpoints ??
-      (config.schemaConfigDeliveryEndpoint
-        ? [config.schemaConfigDeliveryEndpoint]
-        : null) ??
-      envEndpoints ?? [
-        'https://uplink.api.apollographql.com/',
-        'https://aws.uplink.api.apollographql.com/',
-      ]
-    );
-  }
-
   private getIdForSupergraphSdl(supergraphSdl: string) {
     return createHash('sha256').update(supergraphSdl).digest('hex');
   }
@@ -451,11 +396,6 @@ export class ApolloGateway implements GraphQLService {
         healthCheck: this.externalSubgraphHealthCheckCallback.bind(this),
         getDataSource: this.externalGetDataSourceCallback.bind(this),
       });
-      if (!result?.supergraphSdl) {
-        throw new Error(
-          'Provided `supergraphSdl` function did not return an object containing a `supergraphSdl` property',
-        );
-      }
       if (result?.cleanup) {
         if (typeof result.cleanup === 'function') {
           this.toDispose.push(result.cleanup);
@@ -473,6 +413,7 @@ export class ApolloGateway implements GraphQLService {
       throw e;
     }
 
+    this._supergraphManager = supergraphManager;
     this.state = { phase: 'loaded' };
   }
 
@@ -566,7 +507,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,
     );
 
@@ -575,25 +516,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
             ? {
@@ -698,7 +640,7 @@ export class ApolloGateway implements GraphQLService {
     this.createServices(serviceList);
 
     return {
-      schema,
+      supergraphSchema: schema,
       supergraphSdl,
     };
   }
@@ -903,6 +845,7 @@ export class ApolloGateway implements GraphQLService {
             serviceMap,
             requestContext,
             operationContext,
+            this.supergraphSchema!,
           );
 
           const shouldShowQueryPlan =
@@ -1008,9 +951,6 @@ export class ApolloGateway implements GraphQLService {
     switch (this.state.phase) {
       case 'initialized':
       case 'failed to load':
-        throw Error(
-          'ApolloGateway.stop does not need to be called before ApolloGateway.load is called successfully',
-        );
       case 'stopped':
         // Calls to stop() are idempotent.
         return;
@@ -1105,6 +1045,7 @@ export {
   CompositionInfo,
   IntrospectAndCompose,
   LocalCompose,
+  UplinkSupergraphManager,
 };
 
 export * from './datasources';
@@ -1114,8 +1055,12 @@ export {
   SubgraphHealthCheckFunction,
   GetDataSourceFunction,
   SupergraphSdlHook,
-  SupergraphManager
+  SupergraphManager,
 } from './config';
 
-export { UplinkFetcherError } from "./supergraphManagers"
-
+export {
+  UplinkFetcherError,
+  FailureToFetchSupergraphSdlAfterInit,
+  FailureToFetchSupergraphSdlDuringInit,
+  FailureToFetchSupergraphSdlFunctionParams,
+} from './supergraphManagers';

package/src/logger.ts

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

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,6 +1,6 @@
 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 '../..';

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

@@ -0,0 +1,65 @@
+import mockedEnv from 'mocked-env';
+
+import { UplinkSupergraphManager } from '@apollo/gateway';
+
+let cleanUp: (() => void) | undefined;
+
+const logger = {
+  warn: jest.fn(),
+  debug: jest.fn(),
+  error: jest.fn(),
+  info: jest.fn(),
+};
+const apiKey = 'OU812';
+const graphRef = 'graph@ref';
+
+afterEach(async () => {
+  if (cleanUp) {
+    cleanUp();
+    cleanUp = undefined;
+  }
+});
+
+describe('UplinkSupergraphManager', () => {
+  it('can be minimally constructed', () => {
+    new UplinkSupergraphManager({ apiKey, graphRef });
+  });
+
+  describe('setting uplink URLs', () => {
+    it('uses default uplink URLs', async () => {
+      const manager = new UplinkSupergraphManager({ apiKey, graphRef, logger });
+
+      expect(manager.uplinkEndpoints).toEqual(UplinkSupergraphManager.DEFAULT_UPLINK_ENDPOINTS);
+    });
+
+    it('can set uplink URLs via config', async () => {
+      cleanUp = mockedEnv({
+        APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT: 'https://env-delivery.com',
+      });
+      const uplinkEndpoints = [
+        'https://config-delivery1.com',
+        'https://config-delivery2.com',
+      ];
+
+      const manager = new UplinkSupergraphManager({
+        apiKey,
+        graphRef,
+        uplinkEndpoints,
+        logger,
+      });
+
+      expect(manager.uplinkEndpoints).toEqual(uplinkEndpoints);
+    });
+
+    it('can set uplink URLs via environment variable', async () => {
+      const uplinkUrl = 'https://env-delivery.com';
+      cleanUp = mockedEnv({
+        APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT: uplinkUrl,
+      });
+
+      const manager = new UplinkSupergraphManager({ apiKey, graphRef, logger });
+
+      expect(manager.uplinkEndpoints).toEqual([uplinkUrl]);
+    });
+  });
+});