@apollo/gateway 0.45.1 → 0.46.0-alpha.0

package/src/supergraphManagers/IntrospectAndCompose/__tests__/IntrospectAndCompose.test.ts

@@ -0,0 +1,370 @@
+import nock from 'nock';
+import {
+  fixtures,
+  fixturesWithUpdate,
+} from 'apollo-federation-integration-testsuite';
+import { nockBeforeEach, nockAfterEach } from '../../../__tests__/nockAssertions';
+import { RemoteGraphQLDataSource, ServiceEndpointDefinition } from '../../..';
+import { IntrospectAndCompose } from '..';
+import { mockAllServicesSdlQuerySuccess } from '../../../__tests__/integration/nockMocks';
+import { getTestingSupergraphSdl, wait } from '../../../__tests__/execution-utils';
+import resolvable from '@josephg/resolvable';
+import { Logger } from 'apollo-server-types';
+
+describe('IntrospectAndCompose', () => {
+  beforeEach(nockBeforeEach);
+  afterEach(nockAfterEach);
+
+  it('constructs', () => {
+    expect(
+      () =>
+        new IntrospectAndCompose({
+          subgraphs: fixtures,
+        }),
+    ).not.toThrow();
+  });
+
+  it('has an `initialize` property which is callable (simulating the gateway calling it)', async () => {
+    mockAllServicesSdlQuerySuccess();
+    const instance = new IntrospectAndCompose({ subgraphs: fixtures });
+    await expect(
+      instance.initialize({
+        update() {},
+        async healthCheck() {},
+        getDataSource({ url }) {
+          return new RemoteGraphQLDataSource({ url });
+        },
+      }),
+    ).resolves.toBeTruthy();
+  });
+
+  it('uses `GraphQLDataSource`s provided by the `buildService` function', async () => {
+    mockAllServicesSdlQuerySuccess();
+
+    const processSpies: jest.SpyInstance[] = [];
+    function getDataSourceSpy(definition: ServiceEndpointDefinition) {
+      const datasource = new RemoteGraphQLDataSource({
+        url: definition.url,
+      });
+      const processSpy = jest.spyOn(datasource, 'process');
+      processSpies.push(processSpy);
+      return datasource;
+    }
+
+    const instance = new IntrospectAndCompose({
+      subgraphs: fixtures,
+    });
+
+    await instance.initialize({
+      update() {},
+      async healthCheck() {},
+      getDataSource: getDataSourceSpy,
+    });
+
+    expect(processSpies.length).toBe(fixtures.length);
+    for (const processSpy of processSpies) {
+      expect(processSpy).toHaveBeenCalledTimes(1);
+    }
+  });
+
+  it('polls services when a `pollInterval` is set and stops when `cleanup` is called', async () => {
+    // This is mocked 4 times to include the initial load (followed by 3 polls)
+    // We need to alternate schemas, else the update will be ignored
+    mockAllServicesSdlQuerySuccess();
+    mockAllServicesSdlQuerySuccess(fixturesWithUpdate);
+    mockAllServicesSdlQuerySuccess();
+    mockAllServicesSdlQuerySuccess(fixturesWithUpdate);
+
+    const p1 = resolvable();
+    const p2 = resolvable();
+    const p3 = resolvable();
+
+    // `update` (below) is called each time we poll (and there's an update to
+    // the supergraph), so this is a reasonable hook into "when" the poll
+    // happens and drives this test cleanly with `Promise`s.
+    const updateSpy = jest
+      .fn()
+      .mockImplementationOnce(() => p1.resolve())
+      .mockImplementationOnce(() => p2.resolve())
+      .mockImplementationOnce(() => p3.resolve());
+
+    const instance = new IntrospectAndCompose({
+      subgraphs: fixtures,
+      pollIntervalInMs: 10,
+    });
+
+    const { cleanup } = await instance.initialize({
+      update(supergraphSdl) {
+        updateSpy(supergraphSdl);
+      },
+      async healthCheck() {},
+      getDataSource({ url }) {
+        return new RemoteGraphQLDataSource({ url });
+      },
+    });
+
+    await Promise.all([p1, p2, p3]);
+
+    expect(updateSpy).toHaveBeenCalledTimes(3);
+
+    // stop polling
+    await cleanup!();
+
+    expect(updateSpy).toHaveBeenCalledTimes(3);
+
+    // ensure we cancelled the timer
+    // @ts-ignore
+    expect(instance.timerRef).toBe(null);
+  });
+
+  // TODO: useFakeTimers (though I'm struggling to get this to work as expected)
+  it("doesn't call `update` when there's no change to the supergraph", async () => {
+    const fetcher =
+      jest.requireActual<typeof import('apollo-server-env')>(
+        'apollo-server-env',
+      ).fetch;
+
+    // mock for initial load and a few polls against an unchanging schema
+    mockAllServicesSdlQuerySuccess();
+    mockAllServicesSdlQuerySuccess();
+    mockAllServicesSdlQuerySuccess();
+    mockAllServicesSdlQuerySuccess();
+
+    const instance = new IntrospectAndCompose({
+      subgraphs: fixtures,
+      pollIntervalInMs: 100,
+    });
+
+    const updateSpy = jest.fn();
+    const { cleanup } = await instance.initialize({
+      update(supergraphSdl) {
+        updateSpy(supergraphSdl);
+      },
+      async healthCheck() {},
+      getDataSource({ url }) {
+        return new RemoteGraphQLDataSource({
+          url,
+          fetcher,
+        });
+      },
+    });
+
+    // let the instance poll through all the active mocks
+    // wouldn't need to do this if I could get fakeTimers working as expected
+    while (nock.activeMocks().length > 0) {
+      await wait(0);
+    }
+
+    await cleanup!();
+
+    expect(updateSpy).not.toHaveBeenCalled();
+  });
+
+  it('issues subgraph health checks when enabled (and polling)', async () => {
+    mockAllServicesSdlQuerySuccess();
+    mockAllServicesSdlQuerySuccess(fixturesWithUpdate);
+
+    const healthCheckPromiseOnLoad = resolvable();
+    const healthCheckPromiseOnUpdate = resolvable();
+
+    const healthCheckSpy = jest
+      .fn()
+      .mockImplementationOnce(() => healthCheckPromiseOnLoad.resolve())
+      .mockImplementationOnce(() => healthCheckPromiseOnUpdate.resolve());
+
+    const instance = new IntrospectAndCompose({
+      subgraphs: fixtures,
+      pollIntervalInMs: 10,
+      subgraphHealthCheck: true,
+    });
+
+    const { cleanup } = await instance.initialize({
+      update() {},
+      async healthCheck(supergraphSdl) {
+        healthCheckSpy(supergraphSdl);
+      },
+      getDataSource({ url }) {
+        return new RemoteGraphQLDataSource({ url });
+      },
+    });
+
+    await Promise.all([
+      healthCheckPromiseOnLoad,
+      healthCheckPromiseOnUpdate,
+    ]);
+
+    expect(healthCheckSpy).toHaveBeenNthCalledWith(
+      1,
+      getTestingSupergraphSdl(fixtures),
+    );
+    expect(healthCheckSpy).toHaveBeenNthCalledWith(
+      2,
+      getTestingSupergraphSdl(fixturesWithUpdate),
+    );
+
+    // stop polling
+    await cleanup!();
+  });
+
+  describe('errors', () => {
+    it('logs an error when `update` function throws', async () => {
+      const errorLoggedPromise = resolvable();
+
+      const errorSpy = jest.fn(() => {
+        errorLoggedPromise.resolve();
+      });
+      const logger: Logger = {
+        error: errorSpy,
+        debug() {},
+        info() {},
+        warn() {},
+      };
+
+      // mock successful initial load
+      mockAllServicesSdlQuerySuccess();
+
+      // mock first update
+      mockAllServicesSdlQuerySuccess(fixturesWithUpdate);
+
+      const instance = new IntrospectAndCompose({
+        subgraphs: fixtures,
+        pollIntervalInMs: 1000,
+        logger,
+      });
+
+      const thrownErrorMessage = 'invalid supergraph';
+      // simulate gateway throwing an error when `update` is called
+      const updateSpy = jest.fn().mockImplementationOnce(() => {
+        throw new Error(thrownErrorMessage);
+      });
+
+      const { cleanup } = await instance.initialize({
+        update: updateSpy,
+        async healthCheck() {},
+        getDataSource({ url }) {
+          return new RemoteGraphQLDataSource({ url });
+        },
+      });
+
+      await errorLoggedPromise;
+      // stop polling
+      await cleanup!();
+
+      expect(updateSpy).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledWith(
+        `IntrospectAndCompose failed to update supergraph with the following error: ${thrownErrorMessage}`,
+      );
+    });
+
+    it('fails to load when `healthCheck` function throws on startup', async () => {
+      mockAllServicesSdlQuerySuccess();
+
+      const expectedErrorMsg = 'error reaching subgraph';
+      const errorLoggedPromise = resolvable();
+      const errorSpy = jest.fn(() => {
+        errorLoggedPromise.resolve();
+      });
+      const logger: Logger = {
+        error: errorSpy,
+        debug() {},
+        info() {},
+        warn() {},
+      };
+
+      const updateSpy = jest.fn();
+
+      const instance = new IntrospectAndCompose({
+        subgraphs: fixtures,
+        pollIntervalInMs: 10,
+        subgraphHealthCheck: true,
+        logger,
+      });
+
+      await expect(
+        instance.initialize({
+          update() {
+            updateSpy();
+          },
+          async healthCheck() {
+            throw new Error(expectedErrorMsg);
+          },
+          getDataSource({ url }) {
+            return new RemoteGraphQLDataSource({ url });
+          },
+        }),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(`"error reaching subgraph"`);
+
+      await errorLoggedPromise;
+
+      expect(errorSpy).toHaveBeenCalledWith(
+        `IntrospectAndCompose failed to update supergraph with the following error: ${expectedErrorMsg}`,
+      );
+      expect(updateSpy).not.toHaveBeenCalled();
+    });
+
+    it('does not attempt to update when `healthCheck` function throws', async () => {
+      mockAllServicesSdlQuerySuccess();
+      mockAllServicesSdlQuerySuccess(fixturesWithUpdate);
+
+      const expectedErrorMsg = 'error reaching subgraph';
+      const errorLoggedPromise = resolvable();
+      const errorSpy = jest.fn(() => {
+        errorLoggedPromise.resolve();
+      });
+      const logger: Logger = {
+        error: errorSpy,
+        debug() {},
+        info() {},
+        warn() {},
+      };
+
+      const healthCheckPromiseOnLoad = resolvable();
+      const healthCheckPromiseOnUpdate = resolvable();
+      const healthCheckSpyWhichEventuallyThrows = jest
+        .fn()
+        .mockImplementationOnce(() => healthCheckPromiseOnLoad.resolve())
+        .mockImplementationOnce(() => {
+          healthCheckPromiseOnUpdate.resolve();
+          throw new Error(expectedErrorMsg);
+        });
+
+      const updateSpy = jest.fn();
+
+      const instance = new IntrospectAndCompose({
+        subgraphs: fixtures,
+        pollIntervalInMs: 10,
+        subgraphHealthCheck: true,
+        logger,
+      });
+
+      const { cleanup } = await instance.initialize({
+        update() {
+          updateSpy();
+        },
+        async healthCheck(supergraphSdl) {
+          healthCheckSpyWhichEventuallyThrows(supergraphSdl);
+        },
+        getDataSource({ url }) {
+          return new RemoteGraphQLDataSource({ url });
+        },
+      });
+
+      await Promise.all([
+        healthCheckPromiseOnLoad,
+        healthCheckPromiseOnUpdate,
+        errorLoggedPromise,
+      ]);
+
+      expect(errorSpy).toHaveBeenCalledWith(
+        `IntrospectAndCompose failed to update supergraph with the following error: ${expectedErrorMsg}`,
+      );
+      expect(healthCheckSpyWhichEventuallyThrows).toHaveBeenCalledTimes(2);
+      // update isn't called on load so this shouldn't be called even once
+      expect(updateSpy).not.toHaveBeenCalled();
+
+      // stop polling
+      await cleanup!();
+    });
+  });
+});

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

@@ -1,13 +1,13 @@
-import { getServiceDefinitionsFromRemoteEndpoint } from '../loadServicesFromRemoteEndpoint';
-import { RemoteGraphQLDataSource } from '../datasources';
+import { loadServicesFromRemoteEndpoint } from '../loadServicesFromRemoteEndpoint';
+import { RemoteGraphQLDataSource } from '../../../datasources';
 
-describe('getServiceDefinitionsFromRemoteEndpoint', () => {
+describe('loadServicesFromRemoteEndpoint', () => {
   it('errors when no URL was specified', async () => {
     const serviceSdlCache = new Map<string, string>();
     const dataSource = new RemoteGraphQLDataSource({ url: '' });
     const serviceList = [{ name: 'test', dataSource }];
     await expect(
-      getServiceDefinitionsFromRemoteEndpoint({
+      loadServicesFromRemoteEndpoint({
         serviceList,
         serviceSdlCache,
         getServiceIntrospectionHeaders: async () => ({})
@@ -28,7 +28,7 @@ describe('getServiceDefinitionsFromRemoteEndpoint', () => {
     // of `EAI_AGAIN` or `ENOTFOUND`.  This `toThrowError` uses a Regex
     // to match either case.
     await expect(
-      getServiceDefinitionsFromRemoteEndpoint({
+      loadServicesFromRemoteEndpoint({
         serviceList,
         serviceSdlCache,
         getServiceIntrospectionHeaders: async () => ({}),

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

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

package/src/supergraphManagers/IntrospectAndCompose/index.ts

@@ -0,0 +1,163 @@
+import {
+  composeAndValidate,
+  compositionHasErrors,
+  ServiceDefinition,
+} from '@apollo/federation';
+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';
+
+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 = composeAndValidate(subgraphs);
+
+    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;
+      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 { 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',