@apollo/gateway 2.0.0-preview.9 → 2.0.2-alpha.0

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

@@ -1,10 +1,13 @@
 import { buildSubgraphSchema } from '@apollo/subgraph';
 import { ApolloServer } from 'apollo-server';
-import fetch from 'node-fetch';
+import fetch, { Response } from 'node-fetch';
 import { ApolloGateway } from '../..';
 import { fixtures } from 'apollo-federation-integration-testsuite';
 import { ApolloServerPluginInlineTrace } from 'apollo-server-core';
-import { GraphQLSchemaModule } from '../../schema-helper';
+import { GraphQLSchemaModule } from '@apollo/subgraph/src/schema-helper';
+import { buildSchema, ObjectType, ServiceDefinition } from '@apollo/federation-internals';
+import gql from 'graphql-tag';
+import { printSchema } from 'graphql';
 
 async function startFederatedServer(modules: GraphQLSchemaModule[]) {
   const schema = buildSubgraphSchema(modules);
@@ -17,34 +20,49 @@ async function startFederatedServer(modules: GraphQLSchemaModule[]) {
   return { url, server };
 }
 
-describe('end-to-end', () => {
-  let backendServers: ApolloServer[];
-  let gatewayServer: ApolloServer;
-  let gatewayUrl: string;
+let backendServers: ApolloServer[];
+let gateway: ApolloGateway;
+let gatewayServer: ApolloServer;
+let gatewayUrl: string;
 
-  beforeEach(async () => {
-    backendServers = [];
-    const serviceList = [];
-    for (const fixture of fixtures) {
-      const { server, url } = await startFederatedServer([fixture]);
-      backendServers.push(server);
-      serviceList.push({ name: fixture.name, url });
-    }
-
-    const gateway = new ApolloGateway({ serviceList });
-    gatewayServer = new ApolloServer({
-      gateway,
-    });
-    ({ url: gatewayUrl } = await gatewayServer.listen({ port: 0 }));
+async function startServicesAndGateway(servicesDefs: ServiceDefinition[]) {
+  backendServers = [];
+  const serviceList = [];
+  for (const serviceDef of servicesDefs) {
+    const { server, url } = await startFederatedServer([serviceDef]);
+    backendServers.push(server);
+    serviceList.push({ name: serviceDef.name, url });
+  }
+
+  gateway = new ApolloGateway({ serviceList });
+  gatewayServer = new ApolloServer({
+    gateway,
   });
+  ({ url: gatewayUrl } = await gatewayServer.listen({ port: 0 }));
+}
 
-  afterEach(async () => {
-    for (const server of backendServers) {
-      await server.stop();
-    }
-    if (gatewayServer) {
-      await gatewayServer.stop();
-    }
+async function queryGateway(query: string): Promise<Response> {
+  return fetch(gatewayUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ query }),
+  });
+}
+
+afterEach(async () => {
+  for (const server of backendServers) {
+    await server.stop();
+  }
+  if (gatewayServer) {
+    await gatewayServer.stop();
+  }
+});
+
+describe('caching', () => {
+  beforeEach(async () => {
+    await startServicesAndGateway(fixtures);
   });
 
   it(`cache control`, async () => {
@@ -62,13 +80,7 @@ describe('end-to-end', () => {
       }
     `;
 
-    const response = await fetch(gatewayUrl, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ query }),
-    });
+    const response = await queryGateway(query);
     const result = await response.json();
     expect(result).toMatchInlineSnapshot(`
       Object {
@@ -122,13 +134,7 @@ describe('end-to-end', () => {
       }
     `;
 
-    const response = await fetch(gatewayUrl, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ query }),
-    });
+    const response = await queryGateway(query);
     const result = await response.json();
     expect(result).toMatchInlineSnapshot(`
       Object {
@@ -164,3 +170,320 @@ describe('end-to-end', () => {
     expect(response.headers.get('cache-control')).toBe(null);
   });
 });
+
+/**
+ * Tests for a number of specific features end-to-end.
+ * Note that those features have (or at least should have) much thorough test coverage in the various places
+ * that handle them more directly, and those tests largely duplicate other test, but it's meant to ensure we
+ * have basic end-to-end testing, thus ensuring those feature don't break in places we didn't expect.
+ */
+describe('end-to-end features', () => {
+  it('@tag renaming', async () => {
+    const subgraphA = {
+      name: 'A',
+      url: 'https://A',
+      typeDefs: gql`
+        extend schema
+          @link(
+            url: "https://specs.apollo.dev/federation/v2.0",
+            import: [ "@key", { name: "@tag", as: "@federationTag"} ]
+          )
+
+        type Query {
+          t: T
+        }
+
+        type T @key(fields: "k") {
+          k: ID
+          x: Int @federationTag(name: "Important")
+        }
+      `,
+      resolvers: {
+        Query: {
+          t: () => ({
+            k: 42,
+            x: 1
+          }),
+        }
+      }
+    };
+
+    const subgraphB = {
+      name: 'B',
+      url: 'https://B',
+      typeDefs: gql`
+        extend schema
+          @link(
+            url: "https://specs.apollo.dev/federation/v2.0",
+            import: [ "@key", { name: "@tag", as: "@federationTag"} ]
+          )
+
+        type T @key(fields: "k") {
+          k: ID
+          y: Int @federationTag(name: "Less Important")
+        }
+      `,
+      resolvers: {
+        T: {
+          __resolveReference: ({ k }: { k: string }) => {
+            return k === '42' ? ({ y: 2 }) : undefined;
+          },
+        }
+      }
+    };
+
+    await startServicesAndGateway([subgraphA, subgraphB]);
+
+    const query = `
+      {
+        t {
+          x
+          y
+        }
+      }
+    `;
+
+    const response = await queryGateway(query);
+    const result = await response.json();
+    expect(result).toMatchInlineSnapshot(`
+      Object {
+        "data": Object {
+          "t": Object {
+            "x": 1,
+            "y": 2,
+          },
+        },
+      }
+    `);
+
+    const supergraphSdl = gateway.__testing().supergraphSdl;
+    expect(supergraphSdl).toBeDefined();
+    const supergraph = buildSchema(supergraphSdl!);
+    const typeT = supergraph.type('T') as ObjectType;
+    expect(typeT.field('x')?.appliedDirectivesOf('federationTag').toString()).toStrictEqual('@federationTag(name: "Important")');
+    expect(typeT.field('y')?.appliedDirectivesOf('federationTag').toString()).toStrictEqual('@federationTag(name: "Less Important")');
+  });
+
+  it('handles fed1 schema', async () => {
+    const subgraphA = {
+      name: 'A',
+      url: 'https://A',
+      typeDefs: gql`
+        type Query {
+          t: T
+        }
+
+        type T @key(fields: "k") {
+          k: ID
+          x: Int
+        }
+      `,
+      resolvers: {
+        Query: {
+          t: () => ({
+            k: 42,
+            x: 1
+          }),
+        }
+      }
+    };
+
+    const subgraphB = {
+      name: 'B',
+      url: 'https://B',
+      typeDefs: gql`
+        type T @key(fields: "k") {
+          k: ID
+          y: Int
+        }
+      `,
+      resolvers: {
+        T: {
+          __resolveReference: ({ k }: { k: string }) => {
+            return k === '42' ? ({ y: 2 }) : undefined;
+          },
+        }
+      }
+    };
+
+    await startServicesAndGateway([subgraphA, subgraphB]);
+
+    const query = `
+      {
+        t {
+          x
+          y
+        }
+      }
+    `;
+
+    const response = await queryGateway(query);
+    const result = await response.json();
+    expect(result).toMatchInlineSnapshot(`
+      Object {
+        "data": Object {
+          "t": Object {
+            "x": 1,
+            "y": 2,
+          },
+        },
+      }
+    `);
+  });
+
+  it('removals of @inaccessible', async () => {
+    const subgraphA = {
+      name: 'A',
+      url: 'https://A',
+      typeDefs: gql`
+        extend schema
+          @link(
+            url: "https://specs.apollo.dev/federation/v2.0",
+            import: [ "@key", "@shareable", "@inaccessible"]
+          )
+
+        type Query {
+          t: T
+          f(e: E): Int
+        }
+
+        enum E {
+          FOO
+          BAR @inaccessible
+        }
+
+        type T @key(fields: "k") {
+          k: ID
+          a: Int @inaccessible
+          b: Int
+          c: String @shareable
+        }
+      `,
+      resolvers: {
+        Query: {
+          t: () => ({
+            k: 42,
+            a: 1,
+            b: 2,
+            c: 3,
+          }),
+          f: (_: any, args: any) => {
+            return args.e === 'FOO' ? 0 : 1;
+          }
+        }
+      }
+    };
+
+    const subgraphB = {
+      name: 'B',
+      url: 'https://B',
+      typeDefs: gql`
+        extend schema
+          @link(
+            url: "https://specs.apollo.dev/federation/v2.0",
+            import: [ "@key", "@shareable", "@inaccessible" ]
+          )
+
+        type T @key(fields: "k") {
+          k: ID
+          c: String @shareable @inaccessible
+          d: String
+        }
+      `,
+      resolvers: {
+        T: {
+          __resolveReference: ({ k }: { k: string }) => {
+            return k === '42' ? ({ c: 'foo', d: 'bar' }) : undefined;
+          },
+        }
+      }
+    };
+
+    await startServicesAndGateway([subgraphA, subgraphB]);
+
+    const q1 = `
+      {
+        t {
+          b
+          d
+        }
+        f(e: FOO)
+      }
+    `;
+
+    const resp1 = await queryGateway(q1);
+    const res1 = await resp1.json();
+    expect(res1).toMatchInlineSnapshot(`
+      Object {
+        "data": Object {
+          "f": 0,
+          "t": Object {
+            "b": 2,
+            "d": "bar",
+          },
+        },
+      }
+    `);
+
+    // Make sure the exposed API doesn't have any @inaccessible elements.
+    expect(printSchema(gateway.schema!)).toMatchInlineSnapshot(`
+      "enum E {
+        FOO
+      }
+
+      type Query {
+        t: T
+        f(e: E): Int
+      }
+
+      type T {
+        k: ID
+        b: Int
+        d: String
+      }"
+    `);
+
+    // Lastly, make sure querying inaccessible things is rejected
+    const q2 = `
+      {
+        f(e: BAR)
+      }
+    `;
+    const resp2 = await queryGateway(q2);
+    const res2 = await resp2.json();
+    expect(res2).toMatchInlineSnapshot(`
+      Object {
+        "errors": Array [
+          Object {
+            "extensions": Object {
+              "code": "GRAPHQL_VALIDATION_FAILED",
+            },
+            "message": "Value \\"BAR\\" does not exist in \\"E\\" enum.",
+          },
+        ],
+      }
+    `);
+
+    const q3 = `
+      {
+        t {
+          a
+        }
+      }
+    `;
+    const resp3 = await queryGateway(q3);
+    const res3 = await resp3.json();
+    expect(res3).toMatchInlineSnapshot(`
+      Object {
+        "errors": Array [
+          Object {
+            "extensions": Object {
+              "code": "GRAPHQL_VALIDATION_FAILED",
+            },
+            "message": "Cannot query field \\"a\\" on type \\"T\\". Did you mean \\"b\\", \\"d\\", or \\"k\\"?",
+          },
+        ],
+      }
+    `);
+  });
+})

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

@@ -2,7 +2,7 @@ import { fetch } from '../../__mocks__/make-fetch-happen-fetcher';
 import gql from 'graphql-tag';
 import { ApolloGateway } from '../../';
 import { fixtures } from 'apollo-federation-integration-testsuite';
-import { Logger } from 'apollo-server-types';
+import type { Logger } from '@apollo/utils.logger';
 
 let logger: {
   warn: jest.MockedFunction<Logger['warn']>,

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

@@ -0,0 +1,37 @@
+import { ApolloGateway } from '@apollo/gateway';
+import resolvable from '@josephg/resolvable';
+import { GraphQLSchema } from 'graphql';
+import { getTestingSupergraphSdl } from '../execution-utils';
+const { version } = require('../../../package.json');
+
+describe('addExtensions', () => {
+  let gateway: ApolloGateway;
+
+  beforeEach(() => {
+    gateway = new ApolloGateway({
+      supergraphSdl: getTestingSupergraphSdl(),
+    });
+  });
+
+  afterEach(async () => {
+    await gateway.stop();
+  });
+
+  it('has extensions on loaded schemas', async () => {
+    const { schema } = await gateway.load();
+    expect(schema.extensions).toEqual({ apollo: { gateway: { version: version } } });
+  });
+
+  it('has extensions on schema updates', async () => {
+    const schemaChangeBlocker = resolvable<{
+      apiSchema: GraphQLSchema;
+      coreSupergraphSdl: string;
+    }>();
+
+    gateway.onSchemaLoadOrUpdate(schemaChangeBlocker.resolve);
+    gateway.load();
+
+    const { apiSchema } = await schemaChangeBlocker;
+    expect(apiSchema.extensions).toEqual({ apollo: { gateway: { version: version } } });
+  });
+});

package/src/__tests__/gateway/lifecycle-hooks.test.ts

@@ -16,9 +16,9 @@ import {
   fixtures,
   fixturesWithUpdate,
 } from 'apollo-federation-integration-testsuite';
-import { Logger } from 'apollo-server-types';
+import { createHash } from '@apollo/utils.createhash';
+import type { Logger } from '@apollo/utils.logger';
 import resolvable from '@josephg/resolvable';
-import { createHash } from '../../utilities/createHash';
 import { getTestingSupergraphSdl } from '../execution-utils';
 
 // The order of this was specified to preserve existing test coverage. Typically

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

@@ -13,7 +13,7 @@ import { Plugin, Config, Refs } from 'pretty-format';
 import { Report, Trace } from 'apollo-reporting-protobuf';
 import { fixtures } from 'apollo-federation-integration-testsuite';
 import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
-import { GraphQLSchemaModule } from '../../schema-helper';
+import { GraphQLSchemaModule } from '@apollo/subgraph/src/schema-helper';
 import resolvable, { Resolvable } from '@josephg/resolvable';
 
 // Normalize specific fields that change often (eg timestamps) to static values,

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

@@ -5,9 +5,9 @@ import {
   SupergraphSdlUpdateFunction,
 } from '@apollo/gateway';
 import { fixturesWithUpdate } from 'apollo-federation-integration-testsuite';
-import { createHash } from '../../utilities/createHash';
+import { createHash } from '@apollo/utils.createhash';
 import { ApolloServer } from 'apollo-server';
-import { Logger } from 'apollo-server-types';
+import type { Logger } from '@apollo/utils.logger';
 import { fetch } from '../../__mocks__/make-fetch-happen-fetcher';
 import { getTestingSupergraphSdl } from '../execution-utils';
 import { mockAllServicesHealthCheckSuccess } from '../integration/nockMocks';

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

@@ -1,7 +1,7 @@
 import gql from 'graphql-tag';
 import http from 'http';
 import mockedEnv from 'mocked-env';
-import { Logger } from 'apollo-server-types';
+import type { Logger } from '@apollo/utils.logger';
 import { ApolloGateway } from '../..';
 import {
   mockSdlQuerySuccess,

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

@@ -1,5 +1,5 @@
 import { ApolloGateway } from '../..';
-import { Logger } from "apollo-server-types";
+import type { Logger } from '@apollo/utils.logger';
 import { PassThrough } from "stream";
 
 import * as winston from "winston";

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

@@ -1,7 +1,7 @@
 import gql from 'graphql-tag';
 import { GraphQLObjectType, GraphQLSchema } from 'graphql';
 import mockedEnv from 'mocked-env';
-import { Logger } from 'apollo-server-types';
+import type { Logger } from '@apollo/utils.logger';
 import { ApolloGateway } from '../..';
 import {
   mockSdlQuerySuccess,

package/src/config.ts

@@ -1,10 +1,8 @@
 import { GraphQLError, GraphQLSchema } from 'graphql';
 import { HeadersInit } from 'node-fetch';
 import { fetch } from 'apollo-server-env';
-import {
-  GraphQLRequestContextExecutionDidStart,
-  Logger,
-} from 'apollo-server-types';
+import { GraphQLRequestContextExecutionDidStart } from 'apollo-server-types';
+import type { Logger } from '@apollo/utils.logger';
 import { GraphQLDataSource } from './datasources/types';
 import { QueryPlan } from '@apollo/query-planner';
 import { OperationContext } from './operationContext';

package/src/datasources/RemoteGraphQLDataSource.ts

@@ -15,7 +15,7 @@ import {
 import { fetch, Request, Headers, Response } from 'apollo-server-env';
 import { isObject } from '../utilities/predicates';
 import { GraphQLDataSource, GraphQLDataSourceProcessOptions, GraphQLDataSourceRequestKind } from './types';
-import createSHA from 'apollo-server-core/dist/utils/createSHA';
+import { createHash } from '@apollo/utils.createhash';
 import { parseCacheControlHeader } from './parseCacheControlHeader';
 import fetcher from 'make-fetch-happen';
 export class RemoteGraphQLDataSource<
@@ -112,7 +112,7 @@ export class RemoteGraphQLDataSource<
         : null;
 
     if (this.apq) {
-      const apqHash = createSHA('sha256').update(request.query).digest('hex');
+      const apqHash = createHash('sha256').update(request.query).digest('hex');
 
       // Take the original extensions and extend them with
       // the necessary "extensions" for APQ handshaking.

package/src/datasources/__tests__/LocalGraphQLDataSource.test.ts

@@ -1,7 +1,7 @@
 import { LocalGraphQLDataSource } from '../LocalGraphQLDataSource';
 import { buildSubgraphSchema } from '@apollo/subgraph';
 import gql from 'graphql-tag';
-import { GraphQLResolverMap } from '../../schema-helper';
+import { GraphQLResolverMap } from '@apollo/subgraph/src/schema-helper';
 import { GraphQLRequestContext } from 'apollo-server-types';
 import { GraphQLDataSourceRequestKind } from '../types';
 

package/src/index.ts

@@ -2,9 +2,10 @@ import { deprecate } from 'util';
 import { GraphQLService, Unsubscriber } from 'apollo-server-core';
 import {
   GraphQLExecutionResult,
-  Logger,
   GraphQLRequestContextExecutionDidStart,
 } from 'apollo-server-types';
+import { createHash } from '@apollo/utils.createhash';
+import type { Logger } from '@apollo/utils.logger';
 import { InMemoryLRUCache } from 'apollo-server-caching';
 import {
   isObjectType,
@@ -53,14 +54,19 @@ import {
 } from './config';
 import { SpanStatusCode } from '@opentelemetry/api';
 import { OpenTelemetrySpanNames, tracer } from './utilities/opentelemetry';
-import { createHash } from './utilities/createHash';
+import { addExtensions } from './schema-helper/addExtensions';
 import {
   IntrospectAndCompose,
   UplinkFetcher,
   LegacyFetcher,
   LocalCompose,
 } from './supergraphManagers';
-import { buildSupergraphSchema, operationFromDocument, Schema, ServiceDefinition } from '@apollo/federation-internals';
+import {
+  buildSupergraphSchema,
+  operationFromDocument,
+  Schema,
+  ServiceDefinition,
+} from '@apollo/federation-internals';
 
 type DataSourceMap = {
   [serviceName: string]: { url?: string; dataSource: GraphQLDataSource };
@@ -426,6 +432,8 @@ export class ApolloGateway implements GraphQLService {
       }`,
     );
 
+    addExtensions(this.schema!);
+
     return {
       schema: this.schema!,
       executor: this.executor,
@@ -635,8 +643,8 @@ export class ApolloGateway implements GraphQLService {
   ): void {
     if (this.queryPlanStore) this.queryPlanStore.flush();
     this.apiSchema = coreSchema.toAPISchema();
-    this.schema = wrapSchemaWithAliasResolver(
-      this.apiSchema.toGraphQLJSSchema(),
+    this.schema = addExtensions(
+      wrapSchemaWithAliasResolver(this.apiSchema.toGraphQLJSSchema()),
     );
     this.queryPlanner = new QueryPlanner(coreSchema);
 

package/src/schema-helper/__tests__/addExtensions.test.ts

@@ -0,0 +1,11 @@
+import { buildSchema } from 'graphql';
+import { addExtensions } from '../addExtensions';
+const { version } = require('../../../package.json');
+
+describe('addExtensions', () => {
+  it('adds gateway extensions to a schema', async () => {
+    const schema = buildSchema('type Query { hello: String }');
+    expect(schema.extensions).toEqual({});
+    expect(addExtensions(schema).extensions).toEqual({ apollo: { gateway: { version: version } } });
+  });
+});

package/src/schema-helper/addExtensions.ts

@@ -0,0 +1,17 @@
+import { GraphQLSchema } from 'graphql';
+const { version } = require('../../package.json');
+
+export function addExtensions(schema: GraphQLSchema): GraphQLSchema {
+  schema.extensions = {
+    ...schema.extensions,
+    apollo: {
+      ...schema.extensions.apollo,
+      gateway: {
+        ...schema.extensions.apollo?.gateway,
+        version,
+      }
+    },
+  };
+
+  return schema;
+}

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

@@ -9,7 +9,7 @@ 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';
+import type { Logger } from '@apollo/utils.logger';
 
 describe('IntrospectAndCompose', () => {
   beforeEach(nockBeforeEach);