@apollo/gateway 0.45.0 → 0.47.0

package/src/config.ts

@@ -1,8 +1,11 @@
-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 { ServiceDefinition } from '@apollo/federation';
 import { GraphQLDataSource } from './datasources/types';
 import { QueryPlan } from '@apollo/query-planner';
 import { OperationContext } from './operationContext';
@@ -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,71 +124,181 @@ 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);
 }
 
 export interface ManagedGatewayConfig extends GatewayConfigBase {
   /**
    * This configuration option shouldn't be used unless by recommendation from
    * Apollo staff.
+   *
+   * @deprecated: use `uplinkEndpoints` instead
+   */
+  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.
    */
-  schemaConfigDeliveryEndpoint?: string; // deprecated
   uplinkEndpoints?: string[];
   uplinkMaxRetries?: number;
 }
 
+// TODO(trevor:removeServiceList): migrate users to `supergraphSdl` function option
 interface ManuallyManagedServiceDefsGatewayConfig extends GatewayConfigBase {
+  /**
+   * @deprecated: use `supergraphSdl` instead (either as a `SupergraphSdlHook` or `SupergraphManager`)
+   */
   experimental_updateServiceDefinitions: Experimental_UpdateServiceDefinitions;
 }
 
-interface ManuallyManagedSupergraphSdlGatewayConfig extends GatewayConfigBase {
-  experimental_updateSupergraphSdl: Experimental_UpdateSupergraphSdl
+// 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;
+}
+
+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;
+}
+
+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';
+}
+
+export function isSupergraphSdlHookConfig(
+  config: GatewayConfig,
+): config is SupergraphSdlHookGatewayConfig {
+  return (
+    'supergraphSdl' in config && typeof config.supergraphSdl === 'function'
+  );
+}
+
+export function isSupergraphManagerConfig(
+  config: GatewayConfig,
+): config is SupergraphManagerGatewayConfig {
+  return (
+    'supergraphSdl' in config &&
+    typeof config.supergraphSdl === 'object' &&
+    'initialize' in config.supergraphSdl
+  );
 }
 
 // A manually managed config means the user has provided a function which
@@ -192,8 +307,11 @@ export function isManuallyManagedConfig(
   config: GatewayConfig,
 ): config is ManuallyManagedGatewayConfig {
   return (
+    isManuallyManagedSupergraphSdlGatewayConfig(config) ||
     'experimental_updateServiceDefinitions' in config ||
-    'experimental_updateSupergraphSdl' in config
+    'experimental_updateSupergraphSdl' in config ||
+    // TODO(trevor:removeServiceList)
+    isServiceListConfig(config)
   );
 }
 
@@ -203,25 +321,16 @@ export function isManagedConfig(
 ): config is ManagedGatewayConfig {
   return (
     'schemaConfigDeliveryEndpoint' in config ||
-    (!isRemoteConfig(config) &&
-      !isLocalConfig(config) &&
-      !isSupergraphSdlConfig(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/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/executeQueryPlan.ts

@@ -12,6 +12,8 @@ import {
   GraphQLFieldResolver,
   GraphQLFormattedError,
   isAbstractType,
+  isObjectType,
+  isInterfaceType,
   GraphQLSchema,
 } from 'graphql';
 import { Trace, google } from 'apollo-reporting-protobuf';
@@ -523,7 +525,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) =>
@@ -580,7 +592,7 @@ function doesTypeConditionMatch(
   }
 
   if (isAbstractType(conditionalType)) {
-    return schema.isSubType(conditionalType, type);
+    return (isObjectType(type) || isInterfaceType(type)) && schema.isSubType(conditionalType, type);
   }
 
   return false;