@apollo/gateway 2.0.0-alpha.0 → 2.0.0-alpha.4

package/src/__tests__/nockAssertions.ts

@@ -0,0 +1,20 @@
+import nock from 'nock';
+
+// Ensures an active and clean nock before every test
+export function nockBeforeEach() {
+  if (!nock.isActive()) {
+    nock.activate();
+  }
+  // Cleaning _before_ each test ensures that any mocks from a previous test
+  // which failed don't affect the current test.
+  nock.cleanAll();
+}
+
+// Ensures a test is complete (all expected requests were run) and a clean
+// global state after each test.
+export function nockAfterEach() {
+  // unmock HTTP interceptor
+  nock.restore();
+  // effectively nock.isDone() but with more helpful messages in test failures
+  expect(nock.activeMocks()).toEqual([]);
+};

package/src/config.ts

@@ -1,12 +1,15 @@
-import { GraphQLError, GraphQLSchema } from "graphql";
-import { HeadersInit } from "node-fetch";
+import { GraphQLError, GraphQLSchema } from 'graphql';
+import { HeadersInit } from 'node-fetch';
 import { fetch } from 'apollo-server-env';
-import { GraphQLRequestContextExecutionDidStart, Logger } from "apollo-server-types";
-import { ServiceDefinition } from "@apollo/federation";
+import {
+  GraphQLRequestContextExecutionDidStart,
+  Logger,
+} from 'apollo-server-types';
 import { GraphQLDataSource } from './datasources/types';
 import { QueryPlan } from '@apollo/query-planner';
 import { OperationContext } from './operationContext';
 import { ServiceMap } from './executeQueryPlan';
+import { ServiceDefinition } from "@apollo/federation-internals";
 
 export type ServiceEndpointDefinition = Pick<ServiceDefinition, 'name' | 'url'>;
 
@@ -62,7 +65,7 @@ export type CompositionInfo =
   | ServiceDefinitionCompositionInfo
   | SupergraphSdlCompositionInfo;
 
-export type Experimental_DidUpdateCompositionCallback = (
+export type Experimental_DidUpdateSupergraphCallback = (
   currentConfig: CompositionInfo,
   previousConfig?: CompositionInfo,
 ) => void;
@@ -80,7 +83,9 @@ export interface SupergraphSdlUpdate {
   supergraphSdl: string;
 }
 
-export function isSupergraphSdlUpdate(update: CompositionUpdate): update is SupergraphSdlUpdate {
+export function isSupergraphSdlUpdate(
+  update: CompositionUpdate,
+): update is SupergraphSdlUpdate {
   return 'supergraphSdl' in update;
 }
 
@@ -119,142 +124,213 @@ interface GatewayConfigBase {
 
   // experimental observability callbacks
   experimental_didResolveQueryPlan?: Experimental_DidResolveQueryPlanCallback;
-  experimental_didFailComposition?: Experimental_DidFailCompositionCallback;
-  experimental_didUpdateComposition?: Experimental_DidUpdateCompositionCallback;
+  experimental_didUpdateSupergraph?: Experimental_DidUpdateSupergraphCallback;
+  /**
+   * @deprecated use `pollIntervalInMs` instead
+   */
   experimental_pollInterval?: number;
+  pollIntervalInMs?: number;
   experimental_approximateQueryPlanStoreMiB?: number;
   experimental_autoFragmentization?: boolean;
   fetcher?: typeof fetch;
   serviceHealthCheck?: boolean;
 }
 
-export interface RemoteGatewayConfig extends GatewayConfigBase {
+// TODO(trevor:removeServiceList)
+export interface ServiceListGatewayConfig extends GatewayConfigBase {
+  /**
+   * @deprecated: use `supergraphSdl: new IntrospectAndCompose(...)` instead
+   */
   serviceList: ServiceEndpointDefinition[];
+  /**
+   * @deprecated: use `supergraphSdl: new IntrospectAndCompose(...)` instead
+   */
   introspectionHeaders?:
     | HeadersInit
-    | ((service: ServiceEndpointDefinition) => Promise<HeadersInit> | HeadersInit);
+    | ((
+        service: ServiceEndpointDefinition,
+      ) => Promise<HeadersInit> | HeadersInit);
 }
 
-// TODO(trevor:cloudconfig): This type goes away
-export interface LegacyManagedGatewayConfig extends GatewayConfigBase {
-  federationVersion?: number;
+export interface ManagedGatewayConfig extends GatewayConfigBase {
   /**
-   * Setting this to null will cause the gateway to use the old mechanism for
-   * managed federation via GCS + composition.
+   * This configuration option shouldn't be used unless by recommendation from
+   * Apollo staff.
+   *
+   * @deprecated: use `uplinkEndpoints` instead
    */
-  schemaConfigDeliveryEndpoint: null;
+  schemaConfigDeliveryEndpoint?: string;
+  /**
+   * This defaults to:
+   * ['https://uplink.api.apollographql.com/', 'https://aws.uplink.api.apollographql.com/']
+   * The first URL points to GCP, the second to AWS. This option should most likely
+   * be left to default unless you have a specific reason to change it.
+   */
+  uplinkEndpoints?: string[];
+  uplinkMaxRetries?: number;
 }
 
-// TODO(trevor:cloudconfig): This type becomes the only managed config
-export interface PrecomposedManagedGatewayConfig extends GatewayConfigBase {
+// TODO(trevor:removeServiceList): migrate users to `supergraphSdl` function option
+interface ManuallyManagedServiceDefsGatewayConfig extends GatewayConfigBase {
   /**
-   * This configuration option shouldn't be used unless by recommendation from
-   * Apollo staff. This can also be set to `null` (see above) in order to revert
-   * to the previous mechanism for managed federation.
+   * @deprecated: use `supergraphSdl` instead (either as a `SupergraphSdlHook` or `SupergraphManager`)
    */
-  schemaConfigDeliveryEndpoint?: string;
+  experimental_updateServiceDefinitions: Experimental_UpdateServiceDefinitions;
 }
 
-// TODO(trevor:cloudconfig): This union is no longer needed
-export type ManagedGatewayConfig =
-  | LegacyManagedGatewayConfig
-  | PrecomposedManagedGatewayConfig;
+// TODO(trevor:removeServiceList): migrate users to `supergraphSdl` function option
+interface ExperimentalManuallyManagedSupergraphSdlGatewayConfig
+  extends GatewayConfigBase {
+  /**
+   * @deprecated: use `supergraphSdl` instead (either as a `SupergraphSdlHook` or `SupergraphManager`)
+   */
+  experimental_updateSupergraphSdl: Experimental_UpdateSupergraphSdl;
+}
 
-interface ManuallyManagedServiceDefsGatewayConfig extends GatewayConfigBase {
-  experimental_updateServiceDefinitions: Experimental_UpdateServiceDefinitions;
+export function isManuallyManagedSupergraphSdlGatewayConfig(
+  config: GatewayConfig,
+): config is ManuallyManagedSupergraphSdlGatewayConfig {
+  return isSupergraphSdlHookConfig(config) || isSupergraphManagerConfig(config);
+}
+
+export type SupergraphSdlUpdateFunction = (
+  updatedSupergraphSdl: string,
+) => void;
+
+export type SubgraphHealthCheckFunction = (
+  supergraphSdl: string,
+) => Promise<void>;
+
+export type GetDataSourceFunction = ({
+  name,
+  url,
+}: ServiceEndpointDefinition) => GraphQLDataSource;
+
+export interface SupergraphSdlHookOptions {
+  update: SupergraphSdlUpdateFunction;
+  healthCheck: SubgraphHealthCheckFunction;
+  getDataSource: GetDataSourceFunction;
+}
+export interface SupergraphSdlHook {
+  (options: SupergraphSdlHookOptions): Promise<{
+    supergraphSdl: string;
+    cleanup?: () => Promise<void>;
+  }>;
+}
+
+export interface SupergraphManager {
+  initialize: SupergraphSdlHook;
 }
 
-interface ManuallyManagedSupergraphSdlGatewayConfig extends GatewayConfigBase {
-  experimental_updateSupergraphSdl: Experimental_UpdateSupergraphSdl
+type ManuallyManagedSupergraphSdlGatewayConfig =
+  | SupergraphSdlHookGatewayConfig
+  | SupergraphManagerGatewayConfig;
+
+export interface SupergraphSdlHookGatewayConfig extends GatewayConfigBase {
+  supergraphSdl: SupergraphSdlHook;
+}
+
+export interface SupergraphManagerGatewayConfig extends GatewayConfigBase {
+  supergraphSdl: SupergraphManager;
 }
 
 type ManuallyManagedGatewayConfig =
   | ManuallyManagedServiceDefsGatewayConfig
-  | ManuallyManagedSupergraphSdlGatewayConfig;
+  | ExperimentalManuallyManagedSupergraphSdlGatewayConfig
+  | ManuallyManagedSupergraphSdlGatewayConfig
+  // TODO(trevor:removeServiceList
+  | ServiceListGatewayConfig;
 
+// TODO(trevor:removeServiceList)
 interface LocalGatewayConfig extends GatewayConfigBase {
+  /**
+   * @deprecated: use `supergraphSdl: new LocalCompose(...)` instead
+   */
   localServiceList: ServiceDefinition[];
 }
 
-interface SupergraphSdlGatewayConfig extends GatewayConfigBase {
+interface StaticSupergraphSdlGatewayConfig extends GatewayConfigBase {
   supergraphSdl: string;
 }
 
-export type StaticGatewayConfig = LocalGatewayConfig | SupergraphSdlGatewayConfig;
+export type StaticGatewayConfig =
+  | LocalGatewayConfig
+  | StaticSupergraphSdlGatewayConfig;
 
-type DynamicGatewayConfig =
-| ManagedGatewayConfig
-| RemoteGatewayConfig
-| ManuallyManagedGatewayConfig;
+export type DynamicGatewayConfig =
+  | ManagedGatewayConfig
+  | ManuallyManagedGatewayConfig;
 
 export type GatewayConfig = StaticGatewayConfig | DynamicGatewayConfig;
 
-export function isLocalConfig(config: GatewayConfig): config is LocalGatewayConfig {
+// TODO(trevor:removeServiceList)
+export function isLocalConfig(
+  config: GatewayConfig,
+): config is LocalGatewayConfig {
   return 'localServiceList' in config;
 }
 
-export function isRemoteConfig(config: GatewayConfig): config is RemoteGatewayConfig {
+// TODO(trevor:removeServiceList)
+export function isServiceListConfig(
+  config: GatewayConfig,
+): config is ServiceListGatewayConfig {
   return 'serviceList' in config;
 }
 
-export function isSupergraphSdlConfig(config: GatewayConfig): config is SupergraphSdlGatewayConfig {
-  return 'supergraphSdl' in config;
+export function isStaticSupergraphSdlConfig(
+  config: GatewayConfig,
+): config is StaticSupergraphSdlGatewayConfig {
+  return 'supergraphSdl' in config && typeof config.supergraphSdl === 'string';
 }
 
-// A manually managed config means the user has provided a function which
-// handles providing service definitions to the gateway.
-export function isManuallyManagedConfig(
+export function isSupergraphSdlHookConfig(
   config: GatewayConfig,
-): config is ManuallyManagedGatewayConfig {
+): config is SupergraphSdlHookGatewayConfig {
   return (
-    'experimental_updateServiceDefinitions' in config ||
-    'experimental_updateSupergraphSdl' in config
+    'supergraphSdl' in config && typeof config.supergraphSdl === 'function'
   );
 }
 
-// Managed config strictly means managed by Studio
-export function isManagedConfig(
+export function isSupergraphManagerConfig(
   config: GatewayConfig,
-): config is ManagedGatewayConfig {
-  return isPrecomposedManagedConfig(config) || isLegacyManagedConfig(config);
+): config is SupergraphManagerGatewayConfig {
+  return (
+    'supergraphSdl' in config &&
+    typeof config.supergraphSdl === 'object' &&
+    'initialize' in config.supergraphSdl
+  );
 }
 
-// TODO(trevor:cloudconfig): This merges with `isManagedConfig`
-export function isPrecomposedManagedConfig(
+// A manually managed config means the user has provided a function which
+// handles providing service definitions to the gateway.
+export function isManuallyManagedConfig(
   config: GatewayConfig,
-): config is PrecomposedManagedGatewayConfig {
+): config is ManuallyManagedGatewayConfig {
   return (
-    !isLegacyManagedConfig(config) &&
-    (('schemaConfigDeliveryEndpoint' in config &&
-      typeof config.schemaConfigDeliveryEndpoint === 'string') ||
-      (!isRemoteConfig(config) &&
-        !isLocalConfig(config) &&
-        !isSupergraphSdlConfig(config) &&
-        !isManuallyManagedConfig(config)))
+    isManuallyManagedSupergraphSdlGatewayConfig(config) ||
+    'experimental_updateServiceDefinitions' in config ||
+    'experimental_updateSupergraphSdl' in config ||
+    // TODO(trevor:removeServiceList)
+    isServiceListConfig(config)
   );
 }
 
-export function isLegacyManagedConfig(
+// Managed config strictly means managed by Studio
+export function isManagedConfig(
   config: GatewayConfig,
-): config is LegacyManagedGatewayConfig {
+): config is ManagedGatewayConfig {
   return (
-    'schemaConfigDeliveryEndpoint' in config &&
-    config.schemaConfigDeliveryEndpoint === null
+    'schemaConfigDeliveryEndpoint' in config ||
+    'uplinkEndpoints' in config ||
+    (!isLocalConfig(config) &&
+      !isStaticSupergraphSdlConfig(config) &&
+      !isManuallyManagedConfig(config))
   );
 }
 
 // A static config is one which loads synchronously on start and never updates
-export function isStaticConfig(config: GatewayConfig): config is StaticGatewayConfig {
-  return isLocalConfig(config) || isSupergraphSdlConfig(config);
-}
-
-// A dynamic config is one which loads asynchronously and (can) update via polling
-export function isDynamicConfig(
+export function isStaticConfig(
   config: GatewayConfig,
-): config is DynamicGatewayConfig {
-  return (
-    isRemoteConfig(config) ||
-    isManagedConfig(config) ||
-    isManuallyManagedConfig(config)
-  );
+): config is StaticGatewayConfig {
+  return isLocalConfig(config) || isStaticSupergraphSdlConfig(config);
 }

package/src/core/__tests__/core.test.ts

@@ -41,7 +41,7 @@ describe('core v0.1', () => {
       scalar join__FieldSet
 
       enum join__Graph {
-        WORLD @join__graph(name: "world", url: "https://world.api.com")
+        WORLD @join__graph(name: "world", url: "https://world.api.com.invalid")
       }
 
       type Query {
@@ -97,7 +97,7 @@ describe('core v0.1', () => {
       scalar join__FieldSet
 
       enum join__Graph {
-        WORLD @join__graph(name: "world", url: "https://world.api.com")
+        WORLD @join__graph(name: "world", url: "https://world.api.com.invalid")
       }
 
       type Query {
@@ -173,7 +173,7 @@ describe('core v0.2', () => {
       scalar join__FieldSet
 
       enum join__Graph {
-        WORLD @join__graph(name: "world", url: "https://world.api.com")
+        WORLD @join__graph(name: "world", url: "https://world.api.com.invalid")
       }
 
       type Query {
@@ -243,7 +243,7 @@ describe('core v0.2', () => {
       scalar join__FieldSet
 
       enum join__Graph {
-        WORLD @join__graph(name: "world", url: "https://world.api.com")
+        WORLD @join__graph(name: "world", url: "https://world.api.com.invalid")
       }
 
       type Query {
@@ -315,7 +315,7 @@ describe('core v0.2', () => {
       scalar join__FieldSet
 
       enum join__Graph {
-        WORLD @join__graph(name: "world", url: "https://world.api.com")
+        WORLD @join__graph(name: "world", url: "https://world.api.com.invalid")
       }
 
       type Query {
@@ -391,7 +391,7 @@ describe('core v0.2', () => {
       scalar join__FieldSet
 
       enum join__Graph {
-        WORLD @join__graph(name: "world", url: "https://world.api.com")
+        WORLD @join__graph(name: "world", url: "https://world.api.com.invalid")
       }
 
       type Query {

package/src/datasources/LocalGraphQLDataSource.ts

@@ -39,7 +39,7 @@ export class LocalGraphQLDataSource<
       throw new Error(result.errors.map((error) => error.message).join('\n\n'));
     }
 
-    const sdl = result.data && result.data._service && result.data._service.sdl;
+    const sdl = result.data && result.data._service && (result.data._service as any).sdl;
     return parse(sdl);
   }
 }

package/src/datasources/RemoteGraphQLDataSource.ts

@@ -17,18 +17,24 @@ import { isObject } from '../utilities/predicates';
 import { GraphQLDataSource, GraphQLDataSourceProcessOptions, GraphQLDataSourceRequestKind } from './types';
 import createSHA from 'apollo-server-core/dist/utils/createSHA';
 import { parseCacheControlHeader } from './parseCacheControlHeader';
-
+import fetcher from 'make-fetch-happen';
 export class RemoteGraphQLDataSource<
   TContext extends Record<string, any> = Record<string, any>,
 > implements GraphQLDataSource<TContext>
 {
-  fetcher: typeof fetch = fetch;
+  fetcher: typeof fetch;
 
   constructor(
     config?: Partial<RemoteGraphQLDataSource<TContext>> &
       object &
       ThisType<RemoteGraphQLDataSource<TContext>>,
   ) {
+    this.fetcher = fetcher.defaults({
+      // although this is the default, we want to take extra care and be very
+      // explicity to ensure that mutations cannot be retried. please leave this
+      // intact.
+      retry: false,
+    });
     if (config) {
       return Object.assign(this, config);
     }

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

@@ -1,7 +1,7 @@
 import { LocalGraphQLDataSource } from '../LocalGraphQLDataSource';
 import { buildSubgraphSchema } from '@apollo/subgraph';
 import gql from 'graphql-tag';
-import { GraphQLResolverMap } from 'apollo-graphql';
+import { GraphQLResolverMap } from '../../schema-helper';
 import { GraphQLRequestContext } from 'apollo-server-types';
 import { GraphQLDataSourceRequestKind } from '../types';
 

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

@@ -1,5 +1,5 @@
-import { fetch } from '../../__mocks__/apollo-server-env';
-import { makeFetchHappenFetcher } from '../../__mocks__/make-fetch-happen-fetcher';
+import { fetch as customFetcher } from '../../__mocks__/apollo-server-env';
+import { fetch } from '../../__mocks__/make-fetch-happen-fetcher';
 
 import {
   ApolloError,
@@ -263,8 +263,8 @@ describe('fetcher', () => {
     expect(data).toEqual({ injected: true });
   });
 
-  it('supports a custom fetcher, like `make-fetch-happen`', async () => {
-    const injectedFetch = makeFetchHappenFetcher.mockJSONResponseOnce({
+  it('supports a custom fetcher, like `node-fetch`', async () => {
+    const injectedFetch = customFetcher.mockJSONResponseOnce({
       data: { me: 'james' },
     });
     const DataSource = new RemoteGraphQLDataSource({

package/src/datasources/types.ts

@@ -47,6 +47,6 @@ export type GraphQLDataSourceProcessOptions<
       /**
        * Mostly provided for historical reasons.
        */
-      context: {};
+      context: Record<string, any>;
     }
 );

package/src/executeQueryPlan.ts

@@ -12,9 +12,10 @@ import {
   GraphQLFormattedError,
   isAbstractType,
   GraphQLSchema,
+  isObjectType,
+  isInterfaceType,
 } from 'graphql';
 import { Trace, google } from 'apollo-reporting-protobuf';
-import { defaultRootOperationNameLookup } from '@apollo/federation';
 import { GraphQLDataSource, GraphQLDataSourceRequestKind } from './datasources/types';
 import { OperationContext } from './operationContext';
 import {
@@ -30,6 +31,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';
 
 export type ServiceMap = {
   [serviceName: string]: GraphQLDataSource;
@@ -85,7 +87,7 @@ export async function executeQueryPlan<TContext>(
         }
       }
 
-      let result = await tracer.startActiveSpan(OpenTelemetrySpanNames.POST_PROCESSING, async (span) => {
+      const result = await tracer.startActiveSpan(OpenTelemetrySpanNames.POST_PROCESSING, async (span) => {
 
         // FIXME: Re-executing the query is a pretty heavy handed way of making sure
         // only explicitly requested fields are included and field ordering follows
@@ -278,7 +280,7 @@ async function executeFetch<TContext>(
 
       if (entities.length < 1) return;
 
-      let variables = Object.create(null);
+      const variables = Object.create(null);
       if (fetch.variableUsages) {
         for (const variableName of fetch.variableUsages) {
           const providedVariables = context.requestContext.request.variables;
@@ -450,10 +452,7 @@ async function executeFetch<TContext>(
           // to have the default names (Query, Mutation, Subscription) even
           // if the implementing services choose different names, so we override
           // whatever the implementing service reported here.
-          const rootTypeName =
-            defaultRootOperationNameLookup[
-              context.operationContext.operation.operation
-            ];
+          const rootTypeName = defaultRootName(context.operationContext.operation.operation);
           traceNode.trace.root?.child?.forEach((child) => {
             child.parentType = rootTypeName;
           });
@@ -492,7 +491,17 @@ function executeSelectionSet(
         const selections = (selection as QueryPlanFieldNode).selections;
 
         if (typeof source[responseName] === 'undefined') {
-          throw new Error(`Field "${responseName}" was not found in response.`);
+          // This method is called to collect the inputs/requires of a fetch. So, assuming query plans are correct
+          // (and we have not reason to assume otherwise here), all inputs should be fetched beforehand and the
+          // only reason for not finding one of the inputs is that we had an error fetching it _and_ that field
+          // is non-nullable (it it was nullable, error fetching the input would have make that input `null`; not
+          // having the input means the field is non-nullable so the whole entity had to be nullified/ignored,
+          // leading use to not have the field at all).
+          // In any case, we don't have all the necessary inputs for this particular entity and should ignore it.
+          // Note that an error has already been logged for whichever issue happen while fetching the inputs we're
+          // missing here, and that error had much more context, so no reason to log a duplicate (less useful) error
+          // here.
+          return null;
         }
         if (Array.isArray(source[responseName])) {
           result[responseName] = source[responseName].map((value: any) =>
@@ -549,7 +558,7 @@ function doesTypeConditionMatch(
   }
 
   if (isAbstractType(conditionalType)) {
-    return schema.isSubType(conditionalType, type);
+    return (isObjectType(type) || isInterfaceType(type)) && schema.isSubType(conditionalType, type);
   }
 
   return false;