@apollo/gateway 0.45.0 → 0.47.0

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 { GraphQLDataSource, GraphQLDataSourceRequestKind } from '../../datasources/types';
+import { SERVICE_DEFINITION_QUERY } from '../..';
+import { ServiceDefinitionUpdate, ServiceEndpointDefinition } from '../../config';
 import { ServiceDefinition } from '@apollo/federation';
 
-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,229 @@
+/**
+ * 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 {
+  composeAndValidate,
+  compositionHasErrors,
+  ServiceDefinition,
+} from '@apollo/federation';
+
+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 = composeAndValidate(serviceList);
+
+    if (compositionHasErrors(compositionResult)) {
+      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,83 @@
+// TODO(trevor:removeServiceList) the whole file goes away
+import { Logger } from 'apollo-server-types';
+import {
+  composeAndValidate,
+  compositionHasErrors,
+  ServiceDefinition,
+} from '@apollo/federation';
+import {
+  GetDataSourceFunction,
+  SupergraphSdlHookOptions,
+  SupergraphManager,
+} from '../../config';
+
+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 = composeAndValidate(serviceList);
+
+    if (compositionHasErrors(compositionResult)) {
+      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 logUpdateFailure(e: any) {
+    this.config.logger?.error(
+      'UplinkFetcher failed to update supergraph with the following error: ' +
+        (e.message ?? e),
+    );
+  }
+}

package/src/{__tests__ → supergraphManagers/UplinkFetcher/__tests__}/loadSupergraphSdlFromStorage.test.ts

@@ -2,7 +2,7 @@ import {
   loadSupergraphSdlFromStorage,
   loadSupergraphSdlFromUplinks
 } from '../loadSupergraphSdlFromStorage';
-import { getDefaultFetcher } from '../..';
+import { getDefaultFetcher } from '../../..';
 import {
   graphRef,
   apiKey,
@@ -14,9 +14,9 @@ import {
   mockSupergraphSdlRequestSuccess,
   mockSupergraphSdlRequestIfAfterUnchanged,
   mockSupergraphSdlRequestIfAfter
-} from './integration/nockMocks';
-import { getTestingSupergraphSdl } from "./execution-utils";
-import { nockAfterEach, nockBeforeEach } from './nockAssertions';
+} from '../../../__tests__/integration/nockMocks';
+import { getTestingSupergraphSdl } from "../../../__tests__/execution-utils";
+import { nockAfterEach, nockBeforeEach } from '../../../__tests__/nockAssertions';
 
 describe('loadSupergraphSdlFromStorage', () => {
   beforeEach(nockBeforeEach);

package/src/supergraphManagers/UplinkFetcher/__tests__/tsconfig.json

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

package/src/supergraphManagers/UplinkFetcher/index.ts

@@ -0,0 +1,128 @@
+import { fetch } from 'apollo-server-env';
+import { Logger } from 'apollo-server-types';
+import resolvable from '@josephg/resolvable';
+import { SupergraphManager, SupergraphSdlHookOptions } from '../../config';
+import { SubgraphHealthCheckFunction, SupergraphSdlUpdateFunction } from '../..';
+import { loadSupergraphSdlFromUplinks } from './loadSupergraphSdlFromStorage';
+
+export interface UplinkFetcherOptions {
+  pollIntervalInMs: number;
+  subgraphHealthCheck?: boolean;
+  graphRef: string;
+  apiKey: string;
+  fetcher: typeof fetch;
+  maxRetries: number;
+  uplinkEndpoints: string[];
+  logger?: Logger;
+}
+
+type State =
+  | { phase: 'initialized' }
+  | { phase: 'polling'; pollingPromise?: Promise<void> }
+  | { phase: 'stopped' };
+
+export class UplinkFetcher implements SupergraphManager {
+  private config: UplinkFetcherOptions;
+  private update?: SupergraphSdlUpdateFunction;
+  private healthCheck?: SubgraphHealthCheckFunction;
+  private timerRef: NodeJS.Timeout | null = null;
+  private state: State;
+  private errorReportingEndpoint: string | undefined =
+    process.env.APOLLO_OUT_OF_BAND_REPORTER_ENDPOINT ?? undefined;
+  private compositionId?: string;
+
+  constructor(options: UplinkFetcherOptions) {
+    this.config = options;
+    this.state = { phase: 'initialized' };
+  }
+
+  public async initialize({ update, healthCheck }: SupergraphSdlHookOptions) {
+    this.update = update;
+
+    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
+    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 loadSupergraphSdlFromUplinks({
+      graphRef: this.config.graphRef,
+      apiKey: this.config.apiKey,
+      endpoints: this.config.uplinkEndpoints,
+      errorReportingEndpoint: this.errorReportingEndpoint,
+      fetcher: this.config.fetcher,
+      compositionId: this.compositionId ?? null,
+      maxRetries: this.config.maxRetries,
+    });
+
+    if (!result) {
+      return null;
+    } else {
+      this.compositionId = result.id;
+      // the healthCheck fn is only assigned if it's enabled in the config
+      await this.healthCheck?.(result.supergraphSdl);
+      return result.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/{loadSupergraphSdlFromStorage.ts → supergraphManagers/UplinkFetcher/loadSupergraphSdlFromStorage.ts}

@@ -1,8 +1,8 @@
 import { fetch, Response, Request } from 'apollo-server-env';
 import { GraphQLError } from 'graphql';
-import { SupergraphSdlUpdate } from './config';
+import { SupergraphSdlUpdate } from '../../config';
 import { submitOutOfBandReportIfConfigured } from './outOfBandReporter';
-import { SupergraphSdlQuery } from './__generated__/graphqlTypes';
+import { SupergraphSdlQuery } from '../../__generated__/graphqlTypes';
 
 // Magic /* GraphQL */ comment below is for codegen, do not remove
 export const SUPERGRAPH_SDL_QUERY = /* GraphQL */`#graphql
@@ -35,7 +35,7 @@ interface SupergraphSdlQueryFailure {
   errors: GraphQLError[];
 }
 
-const { name, version } = require('../package.json');
+const { name, version } = require('../../../package.json');
 
 const fetchErrorMsg = "An error occurred while fetching your schema from Apollo: ";
 

package/src/{outOfBandReporter.ts → supergraphManagers/UplinkFetcher/outOfBandReporter.ts}

@@ -4,7 +4,7 @@ import {
   ErrorCode,
   OobReportMutation,
   OobReportMutationVariables,
-} from './__generated__/graphqlTypes';
+} from '../../__generated__/graphqlTypes';
 
 // Magic /* GraphQL */ comment below is for codegen, do not remove
 export const OUT_OF_BAND_REPORTER_QUERY = /* GraphQL */`#graphql
@@ -13,7 +13,7 @@ export const OUT_OF_BAND_REPORTER_QUERY = /* GraphQL */`#graphql
   }
 `;
 
-const { name, version } = require('../package.json');
+const { name, version } = require('../../../package.json');
 
 type OobReportMutationResult =
   | OobReportMutationSuccess

package/src/supergraphManagers/index.ts

@@ -0,0 +1,4 @@
+export { LocalCompose } from './LocalCompose';
+export { LegacyFetcher } from './LegacyFetcher';
+export { IntrospectAndCompose } from './IntrospectAndCompose';
+export { UplinkFetcher } from './UplinkFetcher';

package/src/utilities/__tests__/cleanErrorOfInaccessibleElements.test.ts

@@ -49,16 +49,16 @@ describe('cleanErrorOfInaccessibleNames', () => {
   schema = toAPISchema(schema);
 
   it('removes inaccessible type names from error messages', async () => {
-    const result = await execute(schema, parse('{fooField{someField}}'), {
+    const result = await execute({ schema, document: parse('{fooField{someField}}'), rootValue: {
       fooField: {
         __typename: 'Bar',
         someField: 'test',
       },
-    });
+    }});
 
     const cleaned = cleanErrorOfInaccessibleNames(schema, result.errors?.[0]!);
     expect(cleaned.message).toMatchInlineSnapshot(
-      `"Abstract type \\"Foo\\" was resolve to a type [inaccessible type] that does not exist inside schema."`,
+      `"Abstract type \\"Foo\\" was resolved to a type [inaccessible type] that does not exist inside the schema."`,
     );
   });
 

package/src/utilities/createHash.ts

@@ -0,0 +1,10 @@
+import isNodeLike from './isNodeLike';
+
+export function createHash (kind: string): import('crypto').Hash {
+  if (isNodeLike) {
+    // Use module.require instead of just require to avoid bundling whatever
+    // crypto polyfills a non-Node bundler might fall back to.
+    return module.require('crypto').createHash(kind);
+  }
+  return require('sha.js')(kind);
+}

package/src/utilities/isNodeLike.ts

@@ -0,0 +1,11 @@
+export default typeof process === 'object' &&
+  process &&
+  // We used to check `process.release.name === "node"`, however that doesn't
+  // account for certain forks of Node.js which are otherwise identical to
+  // Node.js.  For example, NodeSource's N|Solid reports itself as "nsolid",
+  // though it's mostly the same build of Node.js with an extra addon.
+  process.release &&
+  process.versions &&
+  // The one thing which is present on both Node.js and N|Solid (a fork of
+  // Node.js), is `process.versions.node` being defined.
+  typeof process.versions.node === 'string';