@apollo/gateway 2.4.5 → 2.4.6

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

@@ -1,319 +0,0 @@
-import mockedEnv from 'mocked-env';
-import fetcher from 'make-fetch-happen';
-
-import { ApolloGateway, UplinkSupergraphManager } from '@apollo/gateway';
-import { ApolloServer } from '@apollo/server';
-import { startStandaloneServer } from '@apollo/server/standalone';
-import { ApolloServerPluginUsageReportingDisabled } from '@apollo/server/plugin/disabled';
-import type { FetcherRequestInit } from '@apollo/utils.fetcher';
-
-import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
-import {
-  mockSupergraphSdlRequestSuccess,
-  graphRef,
-  apiKey,
-  mockSupergraphSdlRequest,
-} from '../integration/nockMocks';
-import { getTestingSupergraphSdl } from '../execution-utils';
-
-let gateway: ApolloGateway | undefined;
-let server: ApolloServer | undefined;
-let cleanUp: (() => void) | undefined;
-
-beforeEach(() => {
-  nockBeforeEach();
-});
-
-afterEach(async () => {
-  if (server) {
-    await server.stop();
-    server = undefined;
-  }
-
-  if (gateway) {
-    await gateway.stop();
-    gateway = undefined;
-  }
-
-  nockAfterEach();
-
-  if (cleanUp) {
-    cleanUp();
-    cleanUp = undefined;
-  }
-});
-
-const logger = {
-  warn: jest.fn(),
-  debug: jest.fn(),
-  error: jest.fn(),
-  info: jest.fn(),
-};
-
-describe('minimal gateway', () => {
-  it('uses managed federation', async () => {
-    cleanUp = mockedEnv({
-      APOLLO_KEY: apiKey,
-      APOLLO_GRAPH_REF: graphRef,
-    });
-    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ });
-
-    gateway = new ApolloGateway({ logger });
-    server = new ApolloServer({
-      gateway,
-      plugins: [ApolloServerPluginUsageReportingDisabled()],
-    });
-    await startStandaloneServer(server, { listen: { port: 0 } });
-    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
-  });
-
-  it('fetches from provided `uplinkEndpoints`', async () => {
-    cleanUp = mockedEnv({
-      APOLLO_KEY: apiKey,
-      APOLLO_GRAPH_REF: graphRef,
-    });
-
-    const uplinkEndpoint = 'https://example.com';
-    mockSupergraphSdlRequestSuccess({ url: uplinkEndpoint });
-
-    gateway = new ApolloGateway({ logger, uplinkEndpoints: [uplinkEndpoint] });
-    server = new ApolloServer({
-      gateway,
-      plugins: [ApolloServerPluginUsageReportingDisabled()],
-    });
-    await startStandaloneServer(server, { listen: { port: 0 } });
-    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
-    const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
-    expect(uplinkManager.uplinkEndpoints).toEqual([uplinkEndpoint]);
-  });
-
-  it('fetches from (deprecated) provided `schemaConfigDeliveryEndpoint`', async () => {
-    cleanUp = mockedEnv({
-      APOLLO_KEY: apiKey,
-      APOLLO_GRAPH_REF: graphRef,
-    });
-
-    const schemaConfigDeliveryEndpoint = 'https://example.com';
-    mockSupergraphSdlRequestSuccess({ url: schemaConfigDeliveryEndpoint });
-
-    gateway = new ApolloGateway({ logger, schemaConfigDeliveryEndpoint });
-    server = new ApolloServer({
-      gateway,
-      plugins: [ApolloServerPluginUsageReportingDisabled()],
-    });
-    await startStandaloneServer(server, { listen: { port: 0 } });
-    expect(gateway.supergraphManager).toBeInstanceOf(UplinkSupergraphManager);
-    const uplinkManager = gateway.supergraphManager as UplinkSupergraphManager;
-    expect(uplinkManager.uplinkEndpoints).toEqual([
-      schemaConfigDeliveryEndpoint,
-    ]);
-  });
-
-  it('supports a custom fetcher', async () => {
-    cleanUp = mockedEnv({
-      APOLLO_KEY: apiKey,
-      APOLLO_GRAPH_REF: graphRef,
-    });
-    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ });
-
-    let calls = 0;
-    gateway = new ApolloGateway({
-      logger,
-      fetcher: (url: string, init?: FetcherRequestInit) => {
-        calls++;
-        return fetcher(url, init);
-      },
-    });
-    server = new ApolloServer({
-      gateway,
-      plugins: [ApolloServerPluginUsageReportingDisabled()],
-    });
-    await startStandaloneServer(server, { listen: { port: 0 } });
-
-    expect(calls).toEqual(1);
-  });
-});
-
-describe('Managed gateway with explicit UplinkSupergraphManager', () => {
-  it('waits for supergraph schema to load', async () => {
-    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ });
-
-    gateway = new ApolloGateway({
-      logger,
-      supergraphSdl: new UplinkSupergraphManager({
-        apiKey,
-        graphRef,
-        logger,
-      }),
-    });
-    await expect(gateway.load()).resolves.not.toThrow();
-  });
-
-  it('invokes callback if uplink throws an error during init', async () => {
-    mockSupergraphSdlRequest(null, /.*?apollographql.com/).reply(500);
-
-    const supergraphSchema = getTestingSupergraphSdl();
-    let hasFired;
-    gateway = new ApolloGateway({
-      logger,
-      supergraphSdl: new UplinkSupergraphManager({
-        apiKey,
-        graphRef,
-        logger,
-        maxRetries: 0,
-        async onFailureToFetchSupergraphSdlDuringInit() {
-          hasFired = true;
-          return supergraphSchema;
-        },
-      }),
-    });
-
-    await expect(gateway.load()).resolves.not.toThrow();
-    expect(gateway.__testing().supergraphSdl).toBe(supergraphSchema);
-    expect(hasFired).toBeTruthy();
-  });
-
-  it('invokes callback if uplink throws an error after init', async () => {
-    // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
-    mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
-      .post('/')
-      .reply(500);
-
-    const supergraphSchema = getTestingSupergraphSdl();
-    let hasFired;
-    const uplinkManager = new UplinkSupergraphManager({
-      apiKey,
-      graphRef,
-      logger,
-      maxRetries: 0,
-      async onFailureToFetchSupergraphSdlAfterInit() {
-        hasFired = true;
-        return supergraphSchema;
-      },
-    });
-    // Set pollIntervalMs lower than the typically allowed value so we don't wait 10s between polling
-    uplinkManager['pollIntervalMs'] = 0;
-
-    gateway = new ApolloGateway({
-      logger,
-      supergraphSdl: uplinkManager,
-    });
-
-    await expect(gateway.load()).resolves.not.toThrow();
-    expect(hasFired).toBeFalsy();
-
-    await uplinkManager.nextFetch();
-
-    expect(hasFired).toBeTruthy();
-  });
-
-  it.each([
-    ['x', 'Syntax Error: Unexpected Name "x".'],
-    ['', 'Invalid supergraph schema supplied during initialization.'],
-    [' ', 'Syntax Error: Unexpected <EOF>.'],
-    ['type Query {hi: String}', 'Invalid supergraph: must be a core schema'],
-  ])(
-    'throws if invalid supergraph schema returned from callback during init: %p',
-    async (schemaText, expectedMessage) => {
-      mockSupergraphSdlRequest(null, /.*?apollographql.com/).reply(500);
-
-      gateway = new ApolloGateway({
-        logger,
-        supergraphSdl: new UplinkSupergraphManager({
-          apiKey,
-          graphRef,
-          logger,
-          maxRetries: 0,
-          async onFailureToFetchSupergraphSdlDuringInit() {
-            return schemaText;
-          },
-        }),
-      });
-
-      await expect(gateway.load()).rejects.toThrowError(expectedMessage);
-    },
-  );
-
-  it.each([
-    ['x', 'Syntax Error: Unexpected Name "x".'],
-    [' ', 'Syntax Error: Unexpected <EOF>.'],
-    ['type Query {hi: String}', 'Invalid supergraph: must be a core schema'],
-  ])(
-    'throws if invalid supergraph schema returned from callback after init: %p',
-    async (schemaText, expectedMessage) => {
-      // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
-      mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
-        .post('/')
-        .reply(500);
-
-      let hasFired;
-      const uplinkManager = new UplinkSupergraphManager({
-        apiKey,
-        graphRef,
-        logger,
-        maxRetries: 0,
-        async onFailureToFetchSupergraphSdlAfterInit() {
-          hasFired = true;
-          return schemaText;
-        },
-      });
-      // Set pollIntervalMs lower than the typically allowed value so we don't wait 10s between polling
-      uplinkManager['pollIntervalMs'] = 0;
-
-      gateway = new ApolloGateway({
-        logger,
-        supergraphSdl: uplinkManager
-      });
-
-      await expect(gateway.load()).resolves.not.toThrow();
-      expect(hasFired).toBeFalsy();
-
-      await uplinkManager.nextFetch();
-
-      expect(hasFired).toBeTruthy();
-      expect(logger.error).toBeCalledWith(
-        `UplinkSupergraphManager failed to update supergraph with the following error: ${expectedMessage}`,
-      );
-    },
-  );
-
-  it.each([null, ''])(
-    'uses existing supergraph schema if false-y value returned from callback after init: %p',
-    async (schemaText) => {
-      // This is kinda wonky to read: we're responding the first time with success, then the next fetch should fail
-      mockSupergraphSdlRequestSuccess({ url: /.*?apollographql.com/ })
-        .post('/')
-        .reply(500);
-
-      let hasFired;
-      const uplinkManager = new UplinkSupergraphManager({
-        apiKey,
-        graphRef,
-        logger,
-        maxRetries: 0,
-
-        async onFailureToFetchSupergraphSdlAfterInit() {
-          hasFired = true;
-          return schemaText;
-        },
-      });
-      // Set pollIntervalMs lower than the typically allowed value so we don't wait 10s between polling
-      uplinkManager['pollIntervalMs'] = 0;
-
-      gateway = new ApolloGateway({
-        logger,
-        supergraphSdl: uplinkManager,
-      });
-
-      await expect(gateway.load()).resolves.not.toThrow();
-      expect(hasFired).toBeFalsy();
-
-      await uplinkManager.nextFetch();
-
-      expect(hasFired).toBeTruthy();
-
-      const supergraphSchema = getTestingSupergraphSdl();
-      expect(gateway.__testing().supergraphSdl).toBe(supergraphSchema);
-    },
-  );
-});

package/src/__tests__/integration/merge-arrays.test.ts

@@ -1,34 +0,0 @@
-import { execute } from '../execution-utils';
-
-describe('query', () => {
-  it('supports arrays', async () => {
-    const query = `#graphql
-      query MergeArrays {
-        me {
-          # goodAddress
-          goodDescription
-          metadata {
-            address
-          }
-        }
-      }
-    `;
-
-    const { data, queryPlan } = await execute({
-      query,
-    });
-
-    expect(data).toEqual({
-      me: {
-        goodDescription: true,
-        metadata: [
-          {
-            address: '1',
-          },
-        ],
-      },
-    });
-
-    expect(queryPlan).toCallService('accounts');
-  });
-});

package/src/__tests__/integration/multiple-key.test.ts

@@ -1,327 +0,0 @@
-import gql from 'graphql-tag';
-import { execute, ServiceDefinitionModule } from '../execution-utils';
-import { astSerializer, queryPlanSerializer } from 'apollo-federation-integration-testsuite';
-
-expect.addSnapshotSerializer(astSerializer);
-expect.addSnapshotSerializer(queryPlanSerializer);
-
-const users = [
-  { ssn: '111-11-1111', name: 'Trevor', id: '10', __typename: 'User' },
-  { ssn: '222-22-2222', name: 'Joel', id: '20', __typename: 'User' },
-  { ssn: '333-33-3333', name: 'James', id: '30', __typename: 'User' },
-  { ssn: '444-44-4444', name: 'Baxley', id: '40', __typename: 'User' },
-];
-
-const reviews = [
-  { id: '1', authorId: '10', body: 'A', __typename: 'Review' },
-  { id: '2', authorId: '20', body: 'B', __typename: 'Review' },
-  { id: '3', authorId: '30', body: 'C', __typename: 'Review' },
-  { id: '4', authorId: '40', body: 'D', __typename: 'Review' },
-];
-
-const reviewService: ServiceDefinitionModule = {
-  name: 'reviews',
-  typeDefs: gql`
-    extend type Query {
-      reviews: [Review!]!
-    }
-
-    type Review {
-      id: ID!
-      author: User!
-      body: String!
-    }
-
-    extend type User @key(fields: "id") {
-      id: ID! @external
-      reviews: [Review!]!
-    }
-  `,
-  resolvers: {
-    Query: {
-      reviews() {
-        return reviews;
-      },
-    },
-    User: {
-      reviews(user) {
-        return reviews.filter(review => review.authorId === user.id);
-      },
-    },
-    Review: {
-      author(review) {
-        return {
-          id: review.authorId,
-        };
-      },
-    },
-  },
-};
-
-const actuaryService: ServiceDefinitionModule = {
-  name: 'actuary',
-  typeDefs: gql`
-    extend type User @key(fields: "ssn") {
-      ssn: ID! @external
-      risk: Float
-    }
-  `,
-  resolvers: {
-    User: {
-      risk(user) {
-        return user.ssn[0] / 10;
-      },
-    },
-  },
-};
-
-const userService: ServiceDefinitionModule = {
-  name: 'users',
-  typeDefs: gql`
-    extend type Query {
-      users: [User!]!
-    }
-
-    type Group {
-      id: ID
-      name: String
-    }
-
-    type User
-      @key(fields: "ssn")
-      @key(fields: "id")
-      @key(fields: "group { id }") {
-      id: ID!
-      ssn: ID!
-      name: String!
-      group: Group
-    }
-  `,
-  resolvers: {
-    Query: {
-      users() {
-        return users;
-      },
-    },
-    User: {
-      group: () => ({ id: 1, name: 'Apollo GraphQL' }),
-      __resolveReference(reference) {
-        if (reference.ssn)
-          return users.find(user => user.ssn === reference.ssn);
-        else return users.find(user => user.id === reference.id);
-      },
-    },
-  },
-};
-
-it('fetches data correctly with multiple @key fields', async () => {
-  const query = `#graphql
-    query {
-      reviews {
-        body
-        author {
-          name
-          risk
-        }
-      }
-    }
-  `;
-
-  const { data, queryPlan, errors } = await execute(
-    {
-      query,
-    },
-    [userService, reviewService, actuaryService],
-  );
-
-  expect(errors).toBeFalsy();
-  expect(data).toEqual({
-    reviews: [
-      {
-        body: 'A',
-        author: {
-          risk: 0.1,
-          name: 'Trevor',
-        },
-      },
-      {
-        body: 'B',
-        author: {
-          risk: 0.2,
-          name: 'Joel',
-        },
-      },
-      {
-        body: 'C',
-        author: {
-          risk: 0.3,
-          name: 'James',
-        },
-      },
-      {
-        body: 'D',
-        author: {
-          risk: 0.4,
-          name: 'Baxley',
-        },
-      },
-    ],
-  });
-
-  expect(queryPlan).toMatchInlineSnapshot(`
-    QueryPlan {
-      Sequence {
-        Fetch(service: "reviews") {
-          {
-            reviews {
-              body
-              author {
-                __typename
-                id
-              }
-            }
-          }
-        },
-        Flatten(path: "reviews.@.author") {
-          Fetch(service: "users") {
-            {
-              ... on User {
-                __typename
-                id
-              }
-            } =>
-            {
-              ... on User {
-                ssn
-                name
-              }
-            }
-          },
-        },
-        Flatten(path: "reviews.@.author") {
-          Fetch(service: "actuary") {
-            {
-              ... on User {
-                __typename
-                ssn
-              }
-            } =>
-            {
-              ... on User {
-                risk
-              }
-            }
-          },
-        },
-      },
-    }
-  `);
-});
-
-it('fetches keys as needed to reduce round trip queries', async () => {
-  const query = `#graphql
-    query {
-      users {
-        risk
-        reviews {
-          body
-        }
-      }
-    }
-  `;
-
-  const { data, queryPlan, errors } = await execute(
-    {
-      query,
-    },
-    [userService, reviewService, actuaryService]
-  );
-
-  expect(errors).toBeFalsy();
-  expect(data).toEqual({
-    users: [
-      {
-        risk: 0.1,
-        reviews: [
-          {
-            body: 'A',
-          },
-        ],
-      },
-      {
-        risk: 0.2,
-        reviews: [
-          {
-            body: 'B',
-          },
-        ],
-      },
-      {
-        risk: 0.3,
-        reviews: [
-          {
-            body: 'C',
-          },
-        ],
-      },
-      {
-        risk: 0.4,
-        reviews: [
-          {
-            body: 'D',
-          },
-        ],
-      },
-    ],
-  });
-
-  expect(queryPlan).toMatchInlineSnapshot(`
-        QueryPlan {
-          Sequence {
-            Fetch(service: "users") {
-              {
-                users {
-                  __typename
-                  id
-                  ssn
-                }
-              }
-            },
-            Parallel {
-              Flatten(path: "users.@") {
-                Fetch(service: "reviews") {
-                  {
-                    ... on User {
-                      __typename
-                      id
-                    }
-                  } =>
-                  {
-                    ... on User {
-                      reviews {
-                        body
-                      }
-                    }
-                  }
-                },
-              },
-              Flatten(path: "users.@") {
-                Fetch(service: "actuary") {
-                  {
-                    ... on User {
-                      __typename
-                      ssn
-                    }
-                  } =>
-                  {
-                    ... on User {
-                      risk
-                    }
-                  }
-                },
-              },
-            },
-          },
-        }
-      `);
-});