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

package/src/__tests__/integration/legacyNetworkRequests.test.ts

@@ -1,279 +0,0 @@
-import nock from 'nock';
-import { fetch } from 'apollo-server-env';
-import { Logger } from 'apollo-server-types';
-import { ApolloGateway, GCS_RETRY_COUNT, getDefaultFetcher } from '../..';
-import {
-  mockServiceHealthCheckSuccess,
-  mockServiceHealthCheck,
-  mockStorageSecretSuccess,
-  mockStorageSecret,
-  mockCompositionConfigLinkSuccess,
-  mockCompositionConfigLink,
-  mockCompositionConfigsSuccess,
-  mockCompositionConfigs,
-  mockImplementingServicesSuccess,
-  mockImplementingServices,
-  mockRawPartialSchemaSuccess,
-  mockRawPartialSchema,
-  apiKeyHash,
-  graphId,
-} from './legacyNockMocks';
-
-export interface MockService {
-  gcsDefinitionPath: string;
-  partialSchemaPath: string;
-  url: string;
-  sdl: string;
-}
-
-const service: MockService = {
-  gcsDefinitionPath: 'service-definition.json',
-  partialSchemaPath: 'accounts-partial-schema.json',
-  url: 'http://localhost:4001',
-  sdl: `#graphql
-    extend type Query {
-      me: User
-      everyone: [User]
-    }
-    "This is my User"
-    type User @key(fields: "id") {
-      id: ID!
-      name: String
-      username: String
-    }
-  `,
-};
-
-const updatedService: MockService = {
-  gcsDefinitionPath: 'updated-service-definition.json',
-  partialSchemaPath: 'updated-accounts-partial-schema.json',
-  url: 'http://localhost:4002',
-  sdl: `#graphql
-    extend type Query {
-      me: User
-      everyone: [User]
-    }
-    "This is my updated User"
-    type User @key(fields: "id") {
-      id: ID!
-      name: String
-      username: String
-    }
-  `,
-};
-
-let fetcher: typeof fetch;
-let logger: Logger;
-let gateway: ApolloGateway | null = null;
-
-beforeEach(() => {
-  if (!nock.isActive()) nock.activate();
-
-  fetcher = getDefaultFetcher().defaults({
-    retry: {
-      retries: GCS_RETRY_COUNT,
-      minTimeout: 0,
-      maxTimeout: 0,
-    },
-  });
-
-  const warn = jest.fn();
-  const debug = jest.fn();
-  const error = jest.fn();
-  const info = jest.fn();
-
-  logger = {
-    warn,
-    debug,
-    error,
-    info,
-  };
-});
-
-afterEach(async () => {
-  expect(nock.isDone()).toBeTruthy();
-  nock.cleanAll();
-  nock.restore();
-  if (gateway) {
-    await gateway.stop();
-    gateway = null;
-  }
-});
-
-it('Extracts service definitions from remote storage', async () => {
-  mockStorageSecretSuccess();
-  mockCompositionConfigLinkSuccess();
-  mockCompositionConfigsSuccess([service]);
-  mockImplementingServicesSuccess(service);
-  mockRawPartialSchemaSuccess(service);
-
-  gateway = new ApolloGateway({ logger, schemaConfigDeliveryEndpoint: null });
-
-  await gateway.load({
-    apollo: { keyHash: apiKeyHash, graphId, graphVariant: 'current' },
-  });
-  expect(gateway.schema!.getType('User')!.description).toBe('This is my User');
-});
-
-function failNTimes(n: number, fn: () => nock.Interceptor) {
-  for (let i = 0; i < n; i++) {
-    fn().reply(500);
-  }
-}
-
-it(`Retries GCS (up to ${GCS_RETRY_COUNT} times) on failure for each request and succeeds`, async () => {
-  failNTimes(GCS_RETRY_COUNT, mockStorageSecret);
-  mockStorageSecretSuccess();
-
-  failNTimes(GCS_RETRY_COUNT, mockCompositionConfigLink);
-  mockCompositionConfigLinkSuccess();
-
-  failNTimes(GCS_RETRY_COUNT, mockCompositionConfigs);
-  mockCompositionConfigsSuccess([service]);
-
-  failNTimes(GCS_RETRY_COUNT, () => mockImplementingServices(service));
-  mockImplementingServicesSuccess(service);
-
-  failNTimes(GCS_RETRY_COUNT, () => mockRawPartialSchema(service));
-  mockRawPartialSchemaSuccess(service);
-
-  gateway = new ApolloGateway({
-    fetcher,
-    logger,
-    schemaConfigDeliveryEndpoint: null,
-  });
-
-  await gateway.load({
-    apollo: { keyHash: apiKeyHash, graphId, graphVariant: 'current' },
-  });
-  expect(gateway.schema!.getType('User')!.description).toBe('This is my User');
-});
-
-describe('Managed mode', () => {
-  it('Performs health checks to downstream services on load', async () => {
-    mockStorageSecretSuccess();
-    mockCompositionConfigLinkSuccess();
-    mockCompositionConfigsSuccess([service]);
-    mockImplementingServicesSuccess(service);
-    mockRawPartialSchemaSuccess(service);
-
-    mockServiceHealthCheckSuccess(service);
-
-    gateway = new ApolloGateway({
-      serviceHealthCheck: true,
-      logger,
-      schemaConfigDeliveryEndpoint: null,
-    });
-
-    await gateway.load({
-      apollo: { keyHash: apiKeyHash, graphId, graphVariant: 'current' },
-    });
-    expect(gateway.schema!.getType('User')!.description).toBe(
-      'This is my User',
-    );
-  });
-
-  it('Rejects on initial load when health check fails', async () => {
-    mockStorageSecretSuccess();
-    mockCompositionConfigLinkSuccess();
-    mockCompositionConfigsSuccess([service]);
-    mockImplementingServicesSuccess(service);
-    mockRawPartialSchemaSuccess(service);
-
-    mockServiceHealthCheck(service).reply(500);
-
-    const gateway = new ApolloGateway({
-      serviceHealthCheck: true,
-      logger,
-      schemaConfigDeliveryEndpoint: null,
-    });
-
-    await expect(
-      gateway.load({
-        apollo: { keyHash: apiKeyHash, graphId, graphVariant: 'current' },
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-            "The gateway did not update its schema due to failed service health checks. The gateway will continue to operate with the previous schema and reattempt updates. The following error occurred during the health check:
-            [accounts]: 500: Internal Server Error"
-          `);
-  });
-
-  it('Preserves original schema when health check fails', async () => {
-    mockStorageSecretSuccess();
-    mockCompositionConfigLinkSuccess();
-    mockCompositionConfigsSuccess([service]);
-    mockImplementingServicesSuccess(service);
-    mockRawPartialSchemaSuccess(service);
-    mockServiceHealthCheckSuccess(service);
-
-    // Update
-    mockStorageSecretSuccess();
-    mockCompositionConfigLinkSuccess();
-    mockCompositionConfigsSuccess([updatedService]);
-    mockImplementingServicesSuccess(updatedService);
-    mockRawPartialSchemaSuccess(updatedService);
-    mockServiceHealthCheck(updatedService).reply(500);
-
-    let resolve: () => void;
-    const schemaChangeBlocker = new Promise<void>((res) => (resolve = res));
-
-    gateway = new ApolloGateway({
-      serviceHealthCheck: true,
-      logger,
-      schemaConfigDeliveryEndpoint: null,
-    });
-    // @ts-ignore for testing purposes, a short pollInterval is ideal so we'll override here
-    gateway.experimental_pollInterval = 100;
-
-    // @ts-ignore for testing purposes, we'll call the original `updateSchema`
-    // function from our mock. The first call should mimic original behavior,
-    // but the second call needs to handle the PromiseRejection. Typically for tests
-    // like these we would leverage the `gateway.onSchemaChange` callback to drive
-    // the test, but in this case, that callback isn't triggered when the update
-    // fails (as expected) so we get creative with the second mock as seen below.
-    const original = gateway.updateSchema;
-    const mockUpdateSchema = jest
-      .fn()
-      .mockImplementationOnce(async () => {
-        await original.apply(gateway);
-      })
-      .mockImplementationOnce(async () => {
-        // mock the first poll and handle the error which would otherwise be caught
-        // and logged from within the `pollServices` class method
-        try {
-          await original.apply(gateway);
-        } catch (e) {
-          var err = e;
-        }
-
-        expect(err.message).toMatchInlineSnapshot(`
-          "The gateway did not update its schema due to failed service health checks. The gateway will continue to operate with the previous schema and reattempt updates. The following error occurred during the health check:
-          [accounts]: 500: Internal Server Error"
-        `);
-        // finally resolve the promise which drives this test
-        resolve();
-      });
-
-    // @ts-ignore for testing purposes, replace the `updateSchema`
-    // function on the gateway with our mock
-    gateway.updateSchema = mockUpdateSchema;
-
-    // load the gateway as usual
-    await gateway.load({
-      apollo: { keyHash: apiKeyHash, graphId, graphVariant: 'current' },
-    });
-
-    expect(gateway.schema!.getType('User')!.description).toBe(
-      'This is my User',
-    );
-
-    await schemaChangeBlocker;
-
-    // At this point, the mock update should have been called but the schema
-    // should not have updated to the new one.
-    expect(mockUpdateSchema.mock.calls.length).toBe(2);
-    expect(gateway.schema!.getType('User')!.description).toBe(
-      'This is my User',
-    );
-  });
-});

package/src/__tests__/integration/legacyNockMocks.ts

@@ -1,113 +0,0 @@
-import { HEALTH_CHECK_QUERY, SERVICE_DEFINITION_QUERY } from '@apollo/gateway';
-import nock from 'nock';
-import { MockService } from './legacyNetworkRequests.test';
-
-export const graphId = 'federated-service';
-export const apiKeyHash = 'dd55a79d467976346d229a7b12b673ce';
-const storageSecret = 'my-storage-secret';
-const accountsService = 'accounts';
-
-// Service mocks
-function mockSdlQuery({ url }: MockService) {
-  return nock(url).post('/', {
-    query: SERVICE_DEFINITION_QUERY,
-  });
-}
-
-export function mockSdlQuerySuccess(service: MockService) {
-  mockSdlQuery(service).reply(200, {
-    data: { _service: { sdl: service.sdl } },
-  });
-}
-
-export function mockServiceHealthCheck({ url }: MockService) {
-  return nock(url).post('/', {
-    query: HEALTH_CHECK_QUERY,
-  });
-}
-
-export function mockServiceHealthCheckSuccess(service: MockService) {
-  return mockServiceHealthCheck(service).reply(200, {
-    data: { __typename: 'Query' },
-  });
-}
-
-// GCS mocks
-function gcsNock(url: Parameters<typeof nock>[0]): nock.Scope {
-  const { name, version } = require('../../../package.json');
-  return nock(url, {
-    reqheaders: {
-      'apollographql-client-name': name,
-      'apollographql-client-version': version,
-      'user-agent': `${name}/${version}`,
-      'content-type': 'application/json',
-    },
-  });
-}
-
-export function mockStorageSecret() {
-  return gcsNock('https://storage-secrets.api.apollographql.com:443').get(
-    `/${graphId}/storage-secret/${apiKeyHash}.json`,
-  );
-}
-
-export function mockStorageSecretSuccess() {
-  return gcsNock('https://storage-secrets.api.apollographql.com:443')
-    .get(`/${graphId}/storage-secret/${apiKeyHash}.json`)
-    .reply(200, `"${storageSecret}"`);
-}
-
-// get composition config link, using received storage secret
-export function mockCompositionConfigLink() {
-  return gcsNock('https://federation.api.apollographql.com:443').get(
-    `/${storageSecret}/current/v1/composition-config-link`,
-  );
-}
-
-export function mockCompositionConfigLinkSuccess() {
-  return mockCompositionConfigLink().reply(200, {
-    configPath: `${storageSecret}/current/v1/composition-configs/composition-config-path.json`,
-  });
-}
-
-// get composition configs, using received composition config link
-export function mockCompositionConfigs() {
-  return gcsNock('https://federation.api.apollographql.com:443').get(
-    `/${storageSecret}/current/v1/composition-configs/composition-config-path.json`,
-  );
-}
-
-export function mockCompositionConfigsSuccess(services: MockService[]) {
-  return mockCompositionConfigs().reply(200, {
-    implementingServiceLocations: services.map((service) => ({
-      name: accountsService,
-      path: `${storageSecret}/current/v1/implementing-services/${accountsService}/${service.gcsDefinitionPath}`,
-    })),
-  });
-}
-
-// get implementing service reference, using received composition-config
-export function mockImplementingServices({ gcsDefinitionPath }: MockService) {
-  return gcsNock('https://federation.api.apollographql.com:443').get(
-    `/${storageSecret}/current/v1/implementing-services/${accountsService}/${gcsDefinitionPath}`,
-  );
-}
-
-export function mockImplementingServicesSuccess(service: MockService) {
-  return mockImplementingServices(service).reply(200, {
-    name: accountsService,
-    partialSchemaPath: `${storageSecret}/current/raw-partial-schemas/${service.partialSchemaPath}`,
-    url: service.url,
-  });
-}
-
-// get raw-partial-schema, using received composition-config
-export function mockRawPartialSchema({ partialSchemaPath }: MockService) {
-  return gcsNock('https://federation.api.apollographql.com:443').get(
-    `/${storageSecret}/current/raw-partial-schemas/${partialSchemaPath}`,
-  );
-}
-
-export function mockRawPartialSchemaSuccess(service: MockService) {
-  return mockRawPartialSchema(service).reply(200, service.sdl);
-}

package/src/legacyLoadServicesFromStorage.ts

@@ -1,170 +0,0 @@
-import { fetch } from 'apollo-server-env';
-import { parse } from 'graphql';
-import { ServiceDefinitionUpdate } from './config';
-
-interface LinkFileResult {
-  configPath: string;
-  formatVersion: number;
-}
-
-interface ImplementingService {
-  formatVersion: number;
-  graphID: string;
-  graphVariant: string;
-  name: string;
-  revision: string;
-  url: string;
-  partialSchemaPath: string;
-}
-
-interface ImplementingServiceLocation {
-  name: string;
-  path: string;
-}
-
-export interface CompositionMetadata {
-  formatVersion: number;
-  id: string;
-  implementingServiceLocations: ImplementingServiceLocation[];
-  schemaHash: string;
-}
-
-const envOverridePartialSchemaBaseUrl = 'APOLLO_PARTIAL_SCHEMA_BASE_URL';
-const envOverrideStorageSecretBaseUrl = 'APOLLO_STORAGE_SECRET_BASE_URL';
-
-const urlFromEnvOrDefault = (envKey: string, fallback: string) =>
-  (process.env[envKey] || fallback).replace(/\/$/, '');
-
-// Generate and cache our desired operation manifest URL.
-const urlPartialSchemaBase = urlFromEnvOrDefault(
-  envOverridePartialSchemaBaseUrl,
-  'https://federation.api.apollographql.com/',
-);
-
-const urlStorageSecretBase: string = urlFromEnvOrDefault(
-  envOverrideStorageSecretBaseUrl,
-  'https://storage-secrets.api.apollographql.com/',
-);
-
-function getStorageSecretUrl(graphId: string, apiKeyHash: string): string {
-  return `${urlStorageSecretBase}/${graphId}/storage-secret/${apiKeyHash}.json`;
-}
-
-function fetchApolloGcs(
-  fetcher: typeof fetch,
-  ...args: Parameters<typeof fetch>
-): ReturnType<typeof fetch> {
-  const [input, init] = args;
-
-  // Used in logging.
-  const url = (typeof input === 'object' && input.url) || input;
-
-  return fetcher(input, init)
-    .catch((fetchError) => {
-      throw new Error('Cannot access Apollo storage: ' + fetchError);
-    })
-    .then(async (response) => {
-      // If the fetcher has a cache and has implemented ETag validation, then
-      // a 304 response may be returned.  Either way, we will return the
-      // non-JSON-parsed version and let the caller decide if that's important
-      // to their needs.
-      if (response.ok || response.status === 304) {
-        return response;
-      }
-
-      // We won't make any assumptions that the body is anything but text, to
-      // avoid parsing errors in this unknown condition.
-      const body = await response.text();
-
-      // Google Cloud Storage returns an `application/xml` error under error
-      // conditions.  We'll special-case our known errors, and resort to
-      // printing the body for others.
-      if (response.status === 403 && body.includes('AccessDenied')) {
-        throw new Error(
-          'Unable to authenticate with Apollo storage ' +
-            'while fetching ' +
-            url +
-            '.  Ensure that the API key is ' +
-            'configured properly and that a federated service has been ' +
-            'pushed.  For details, see ' +
-            'https://go.apollo.dev/g/resolve-access-denied.',
-        );
-      }
-
-      // Normally, we'll try to keep the logs clean with errors we expect.
-      // If it's not a known error, reveal the full body for debugging.
-      throw new Error('Could not communicate with Apollo storage: ' + body);
-    });
-}
-
-export async function getServiceDefinitionsFromStorage({
-  graphRef,
-  apiKeyHash,
-  federationVersion,
-  fetcher,
-}: {
-  graphRef: string;
-  apiKeyHash: string;
-  federationVersion: number;
-  fetcher: typeof fetch;
-}): Promise<ServiceDefinitionUpdate> {
-  // The protocol for talking to GCS requires us to split the graph ref
-  // into ID and variant; sigh.
-  const at = graphRef.indexOf('@');
-  const graphId = at === -1 ? graphRef : graphRef.substring(0, at);
-  const graphVariant = at === -1 ? 'current' : graphRef.substring(at + 1);
-
-  // fetch the storage secret
-  const storageSecretUrl = getStorageSecretUrl(graphId, apiKeyHash);
-
-  // The storage secret is a JSON string (e.g. `"secret"`).
-  const secret: string = await fetchApolloGcs(
-    fetcher,
-    storageSecretUrl,
-  ).then((res) => res.json());
-
-  const baseUrl = `${urlPartialSchemaBase}/${secret}/${graphVariant}/v${federationVersion}`;
-
-  const compositionConfigResponse = await fetchApolloGcs(
-    fetcher,
-    `${baseUrl}/composition-config-link`,
-  );
-
-  if (compositionConfigResponse.status === 304) {
-    return { isNewSchema: false };
-  }
-
-  const linkFileResult: LinkFileResult = await compositionConfigResponse.json();
-
-  const compositionMetadata: CompositionMetadata = await fetchApolloGcs(
-    fetcher,
-    `${urlPartialSchemaBase}/${linkFileResult.configPath}`,
-  ).then((res) => res.json());
-
-  // It's important to maintain the original order here
-  const serviceDefinitions = await Promise.all(
-    compositionMetadata.implementingServiceLocations.map(
-      async ({ name, path }) => {
-        const { url, partialSchemaPath }: ImplementingService = await fetcher(
-          `${urlPartialSchemaBase}/${path}`,
-        ).then((response) => response.json());
-
-        const sdl = await fetcher(
-          `${urlPartialSchemaBase}/${partialSchemaPath}`,
-        ).then((response) => response.text());
-
-        return { name, url, typeDefs: parse(sdl) };
-      },
-    ),
-  );
-
-  // explicity return that this is a new schema, as the link file has changed.
-  // we can't use the hit property of the fetchPartialSchemaFiles, as the partial
-  // schema may all be cache hits with the final schema still being new
-  // (for instance if a partial schema is removed or a partial schema is rolled back to a prior version, which is still in cache)
-  return {
-    serviceDefinitions,
-    compositionMetadata,
-    isNewSchema: true,
-  };
-}