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

package/src/supergraphManagers/IntrospectAndCompose/index.ts

@@ -0,0 +1,160 @@
+import { Logger } from 'apollo-server-types';
+import { HeadersInit } from 'node-fetch';
+import resolvable from '@josephg/resolvable';
+import {
+  ServiceEndpointDefinition,
+  SupergraphSdlUpdateFunction,
+  SubgraphHealthCheckFunction,
+} from '../..';
+import {
+  loadServicesFromRemoteEndpoint,
+  Service,
+} from './loadServicesFromRemoteEndpoint';
+import { SupergraphManager, SupergraphSdlHookOptions } from '../../config';
+import { composeServices } from '@apollo/composition';
+import { ServiceDefinition } from '@apollo/federation-internals';
+
+export interface IntrospectAndComposeOptions {
+  subgraphs: ServiceEndpointDefinition[];
+  introspectionHeaders?:
+    | HeadersInit
+    | ((
+        service: ServiceEndpointDefinition,
+      ) => Promise<HeadersInit> | HeadersInit);
+  pollIntervalInMs?: number;
+  logger?: Logger;
+  subgraphHealthCheck?: boolean;
+}
+
+type State =
+  | { phase: 'initialized' }
+  | { phase: 'polling'; pollingPromise?: Promise<void> }
+  | { phase: 'stopped' };
+
+export class IntrospectAndCompose implements SupergraphManager {
+  private config: IntrospectAndComposeOptions;
+  private update?: SupergraphSdlUpdateFunction;
+  private healthCheck?: SubgraphHealthCheckFunction;
+  private subgraphs?: Service[];
+  private serviceSdlCache: Map<string, string> = new Map();
+  private timerRef: NodeJS.Timeout | null = null;
+  private state: State;
+
+  constructor(options: IntrospectAndComposeOptions) {
+    this.config = options;
+    this.state = { phase: 'initialized' };
+  }
+
+  public async initialize({ update, getDataSource, healthCheck }: SupergraphSdlHookOptions) {
+    this.update = update;
+
+    if (this.config.subgraphHealthCheck) {
+      this.healthCheck = healthCheck;
+    }
+
+    this.subgraphs = this.config.subgraphs.map((subgraph) => ({
+      ...subgraph,
+      dataSource: getDataSource(subgraph),
+    }));
+
+    let initialSupergraphSdl: string | null = null;
+    try {
+      initialSupergraphSdl = await this.updateSupergraphSdl();
+    } catch (e) {
+      this.logUpdateFailure(e);
+      throw e;
+    }
+
+    // Start polling after we resolve the first supergraph
+    if (this.config.pollIntervalInMs) {
+      this.beginPolling();
+    }
+
+    return {
+      // on init, this supergraphSdl should never actually be `null`.
+      // `this.updateSupergraphSdl()` will only return null if the schema hasn't
+      // changed over the course of an _update_.
+      supergraphSdl: initialSupergraphSdl!,
+      cleanup: async () => {
+        if (this.state.phase === 'polling') {
+          await this.state.pollingPromise;
+        }
+        this.state = { phase: 'stopped' };
+        if (this.timerRef) {
+          clearTimeout(this.timerRef);
+          this.timerRef = null;
+        }
+      },
+    };
+  }
+
+  private async updateSupergraphSdl() {
+    const result = await loadServicesFromRemoteEndpoint({
+      serviceList: this.subgraphs!,
+      getServiceIntrospectionHeaders: async (service) => {
+        return typeof this.config.introspectionHeaders === 'function'
+          ? await this.config.introspectionHeaders(service)
+          : this.config.introspectionHeaders;
+      },
+      serviceSdlCache: this.serviceSdlCache,
+    });
+
+    if (!result.isNewSchema) {
+      return null;
+    }
+
+    const supergraphSdl = this.createSupergraphFromSubgraphList(result.serviceDefinitions!);
+    // the healthCheck fn is only assigned if it's enabled in the config
+    await this.healthCheck?.(supergraphSdl);
+
+    return supergraphSdl;
+  }
+
+  private createSupergraphFromSubgraphList(subgraphs: ServiceDefinition[]) {
+    const compositionResult = composeServices(subgraphs);
+
+    if (compositionResult.errors) {
+      const { errors } = compositionResult;
+      throw Error(
+        "A valid schema couldn't be composed. The following composition errors were found:\n" +
+          errors.map((e) => '\t' + e.message).join('\n'),
+      );
+    } else {
+      const { supergraphSdl } = compositionResult;
+      return supergraphSdl;
+    }
+  }
+
+  private beginPolling() {
+    this.state = { phase: 'polling' };
+    this.poll();
+  }
+
+  private poll() {
+    this.timerRef = setTimeout(async () => {
+      if (this.state.phase === 'polling') {
+        const pollingPromise = resolvable();
+
+        this.state.pollingPromise = pollingPromise;
+        try {
+          const maybeNewSupergraphSdl = await this.updateSupergraphSdl();
+          if (maybeNewSupergraphSdl) {
+            this.update?.(maybeNewSupergraphSdl);
+          }
+        } catch (e) {
+          this.logUpdateFailure(e);
+        }
+        pollingPromise.resolve();
+      }
+
+      this.poll();
+    }, this.config.pollIntervalInMs!);
+  }
+
+  private logUpdateFailure(e: any) {
+    this.config.logger?.error(
+      'IntrospectAndCompose failed to update supergraph with the following error: ' +
+        (e.message ?? e),
+    );
+  }
+}

package/src/{loadServicesFromRemoteEndpoint.ts → supergraphManagers/IntrospectAndCompose/loadServicesFromRemoteEndpoint.ts}

@@ -1,16 +1,16 @@
 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 { CompositionUpdate, ServiceEndpointDefinition } from './config';
-import { ServiceDefinition } from '@apollo/federation';
+import { ServiceDefinition } from '@apollo/federation-internals';
+import { GraphQLDataSource, GraphQLDataSourceRequestKind } from '../../datasources/types';
+import { SERVICE_DEFINITION_QUERY } from '../..';
+import { ServiceDefinitionUpdate, ServiceEndpointDefinition } from '../../config';
 
-type Service = ServiceEndpointDefinition & {
+export type Service = ServiceEndpointDefinition & {
   dataSource: GraphQLDataSource;
 };
 
-export async function getServiceDefinitionsFromRemoteEndpoint({
+export async function loadServicesFromRemoteEndpoint({
   serviceList,
   getServiceIntrospectionHeaders,
   serviceSdlCache,
@@ -20,7 +20,7 @@ export async function getServiceDefinitionsFromRemoteEndpoint({
     service: ServiceEndpointDefinition,
   ) => Promise<HeadersInit | undefined>;
   serviceSdlCache: Map<string, string>;
-}): Promise<CompositionUpdate> {
+}): Promise<ServiceDefinitionUpdate> {
   if (!serviceList || !serviceList.length) {
     throw new Error(
       'Tried to load services from remote endpoints but none provided',

package/src/supergraphManagers/LegacyFetcher/index.ts

@@ -0,0 +1,226 @@
+/**
+ * Similar in concept to `IntrospectAndCompose`, but this handles
+ * the `experimental_updateComposition` and `experimental_updateSupergraphSdl`
+ * configuration options of the gateway and will be removed in a future release
+ * along with those options.
+ */
+import { Logger } from 'apollo-server-types';
+import resolvable from '@josephg/resolvable';
+import {
+  SupergraphManager,
+  SupergraphSdlHookOptions,
+  DynamicGatewayConfig,
+  isSupergraphSdlUpdate,
+  isServiceDefinitionUpdate,
+  ServiceDefinitionUpdate,
+  GetDataSourceFunction,
+} from '../../config';
+import {
+  Experimental_UpdateComposition,
+  SubgraphHealthCheckFunction,
+  SupergraphSdlUpdateFunction,
+} from '../..';
+import { composeServices } from '@apollo/composition';
+import { ServiceDefinition } from '@apollo/federation-internals';
+
+export interface LegacyFetcherOptions {
+  pollIntervalInMs?: number;
+  logger?: Logger;
+  subgraphHealthCheck?: boolean;
+  updateServiceDefinitions: Experimental_UpdateComposition;
+  gatewayConfig: DynamicGatewayConfig;
+}
+
+type State =
+  | { phase: 'initialized' }
+  | { phase: 'polling'; pollingPromise?: Promise<void> }
+  | { phase: 'stopped' };
+
+export class LegacyFetcher implements SupergraphManager {
+  private config: LegacyFetcherOptions;
+  private update?: SupergraphSdlUpdateFunction;
+  private healthCheck?: SubgraphHealthCheckFunction;
+  private getDataSource?: GetDataSourceFunction;
+  private timerRef: NodeJS.Timeout | null = null;
+  private state: State;
+  private compositionId?: string;
+  private serviceDefinitions?: ServiceDefinition[];
+
+  constructor(options: LegacyFetcherOptions) {
+    this.config = options;
+    this.state = { phase: 'initialized' };
+    this.issueDeprecationWarnings();
+  }
+
+  private issueDeprecationWarnings() {
+    if ('experimental_updateSupergraphSdl' in this.config.gatewayConfig) {
+      this.config.logger?.warn(
+        'The `experimental_updateSupergraphSdl` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to the function form of the `supergraphSdl` configuration option.',
+      );
+    }
+
+    if ('experimental_updateServiceDefinitions' in this.config.gatewayConfig) {
+      this.config.logger?.warn(
+        'The `experimental_updateServiceDefinitions` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to the function form of the `supergraphSdl` configuration option.',
+      );
+    }
+  }
+
+  public async initialize({
+    update,
+    healthCheck,
+    getDataSource,
+  }: SupergraphSdlHookOptions) {
+    this.update = update;
+    this.getDataSource = getDataSource;
+
+    if (this.config.subgraphHealthCheck) {
+      this.healthCheck = healthCheck;
+    }
+
+    let initialSupergraphSdl: string | null = null;
+    try {
+      initialSupergraphSdl = await this.updateSupergraphSdl();
+    } catch (e) {
+      this.logUpdateFailure(e);
+      throw e;
+    }
+
+    // Start polling after we resolve the first supergraph
+    if (this.config.pollIntervalInMs) {
+      this.beginPolling();
+    }
+
+    return {
+      // on init, this supergraphSdl should never actually be `null`.
+      // `this.updateSupergraphSdl()` will only return null if the schema hasn't
+      // changed over the course of an _update_.
+      supergraphSdl: initialSupergraphSdl!,
+      cleanup: async () => {
+        if (this.state.phase === 'polling') {
+          await this.state.pollingPromise;
+        }
+        this.state = { phase: 'stopped' };
+        if (this.timerRef) {
+          clearTimeout(this.timerRef);
+          this.timerRef = null;
+        }
+      },
+    };
+  }
+
+  private async updateSupergraphSdl() {
+    const result = await this.config.updateServiceDefinitions(
+      this.config.gatewayConfig,
+    );
+
+    if (isSupergraphSdlUpdate(result)) {
+      // no change
+      if (this.compositionId === result.id) return null;
+
+      await this.healthCheck?.(result.supergraphSdl);
+      this.compositionId = result.id;
+      return result.supergraphSdl;
+    } else if (isServiceDefinitionUpdate(result)) {
+      const supergraphSdl = this.updateByComposition(result);
+      if (!supergraphSdl) return null;
+      await this.healthCheck?.(supergraphSdl);
+      return supergraphSdl;
+    } else {
+      throw new Error(
+        'Programming error: unexpected result type from `updateServiceDefinitions`',
+      );
+    }
+  }
+
+  private updateByComposition(result: ServiceDefinitionUpdate) {
+    if (
+      !result.serviceDefinitions ||
+      JSON.stringify(this.serviceDefinitions) ===
+        JSON.stringify(result.serviceDefinitions)
+    ) {
+      this.config.logger?.debug(
+        'No change in service definitions since last check.',
+      );
+      return null;
+    }
+
+    if (this.serviceDefinitions) {
+      this.config.logger?.info('New service definitions were found.');
+    }
+
+    this.serviceDefinitions = result.serviceDefinitions;
+
+    const supergraphSdl = this.createSupergraphFromServiceList(
+      result.serviceDefinitions,
+    );
+
+    if (!supergraphSdl) {
+      throw new Error(
+        "A valid schema couldn't be composed. Falling back to previous schema.",
+      );
+    } else {
+      return supergraphSdl;
+    }
+  }
+
+  private createSupergraphFromServiceList(serviceList: ServiceDefinition[]) {
+    this.config.logger?.debug(
+      `Composing schema from service list: \n${serviceList
+        .map(({ name, url }) => `  ${url || 'local'}: ${name}`)
+        .join('\n')}`,
+    );
+
+    const compositionResult = composeServices(serviceList);
+
+    if (compositionResult.errors) {
+      const { errors } = compositionResult;
+      throw Error(
+        "A valid schema couldn't be composed. The following composition errors were found:\n" +
+          errors.map((e) => '\t' + e.message).join('\n'),
+      );
+    } else {
+      const { supergraphSdl } = compositionResult;
+      for (const service of serviceList) {
+        this.getDataSource?.(service);
+      }
+
+      this.config.logger?.debug('Schema loaded and ready for execution');
+
+      return supergraphSdl;
+    }
+  }
+
+  private beginPolling() {
+    this.state = { phase: 'polling' };
+    this.poll();
+  }
+
+  private poll() {
+    this.timerRef = setTimeout(async () => {
+      if (this.state.phase === 'polling') {
+        const pollingPromise = resolvable();
+
+        this.state.pollingPromise = pollingPromise;
+        try {
+          const maybeNewSupergraphSdl = await this.updateSupergraphSdl();
+          if (maybeNewSupergraphSdl) {
+            this.update?.(maybeNewSupergraphSdl);
+          }
+        } catch (e) {
+          this.logUpdateFailure(e);
+        }
+        pollingPromise.resolve();
+      }
+
+      this.poll();
+    }, this.config.pollIntervalInMs!);
+  }
+
+  private logUpdateFailure(e: any) {
+    this.config.logger?.error(
+      'UplinkFetcher failed to update supergraph with the following error: ' +
+        (e.message ?? e),
+    );
+  }
+}

package/src/supergraphManagers/LocalCompose/index.ts

@@ -0,0 +1,79 @@
+// TODO(trevor:removeServiceList) the whole file goes away
+import { Logger } from 'apollo-server-types';
+import { composeServices } from '@apollo/composition';
+import {
+  GetDataSourceFunction,
+  SupergraphSdlHookOptions,
+  SupergraphManager,
+} from '../../config';
+import { ServiceDefinition } from '@apollo/federation-internals';
+
+export interface LocalComposeOptions {
+  logger?: Logger;
+  localServiceList: ServiceDefinition[];
+}
+
+export class LocalCompose implements SupergraphManager {
+  private config: LocalComposeOptions;
+  private getDataSource?: GetDataSourceFunction;
+
+  constructor(options: LocalComposeOptions) {
+    this.config = options;
+    this.issueDeprecationWarnings();
+  }
+
+  private issueDeprecationWarnings() {
+    this.config.logger?.warn(
+      'The `localServiceList` option is deprecated and will be removed in a future version of `@apollo/gateway`. Please migrate to the `LocalCompose` supergraph manager exported by `@apollo/gateway`.',
+    );
+  }
+
+  public async initialize({ getDataSource }: SupergraphSdlHookOptions) {
+    this.getDataSource = getDataSource;
+    let supergraphSdl: string | null = null;
+    try {
+      supergraphSdl = this.createSupergraphFromServiceList(
+        this.config.localServiceList,
+      );
+    } catch (e) {
+      this.logUpdateFailure(e);
+      throw e;
+    }
+    return {
+      supergraphSdl,
+    };
+  }
+
+  private createSupergraphFromServiceList(serviceList: ServiceDefinition[]) {
+    this.config.logger?.debug(
+      `Composing schema from service list: \n${serviceList
+        .map(({ name, url }) => `  ${url || 'local'}: ${name}`)
+        .join('\n')}`,
+    );
+
+    const compositionResult = composeServices(serviceList);
+    const errors = compositionResult.errors;
+    if (errors) {
+      throw Error(
+        "A valid schema couldn't be composed. The following composition errors were found:\n" +
+          errors.map((e) => '\t' + e.message).join('\n'),
+      );
+    } else {
+      const { supergraphSdl } = compositionResult;
+      for (const service of serviceList) {
+        this.getDataSource?.(service);
+      }
+
+      this.config.logger?.debug('Schema loaded and ready for execution');
+
+      return supergraphSdl;
+    }
+  }
+
+  private logUpdateFailure(e: any) {
+    this.config.logger?.error(
+      'UplinkFetcher failed to update supergraph with the following error: ' +
+        (e.message ?? e),
+    );
+  }
+}