@apollo/gateway 2.4.4 → 2.4.6

package/src/__tests__/execution-utils.ts

@@ -1,124 +0,0 @@
-import {
-  GraphQLSchemaModule,
-  GraphQLResolverMap,
-  GraphQLSchemaValidationError,
-} from '@apollo/subgraph/src/schema-helper';
-import type { Logger } from '@apollo/utils.logger';
-import { buildSubgraphSchema } from '@apollo/subgraph';
-import {
-  executeQueryPlan,
-  buildOperationContext,
-} from '@apollo/gateway';
-import { QueryPlan, QueryPlanner } from '@apollo/query-planner';
-import { LocalGraphQLDataSource } from '../datasources/LocalGraphQLDataSource';
-import { mergeDeep } from '@apollo/client/utilities';
-
-import { queryPlanSerializer, astSerializer } from 'apollo-federation-integration-testsuite';
-import gql from 'graphql-tag';
-import { fixtures } from 'apollo-federation-integration-testsuite';
-import { composeServices } from '@apollo/composition';
-import { buildSchema, Operation, operationFromDocument, ServiceDefinition } from '@apollo/federation-internals';
-import { GatewayExecutionResult, GatewayGraphQLRequest } from '@apollo/server-gateway-interface';
-
-const prettyFormat = require('pretty-format');
-
-export type ServiceDefinitionModule = ServiceDefinition & GraphQLSchemaModule;
-
-export function overrideResolversInService(
-  module: ServiceDefinitionModule,
-  resolvers: GraphQLResolverMap,
-): ServiceDefinitionModule {
-  return {
-    name: module.name,
-    typeDefs: module.typeDefs,
-    resolvers: mergeDeep(module.resolvers, resolvers),
-  };
-}
-
-export async function execute(
-  request: GatewayGraphQLRequest,
-  services: ServiceDefinitionModule[] = fixtures,
-  logger: Logger = console,
-): Promise<GatewayExecutionResult & { queryPlan: QueryPlan, operation: Operation }> {
-  const serviceMap = Object.fromEntries(
-    services.map(({ name, typeDefs, resolvers }) => {
-      return [
-        name,
-        new LocalGraphQLDataSource(
-          buildSubgraphSchema([{ typeDefs, resolvers }]),
-        ),
-      ] as [string, LocalGraphQLDataSource];
-    }),
-  );
-
-  const { schema, queryPlanner } = getFederatedTestingSchema(services);
-
-  const apiSchema = schema.toAPISchema();
-  const operationDocument = gql`${request.query}`;
-  const operation = operationFromDocument(apiSchema, operationDocument);
-  const queryPlan = queryPlanner.buildQueryPlan(operation);
-
-  const operationContext = buildOperationContext({
-    schema: apiSchema.toGraphQLJSSchema(),
-    operationDocument,
-  });
-
-  const result = await executeQueryPlan(
-    queryPlan,
-    serviceMap,
-     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-     // @ts-ignore
-    {
-      cache: undefined as any,
-      context: {},
-      request,
-      logger
-    },
-    operationContext,
-    schema.toGraphQLJSSchema(),
-    apiSchema,
-  );
-
-  return { ...result, queryPlan, operation };
-}
-
-export function buildLocalService(modules: GraphQLSchemaModule[]) {
-  const schema = buildSubgraphSchema(modules);
-  return new LocalGraphQLDataSource(schema);
-}
-
-export function getFederatedTestingSchema(services: ServiceDefinitionModule[] = fixtures) {
-  const compositionResult = composeServices(services);
-  if (compositionResult.errors) {
-    throw new GraphQLSchemaValidationError(compositionResult.errors);
-  }
-
-  const queryPlanner = new QueryPlanner(compositionResult.schema);
-  const schema = buildSchema(compositionResult.supergraphSdl);
-
-  const serviceMap = Object.fromEntries(
-    services.map((service) => [
-      service.name,
-      buildLocalService([service]),
-    ]),
-  );
-  return { serviceMap, schema, queryPlanner };
-}
-
-export function getTestingSupergraphSdl(services: typeof fixtures = fixtures) {
-  const compositionResult = composeServices(services);
-  if (!compositionResult.errors) {
-    return compositionResult.supergraphSdl;
-  }
-  throw new Error(`Testing fixtures don't compose properly!\nCauses:\n${compositionResult.errors.join('\n\n')}`);
-}
-
-export function wait(ms: number, toResolveTo?: any) {
-  return new Promise((r) => setTimeout(() => r(toResolveTo), ms));
-}
-
-export function printPlan(queryPlan: QueryPlan): string {
-  return prettyFormat(queryPlan, {
-    plugins: [queryPlanSerializer, astSerializer],
-  });
-}

package/src/__tests__/gateway/__snapshots__/opentelemetry.test.ts.snap

@@ -1,195 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`opentelemetry receives spans on fetch failure 1`] = `
-[
-  {
-    "name": "gateway.request",
-    "attributes": {
-      "operationName": "GetProduct"
-    },
-    "children": [
-      {
-        "name": "gateway.validate",
-        "attributes": {},
-        "children": [],
-        "status": {
-          "code": 0
-        }
-      },
-      {
-        "name": "gateway.plan",
-        "attributes": {},
-        "children": [],
-        "status": {
-          "code": 0
-        }
-      },
-      {
-        "name": "gateway.execute",
-        "attributes": {},
-        "children": [
-          {
-            "name": "gateway.fetch",
-            "attributes": {
-              "service": "product"
-            },
-            "children": [],
-            "status": {
-              "code": 2
-            }
-          },
-          {
-            "name": "gateway.postprocessing",
-            "attributes": {},
-            "children": [],
-            "status": {
-              "code": 0
-            }
-          }
-        ],
-        "status": {
-          "code": 2
-        }
-      }
-    ],
-    "status": {
-      "code": 2
-    }
-  }
-]
-`;
-
-exports[`opentelemetry with local data receives spans on plan failure 1`] = `
-[
-  {
-    "name": "gateway.request",
-    "attributes": {
-      "operationName": "GetProduct"
-    },
-    "children": [
-      {
-        "name": "gateway.validate",
-        "attributes": {},
-        "children": [],
-        "status": {
-          "code": 0
-        }
-      },
-      {
-        "name": "gateway.plan",
-        "attributes": {},
-        "children": [],
-        "status": {
-          "code": 2
-        }
-      }
-    ],
-    "status": {
-      "code": 2
-    }
-  }
-]
-`;
-
-exports[`opentelemetry with local data receives spans on success 1`] = `
-[
-  {
-    "name": "gateway.request",
-    "attributes": {
-      "operationName": "GetProduct"
-    },
-    "children": [
-      {
-        "name": "gateway.validate",
-        "attributes": {},
-        "children": [],
-        "status": {
-          "code": 0
-        }
-      },
-      {
-        "name": "gateway.plan",
-        "attributes": {},
-        "children": [],
-        "status": {
-          "code": 0
-        }
-      },
-      {
-        "name": "gateway.execute",
-        "attributes": {},
-        "children": [
-          {
-            "name": "gateway.fetch",
-            "attributes": {
-              "service": "product"
-            },
-            "children": [],
-            "status": {
-              "code": 0
-            }
-          },
-          {
-            "name": "gateway.fetch",
-            "attributes": {
-              "service": "books"
-            },
-            "children": [],
-            "status": {
-              "code": 0
-            }
-          },
-          {
-            "name": "gateway.fetch",
-            "attributes": {
-              "service": "product"
-            },
-            "children": [],
-            "status": {
-              "code": 0
-            }
-          },
-          {
-            "name": "gateway.postprocessing",
-            "attributes": {},
-            "children": [],
-            "status": {
-              "code": 0
-            }
-          }
-        ],
-        "status": {
-          "code": 0
-        }
-      }
-    ],
-    "status": {
-      "code": 0
-    }
-  }
-]
-`;
-
-exports[`opentelemetry with local data receives spans on validation failure 1`] = `
-[
-  {
-    "name": "gateway.request",
-    "attributes": {
-      "operationName": "InvalidVariables"
-    },
-    "children": [
-      {
-        "name": "gateway.validate",
-        "attributes": {},
-        "children": [],
-        "status": {
-          "code": 2
-        }
-      }
-    ],
-    "status": {
-      "code": 2
-    }
-  }
-]
-`;

package/src/__tests__/gateway/buildService.test.ts

@@ -1,249 +0,0 @@
-import nock from 'nock';
-
-import { ApolloServer } from '@apollo/server';
-
-import { RemoteGraphQLDataSource } from '../../datasources/RemoteGraphQLDataSource';
-import { ApolloGateway, SERVICE_DEFINITION_QUERY } from '../../';
-import { fixtures } from 'apollo-federation-integration-testsuite';
-import { GraphQLDataSourceRequestKind } from '../../datasources/types';
-import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
-import { unwrapSingleResultKind } from '../gateway/testUtils';
-
-beforeEach(nockBeforeEach);
-afterEach(nockAfterEach);
-
-const replyHeaders = {
-  'content-type': 'application/json',
-};
-
-it('calls buildService only once per service', async () => {
-  nock('https://api.example.com')
-    .post('/foo')
-    .reply(
-      200,
-      {
-        data: { _service: { sdl: `extend type Query { thing: String }` } },
-      },
-      replyHeaders,
-    );
-
-  const buildServiceSpy = jest.fn(() => {
-    return new RemoteGraphQLDataSource({
-      url: 'https://api.example.com/foo',
-    });
-  });
-
-  const gateway = new ApolloGateway({
-    serviceList: [{ name: 'foo', url: 'https://api.example.com/foo' }],
-    buildService: buildServiceSpy,
-  });
-
-  await gateway.load();
-
-  expect(buildServiceSpy).toHaveBeenCalledTimes(1);
-});
-
-it('correctly passes the context from ApolloServer to datasources', async () => {
-  const gateway = new ApolloGateway({
-    localServiceList: fixtures,
-    buildService: (_service) => {
-      return new RemoteGraphQLDataSource({
-        url: 'https://api.example.com/foo',
-        willSendRequest: (options) => {
-          if (
-            options.kind === GraphQLDataSourceRequestKind.INCOMING_OPERATION
-          ) {
-            options.request.http?.headers.set(
-              'x-user-id',
-              options.context.userId,
-            );
-          }
-        },
-      });
-    },
-  });
-
-  const server = new ApolloServer({
-    gateway,
-  });
-  await server.start();
-
-  const query = `#graphql
-    {
-      me {
-        username
-      }
-    }
-  `;
-
-  nock('https://api.example.com', {
-    reqheaders: {
-      'x-user-id': '1234',
-    },
-  })
-    .post('/foo', {
-      query: `{me{username}}`,
-      variables: {},
-    })
-    .reply(
-      200,
-      {
-        data: { me: { username: '@apollo-user' } },
-      },
-      replyHeaders,
-    );
-
-  const result = await server.executeOperation(
-    {
-      query,
-    },
-    {
-      contextValue: {
-        userId: '1234',
-      },
-    },
-  );
-
-  const { data, errors } = unwrapSingleResultKind(result);
-  expect(errors).toBeUndefined();
-  expect(data).toEqual({
-    me: { username: '@apollo-user' },
-  });
-});
-
-function createSdlData(sdl: string): [number, any, Record<string, string>] {
-  return [
-    200,
-    {
-      data: {
-        _service: {
-          sdl: sdl,
-        },
-      },
-    },
-    replyHeaders,
-  ];
-}
-
-it('makes enhanced introspection request using datasource', async () => {
-  nock('https://api.example.com', {
-    reqheaders: {
-      'custom-header': 'some-custom-value',
-    },
-  })
-    .post('/override', {
-      query: SERVICE_DEFINITION_QUERY,
-    })
-    .reply(...createSdlData('extend type Query { one: String }'));
-
-  const gateway = new ApolloGateway({
-    serviceList: [
-      {
-        name: 'one',
-        url: 'https://api.example.com/one',
-      },
-    ],
-    buildService: (_service) => {
-      return new RemoteGraphQLDataSource({
-        url: 'https://api.example.com/override',
-        willSendRequest: ({ request }) => {
-          request.http?.headers.set('custom-header', 'some-custom-value');
-        },
-      });
-    },
-  });
-
-  await gateway.load();
-});
-
-it('customizes request on a per-service basis', async () => {
-  for (const subgraph of ['one', 'two', 'three']) {
-    nock('https://api.example.com', {
-      reqheaders: {
-        'service-name': subgraph,
-      },
-    })
-      .post(`/${subgraph}`, {
-        query: SERVICE_DEFINITION_QUERY,
-      })
-      .reply(...createSdlData(`extend type Query { ${subgraph}: String }`));
-  }
-
-  const gateway = new ApolloGateway({
-    serviceList: [
-      {
-        name: 'one',
-        url: 'https://api.example.com/one',
-      },
-      {
-        name: 'two',
-        url: 'https://api.example.com/two',
-      },
-      {
-        name: 'three',
-        url: 'https://api.example.com/three',
-      },
-    ],
-    buildService: (service) => {
-      return new RemoteGraphQLDataSource({
-        url: service.url,
-        willSendRequest: ({ request }) => {
-          request.http?.headers.set('service-name', service.name);
-        },
-      });
-    },
-  });
-
-  await gateway.load();
-});
-
-it('does not share service definition cache between gateways', async () => {
-  let updates = 0;
-  const updateObserver: any = (..._args: any[]) => {
-    updates += 1;
-  };
-
-  function nockSDLFetchOnce() {
-    nock('https://api.example.com')
-      .post('/repeat', {
-        query: SERVICE_DEFINITION_QUERY,
-      })
-      .reply(...createSdlData('extend type Query { repeat: String }'));
-  }
-
-  // Initialize first gateway
-  {
-    nockSDLFetchOnce();
-
-    const gateway = new ApolloGateway({
-      serviceList: [
-        {
-          name: 'repeat',
-          url: 'https://api.example.com/repeat',
-        },
-      ],
-      experimental_didUpdateSupergraph: updateObserver,
-    });
-
-    await gateway.load();
-  }
-
-  // Initialize second gateway
-  {
-    nockSDLFetchOnce();
-
-    const gateway = new ApolloGateway({
-      serviceList: [
-        {
-          name: 'repeat',
-          url: 'https://api.example.com/repeat',
-        },
-      ],
-      experimental_didUpdateSupergraph: updateObserver,
-    });
-
-    await gateway.load();
-  }
-
-  expect(updates).toEqual(2);
-});