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

package/src/make-fetch-happen.d.ts

@@ -36,7 +36,7 @@ declare module 'make-fetch-happen' {
   }
 
   export interface CacheManager {
-    delete(req: Request): Promise<Boolean>;
+    delete(req: Request): Promise<boolean>;
     put(req: Request, res: Response): Promise<Response>;
     match(req: Request): Promise<Response | undefined>;
   }

package/src/operationContext.ts

@@ -20,7 +20,7 @@ interface BuildOperationContextOptions {
   schema: GraphQLSchema;
   operationDocument: DocumentNode;
   operationName?: string;
-};
+}
 
 export function buildOperationContext({
   schema,
@@ -28,7 +28,7 @@ export function buildOperationContext({
   operationName,
 }: BuildOperationContextOptions): OperationContext {
   let operation: OperationDefinitionNode | undefined;
-  let operationCount: number = 0;
+  let operationCount = 0;
   const fragments: {
     [fragmentName: string]: FragmentDefinitionNode;
   } = Object.create(null);

package/src/schema-helper/addResolversToSchema.ts

@@ -0,0 +1,83 @@
+import {
+  GraphQLSchema,
+  isObjectType,
+  GraphQLEnumType,
+  isAbstractType,
+  isScalarType,
+  isEnumType,
+  GraphQLEnumValueConfig,
+} from 'graphql';
+
+import { GraphQLResolverMap } from './resolverMap';
+
+export function addResolversToSchema(
+  schema: GraphQLSchema,
+  resolvers: GraphQLResolverMap<any>
+) {
+  for (const [typeName, fieldConfigs] of Object.entries(resolvers)) {
+    const type = schema.getType(typeName);
+
+    if (isAbstractType(type)) {
+      for (const [fieldName, fieldConfig] of Object.entries(fieldConfigs)) {
+        if (fieldName.startsWith("__")) {
+          (type as any)[fieldName.substring(2)] = fieldConfig;
+        }
+      }
+    }
+
+    if (isScalarType(type)) {
+      for (const fn in fieldConfigs) {
+        (type as any)[fn] = (fieldConfigs as any)[fn];
+      }
+    }
+
+    if (isEnumType(type)) {
+      const values = type.getValues();
+      const newValues: { [key: string]: GraphQLEnumValueConfig } = {};
+      values.forEach(value => {
+        let newValue = (fieldConfigs as any)[value.name];
+        if (newValue === undefined) {
+          newValue = value.name;
+        }
+
+        newValues[value.name] = {
+          value: newValue,
+          deprecationReason: value.deprecationReason,
+          description: value.description,
+          astNode: value.astNode,
+          extensions: undefined
+        };
+      });
+
+      // In place updating hack to get around pulling in the full
+      // schema walking and immutable updating machinery from graphql-tools
+      Object.assign(
+        type,
+        new GraphQLEnumType({
+          ...type.toConfig(),
+          values: newValues
+        })
+      );
+    }
+
+    if (!isObjectType(type)) continue;
+
+    const fieldMap = type.getFields();
+
+    for (const [fieldName, fieldConfig] of Object.entries(fieldConfigs)) {
+      if (fieldName.startsWith("__")) {
+        (type as any)[fieldName.substring(2)] = fieldConfig;
+        continue;
+      }
+
+      const field = fieldMap[fieldName];
+      if (!field) continue;
+
+      if (typeof fieldConfig === "function") {
+        field.resolve = fieldConfig;
+      } else {
+        field.resolve = fieldConfig.resolve;
+      }
+    }
+  }
+}

package/src/schema-helper/error.ts

@@ -0,0 +1,11 @@
+import { GraphQLError } from "graphql";
+
+export class GraphQLSchemaValidationError extends Error {
+  constructor(public errors: ReadonlyArray<GraphQLError>) {
+    super();
+
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+    this.message = errors.map(error => error.message).join("\n\n");
+  }
+}

package/src/schema-helper/index.ts

@@ -0,0 +1,3 @@
+export * from './resolverMap';
+export * from './addResolversToSchema';
+export * from './error';

package/src/schema-helper/resolverMap.ts

@@ -0,0 +1,23 @@
+import { GraphQLFieldResolver, GraphQLScalarType, DocumentNode } from 'graphql';
+
+export interface GraphQLSchemaModule {
+  typeDefs: DocumentNode;
+  resolvers?: GraphQLResolverMap<any>;
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export interface GraphQLResolverMap<TContext = {}> {
+  [typeName: string]:
+    | {
+        [fieldName: string]:
+          | GraphQLFieldResolver<any, TContext>
+          | {
+              requires?: string;
+              resolve: GraphQLFieldResolver<any, TContext>;
+            };
+      }
+    | GraphQLScalarType
+    | {
+        [enumValue: string]: string | number;
+      };
+}

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 () => ({})
@@ -19,7 +19,7 @@ describe('getServiceDefinitionsFromRemoteEndpoint', () => {
 
   it('throws when the downstream service returns errors', async () => {
     const serviceSdlCache = new Map<string, string>();
-    const host = 'http://host-which-better-not-resolve';
+    const host = 'http://host-which-better-not-resolve.invalid';
     const url = host + '/graphql';
 
     const dataSource = new RemoteGraphQLDataSource({ url });
@@ -28,13 +28,13 @@ describe('getServiceDefinitionsFromRemoteEndpoint', () => {
     // of `EAI_AGAIN` or `ENOTFOUND`.  This `toThrowError` uses a Regex
     // to match either case.
     await expect(
-      getServiceDefinitionsFromRemoteEndpoint({
+      loadServicesFromRemoteEndpoint({
         serviceList,
         serviceSdlCache,
         getServiceIntrospectionHeaders: async () => ({}),
       }),
     ).rejects.toThrowError(
-      /^Couldn't load service definitions for "test" at http:\/\/host-which-better-not-resolve\/graphql: request to http:\/\/host-which-better-not-resolve\/graphql failed, reason: getaddrinfo (ENOTFOUND|EAI_AGAIN)/,
+      /^Couldn't load service definitions for "test" at http:\/\/host-which-better-not-resolve.invalid\/graphql: request to http:\/\/host-which-better-not-resolve.invalid\/graphql failed, reason: getaddrinfo (ENOTFOUND|EAI_AGAIN)/,
     );
   });
 });

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

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