@apollo/gateway 0.300.0-alpha.2 → 2.0.0-alpha.2

package/src/__tests__/queryPlanCucumber.test.ts

@@ -1,14 +1,13 @@
 import gql from 'graphql-tag';
-import { GraphQLSchemaValidationError } from 'apollo-graphql';
 import { defineFeature, loadFeature } from 'jest-cucumber';
-import { DocumentNode, GraphQLSchema, GraphQLError, Kind } from 'graphql';
+import { DocumentNode } from 'graphql';
 
-import { QueryPlan } from '../..';
-import { buildQueryPlan, buildOperationContext, BuildQueryPlanOptions } from '../buildQueryPlan';
+import { QueryPlan } from '@apollo/query-planner';
 import { getFederatedTestingSchema } from './execution-utils';
+import { operationFromDocument } from '@apollo/federation-internals';
 
 const buildQueryPlanFeature = loadFeature(
-  './packages/apollo-gateway/src/__tests__/build-query-plan.feature'
+  './gateway-js/src/__tests__/build-query-plan.feature'
 );
 
 
@@ -19,40 +18,26 @@ const features = [
 features.forEach((feature) => {
   defineFeature(feature, (test) => {
     feature.scenarios.forEach((scenario) => {
-      test(scenario.title, async ({ given, when, then }) => {
-        let query: DocumentNode;
+      test(scenario.title, async ({ given, then }) => {
+        let operationDocument: DocumentNode;
         let queryPlan: QueryPlan;
-        let options: BuildQueryPlanOptions = { autoFragmentization: false };
 
-        const { schema, errors } = getFederatedTestingSchema();
-
-        if (errors && errors.length > 0) {
-          throw new GraphQLSchemaValidationError(errors);
-        }
+        // throws on composition errors
+        const { schema, queryPlanner } = getFederatedTestingSchema();
 
         const givenQuery = () => {
           given(/^query$/im, (operation: string) => {
-            query = gql(operation)
-          })
-        }
-
-        const whenUsingAutoFragmentization = () => {
-          when(/using autofragmentization/i, () => {
-            options = { autoFragmentization: true };
+            operationDocument = gql(operation);
           })
         }
 
         const thenQueryPlanShouldBe = () => {
           then(/^query plan$/i, (expectedQueryPlan: string) => {
-            queryPlan = buildQueryPlan(
-              buildOperationContext(schema, query, undefined),
-              options
-            );
+            queryPlan = queryPlanner.buildQueryPlan(operationFromDocument(schema, operationDocument));
 
-            const serializedPlan = JSON.parse(JSON.stringify(queryPlan, serializeQueryPlanNode));
             const parsedExpectedPlan = JSON.parse(expectedQueryPlan);
 
-            expect(serializedPlan).toEqual(parsedExpectedPlan);
+            expect(queryPlan).toEqual(parsedExpectedPlan);
           })
         }
 
@@ -61,7 +46,6 @@ features.forEach((feature) => {
         scenario.steps.forEach(({ stepText }) => {
           const title = stepText.toLocaleLowerCase();
           if (title === "query") givenQuery();
-          else if (title === "using autofragmentization") whenUsingAutoFragmentization();
           else if (title === "query plan") thenQueryPlanShouldBe();
           else throw new Error(`Unrecognized steps used in "build-query-plan.feature"`);
         });
@@ -69,37 +53,3 @@ features.forEach((feature) => {
     });
   });
 });
-
-const serializeQueryPlanNode = (k: string , v: any) => {
-  switch(k){
-    case "selectionSet":
-    case "internalFragments":
-    case "loc":
-    case "arguments":
-    case "directives":
-    case "source":
-      return undefined;
-    case "kind":
-      if(v === Kind.SELECTION_SET) return undefined;
-      return v;
-    case "variableUsages":
-      // TODO check this
-      return Object.keys(v);
-    case "typeCondition":
-      return v.name.value;
-    case "name":
-      return v.value;
-    case "requires":
-      return v?.selections;
-    default:
-      // replace source with operation
-      if(v?.kind === "Fetch"){
-        return { ...v, operation: v.source };
-      }
-      // replace selectionSet with selections[]
-      if(v?.kind === Kind.INLINE_FRAGMENT){
-        return { ...v, selections: v.selectionSet.selections }
-      }
-      return v;
-  }
-}

package/src/__tests__/testSetup.ts

@@ -1,4 +1 @@
-import './matchers/toMatchAST';
-import './matchers/toCallService';
-import './matchers/toHaveBeenCalledBefore';
-import './matchers/toHaveFetched';
+import 'apollo-federation-integration-testsuite/dist/matchers';

package/src/__tests__/tsconfig.json

@@ -1,7 +1,8 @@
 {
-  "extends": "../../../../tsconfig.test.base",
+  "extends": "../../tsconfig.test",
   "include": ["**/*"],
   "references": [
     { "path": "../../" },
+    { "path": "../../../federation-integration-testsuite-js" },
   ]
 }

package/src/config.ts

@@ -0,0 +1,225 @@
+import { GraphQLError, GraphQLSchema } from "graphql";
+import { HeadersInit } from "node-fetch";
+import { fetch } from 'apollo-server-env';
+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'>;
+
+export type Experimental_DidResolveQueryPlanCallback = ({
+  queryPlan,
+  serviceMap,
+  operationContext,
+  requestContext,
+}: {
+  readonly queryPlan: QueryPlan;
+  readonly serviceMap: ServiceMap;
+  readonly operationContext: OperationContext;
+  readonly requestContext: GraphQLRequestContextExecutionDidStart<
+    Record<string, any>
+  >;
+}) => void;
+
+interface ImplementingServiceLocation {
+  name: string;
+  path: string;
+}
+
+export interface CompositionMetadata {
+  formatVersion: number;
+  id: string;
+  implementingServiceLocations: ImplementingServiceLocation[];
+  schemaHash: string;
+}
+
+export type Experimental_DidFailCompositionCallback = ({
+  errors,
+  serviceList,
+  compositionMetadata,
+}: {
+  readonly errors: GraphQLError[];
+  readonly serviceList: ServiceDefinition[];
+  readonly compositionMetadata?: CompositionMetadata;
+}) => void;
+
+export interface ServiceDefinitionCompositionInfo {
+  serviceDefinitions: ServiceDefinition[];
+  schema: GraphQLSchema;
+  compositionMetadata?: CompositionMetadata;
+}
+
+export interface SupergraphSdlCompositionInfo {
+  schema: GraphQLSchema;
+  compositionId: string;
+  supergraphSdl: string;
+}
+
+export type CompositionInfo =
+  | ServiceDefinitionCompositionInfo
+  | SupergraphSdlCompositionInfo;
+
+export type Experimental_DidUpdateCompositionCallback = (
+  currentConfig: CompositionInfo,
+  previousConfig?: CompositionInfo,
+) => void;
+
+export type CompositionUpdate = ServiceDefinitionUpdate | SupergraphSdlUpdate;
+
+export interface ServiceDefinitionUpdate {
+  serviceDefinitions?: ServiceDefinition[];
+  compositionMetadata?: CompositionMetadata;
+  isNewSchema: boolean;
+}
+
+export interface SupergraphSdlUpdate {
+  id: string;
+  supergraphSdl: string;
+}
+
+export function isSupergraphSdlUpdate(update: CompositionUpdate): update is SupergraphSdlUpdate {
+  return 'supergraphSdl' in update;
+}
+
+export function isServiceDefinitionUpdate(
+  update: CompositionUpdate,
+): update is ServiceDefinitionUpdate {
+  return 'isNewSchema' in update;
+}
+
+/**
+ * **Note:** It's possible for a schema to be the same (`isNewSchema: false`) when
+ * `serviceDefinitions` have changed. For example, during type migration, the
+ * composed schema may be identical but the `serviceDefinitions` would differ
+ * since a type has moved from one service to another.
+ */
+export type Experimental_UpdateServiceDefinitions = (
+  config: DynamicGatewayConfig,
+) => Promise<ServiceDefinitionUpdate>;
+
+export type Experimental_UpdateSupergraphSdl = (
+  config: DynamicGatewayConfig,
+) => Promise<SupergraphSdlUpdate>;
+
+export type Experimental_UpdateComposition = (
+  config: DynamicGatewayConfig,
+) => Promise<CompositionUpdate>;
+
+interface GatewayConfigBase {
+  debug?: boolean;
+  logger?: Logger;
+  // TODO: expose the query plan in a more flexible JSON format in the future
+  // and remove this config option in favor of `exposeQueryPlan`. Playground
+  // should cutover to use the new option when it's built.
+  __exposeQueryPlanExperimental?: boolean;
+  buildService?: (definition: ServiceEndpointDefinition) => GraphQLDataSource;
+
+  // experimental observability callbacks
+  experimental_didResolveQueryPlan?: Experimental_DidResolveQueryPlanCallback;
+  experimental_didFailComposition?: Experimental_DidFailCompositionCallback;
+  experimental_didUpdateComposition?: Experimental_DidUpdateCompositionCallback;
+  experimental_pollInterval?: number;
+  experimental_approximateQueryPlanStoreMiB?: number;
+  experimental_autoFragmentization?: boolean;
+  fetcher?: typeof fetch;
+  serviceHealthCheck?: boolean;
+}
+
+export interface RemoteGatewayConfig extends GatewayConfigBase {
+  serviceList: ServiceEndpointDefinition[];
+  introspectionHeaders?:
+    | HeadersInit
+    | ((service: ServiceEndpointDefinition) => Promise<HeadersInit> | HeadersInit);
+}
+
+export interface ManagedGatewayConfig extends GatewayConfigBase {
+  /**
+   * This configuration option shouldn't be used unless by recommendation from
+   * Apollo staff.
+   */
+  schemaConfigDeliveryEndpoint?: string;
+}
+
+interface ManuallyManagedServiceDefsGatewayConfig extends GatewayConfigBase {
+  experimental_updateServiceDefinitions: Experimental_UpdateServiceDefinitions;
+}
+
+interface ManuallyManagedSupergraphSdlGatewayConfig extends GatewayConfigBase {
+  experimental_updateSupergraphSdl: Experimental_UpdateSupergraphSdl
+}
+
+type ManuallyManagedGatewayConfig =
+  | ManuallyManagedServiceDefsGatewayConfig
+  | ManuallyManagedSupergraphSdlGatewayConfig;
+
+interface LocalGatewayConfig extends GatewayConfigBase {
+  localServiceList: ServiceDefinition[];
+}
+
+interface SupergraphSdlGatewayConfig extends GatewayConfigBase {
+  supergraphSdl: string;
+}
+
+export type StaticGatewayConfig = LocalGatewayConfig | SupergraphSdlGatewayConfig;
+
+type DynamicGatewayConfig =
+| ManagedGatewayConfig
+| RemoteGatewayConfig
+| ManuallyManagedGatewayConfig;
+
+export type GatewayConfig = StaticGatewayConfig | DynamicGatewayConfig;
+
+export function isLocalConfig(config: GatewayConfig): config is LocalGatewayConfig {
+  return 'localServiceList' in config;
+}
+
+export function isRemoteConfig(config: GatewayConfig): config is RemoteGatewayConfig {
+  return 'serviceList' in config;
+}
+
+export function isSupergraphSdlConfig(config: GatewayConfig): config is SupergraphSdlGatewayConfig {
+  return 'supergraphSdl' in config;
+}
+
+// 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 ManuallyManagedGatewayConfig {
+  return (
+    'experimental_updateServiceDefinitions' in config ||
+    'experimental_updateSupergraphSdl' in config
+  );
+}
+
+// Managed config strictly means managed by Studio
+export function isManagedConfig(
+  config: GatewayConfig,
+): config is ManagedGatewayConfig {
+  return (
+    'schemaConfigDeliveryEndpoint' in config ||
+    (!isRemoteConfig(config) &&
+      !isLocalConfig(config) &&
+      !isSupergraphSdlConfig(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(
+  config: GatewayConfig,
+): config is DynamicGatewayConfig {
+  return (
+    isRemoteConfig(config) ||
+    isManagedConfig(config) ||
+    isManuallyManagedConfig(config)
+  );
+}