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

package/src/loadServicesFromRemoteEndpoint.ts

@@ -1,23 +1,26 @@
 import { GraphQLRequest } from 'apollo-server-types';
 import { parse } from 'graphql';
 import { Headers, HeadersInit } from 'node-fetch';
-import { GraphQLDataSource } from './datasources/types';
-import { Experimental_UpdateServiceDefinitions, SERVICE_DEFINITION_QUERY } from './';
-import { ServiceDefinition } from '@apollo/federation';
+import { GraphQLDataSource, GraphQLDataSourceRequestKind } from './datasources/types';
+import { SERVICE_DEFINITION_QUERY } from './';
+import { CompositionUpdate, ServiceEndpointDefinition } from './config';
+import { ServiceDefinition } from '@apollo/federation-internals';
+
+type Service = ServiceEndpointDefinition & {
+  dataSource: GraphQLDataSource;
+};
 
 export async function getServiceDefinitionsFromRemoteEndpoint({
   serviceList,
-  headers = {},
+  getServiceIntrospectionHeaders,
   serviceSdlCache,
 }: {
-  serviceList: {
-    name: string;
-    url?: string;
-    dataSource: GraphQLDataSource;
-  }[];
-  headers?: HeadersInit;
+  serviceList: Service[];
+  getServiceIntrospectionHeaders: (
+    service: ServiceEndpointDefinition,
+  ) => Promise<HeadersInit | undefined>;
   serviceSdlCache: Map<string, string>;
-}): ReturnType<Experimental_UpdateServiceDefinitions> {
+}): Promise<CompositionUpdate> {
   if (!serviceList || !serviceList.length) {
     throw new Error(
       'Tried to load services from remote endpoints but none provided',
@@ -26,7 +29,7 @@ export async function getServiceDefinitionsFromRemoteEndpoint({
 
   let isNewSchema = false;
   // for each service, fetch its introspection schema
-  const promiseOfServiceList = serviceList.map(({ name, url, dataSource }) => {
+  const promiseOfServiceList = serviceList.map(async ({ name, url, dataSource }) => {
     if (!url) {
       throw new Error(
         `Tried to load schema for '${name}' but no 'url' was specified.`);
@@ -37,12 +40,16 @@ export async function getServiceDefinitionsFromRemoteEndpoint({
       http: {
         url,
         method: 'POST',
-        headers: new Headers(headers),
+        headers: new Headers(await getServiceIntrospectionHeaders({ name, url })),
       },
     };
 
     return dataSource
-      .process({ request, context: {} })
+      .process({
+        kind: GraphQLDataSourceRequestKind.LOADING_SCHEMA,
+        request,
+        context: {},
+      })
       .then(({ data, errors }): ServiceDefinition => {
         if (data && !errors) {
           const typeDefs = data._service.sdl as string;
@@ -60,12 +67,12 @@ export async function getServiceDefinitionsFromRemoteEndpoint({
           };
         }
 
-        throw new Error(errors?.map(e => e.message).join("\n"));
+        throw new Error(errors?.map((e) => e.message).join('\n'));
       })
-      .catch(err => {
+      .catch((err) => {
         const errorMessage =
           `Couldn't load service definitions for "${name}" at ${url}` +
-          (err && err.message ? ": " + err.message || err : "");
+          (err && err.message ? ': ' + err.message || err : '');
 
         throw new Error(errorMessage);
       });

package/src/loadSupergraphSdlFromStorage.ts

@@ -0,0 +1,140 @@
+import { fetch, Response, Request } from 'apollo-server-env';
+import { GraphQLError } from 'graphql';
+import { OutOfBandReporter } from './outOfBandReporter';
+import { SupergraphSdlQuery } from './__generated__/graphqlTypes';
+
+// Magic /* GraphQL */ comment below is for codegen, do not remove
+export const SUPERGRAPH_SDL_QUERY = /* GraphQL */`#graphql
+  query SupergraphSdl($apiKey: String!, $ref: String!, $ifAfterId: ID) {
+    routerConfig(ref: $ref, apiKey: $apiKey, ifAfterId: $ifAfterId) {
+      __typename
+      ... on RouterConfigResult {
+        id
+        supergraphSdl: supergraphSDL
+      }
+      ... on FetchError {
+        code
+        message
+      }
+    }
+  }
+`;
+
+
+type SupergraphSdlQueryResult =
+  | SupergraphSdlQuerySuccess
+  | SupergraphSdlQueryFailure;
+
+interface SupergraphSdlQuerySuccess {
+  data: SupergraphSdlQuery;
+}
+
+interface SupergraphSdlQueryFailure {
+  data?: SupergraphSdlQuery;
+  errors: GraphQLError[];
+}
+
+const { name, version } = require('../package.json');
+
+const fetchErrorMsg = "An error occurred while fetching your schema from Apollo: ";
+
+export async function loadSupergraphSdlFromStorage({
+  graphRef,
+  apiKey,
+  endpoint,
+  fetcher,
+  compositionId,
+}: {
+  graphRef: string;
+  apiKey: string;
+  endpoint: string;
+  fetcher: typeof fetch;
+  compositionId: string | null;
+}) {
+  let result: Response;
+  const requestDetails = {
+    method: 'POST',
+    body: JSON.stringify({
+      query: SUPERGRAPH_SDL_QUERY,
+      variables: {
+        ref: graphRef,
+        apiKey,
+        ifAfterId: compositionId,
+      },
+    }),
+    headers: {
+      'apollographql-client-name': name,
+      'apollographql-client-version': version,
+      'user-agent': `${name}/${version}`,
+      'content-type': 'application/json',
+    },
+  };
+
+  const request: Request = new Request(endpoint, requestDetails);
+
+  const OOBReport = new OutOfBandReporter();
+  const startTime = new Date()
+  try {
+    result = await fetcher(endpoint, requestDetails);
+  } catch (e) {
+    const endTime = new Date();
+
+    await OOBReport.submitOutOfBandReportIfConfigured({
+      error: e,
+      request,
+      startedAt: startTime,
+      endedAt: endTime,
+      fetcher
+    });
+
+    throw new Error(fetchErrorMsg + (e.message ?? e));
+  }
+
+  const endTime = new Date();
+  let response: SupergraphSdlQueryResult;
+
+  if (result.ok || result.status === 400) {
+    try {
+      response = await result.json();
+    } catch (e) {
+      // Bad response
+      throw new Error(fetchErrorMsg + result.status + ' ' + e.message ?? e);
+    }
+
+    if ('errors' in response) {
+      throw new Error(
+        [fetchErrorMsg, ...response.errors.map((error) => error.message)].join(
+          '\n',
+        ),
+      );
+    }
+  } else {
+    await OOBReport.submitOutOfBandReportIfConfigured({
+      error: new Error(fetchErrorMsg + result.status + ' ' + result.statusText),
+      request,
+      response: result,
+      startedAt: startTime,
+      endedAt: endTime,
+      fetcher
+    });
+    throw new Error(fetchErrorMsg + result.status + ' ' + result.statusText);
+  }
+
+  const { routerConfig } = response.data;
+  if (routerConfig.__typename === 'RouterConfigResult') {
+    const {
+      id,
+      supergraphSdl,
+      // messages,
+    } = routerConfig;
+    return { id, supergraphSdl: supergraphSdl! };
+  } else if (routerConfig.__typename === 'FetchError') {
+    // FetchError case
+    const { code, message } = routerConfig;
+    throw new Error(`${code}: ${message}`);
+  } else if (routerConfig.__typename === 'Unchanged') {
+    return null;
+  } else {
+    throw new Error('Programming error: unhandled response failure');
+  }
+}

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>;
   }
@@ -52,7 +52,7 @@ declare module 'make-fetch-happen' {
   }
 
   let fetch: Fetcher & {
-    defaults(opts?: RequestInit & FetcherOptions): Fetcher;
+    defaults(opts?: RequestInit & FetcherOptions): typeof fetch;
   };
 
   export default fetch;

package/src/operationContext.ts

@@ -0,0 +1,70 @@
+import {
+  DocumentNode,
+  FragmentDefinitionNode,
+  GraphQLError,
+  GraphQLSchema,
+  Kind,
+  OperationDefinitionNode,
+} from 'graphql';
+
+type FragmentMap = { [fragmentName: string]: FragmentDefinitionNode };
+
+export type OperationContext = {
+  schema: GraphQLSchema;
+  operation: OperationDefinitionNode;
+  fragments: FragmentMap;
+};
+
+// Adapted from buildExecutionContext in graphql-js
+interface BuildOperationContextOptions {
+  schema: GraphQLSchema;
+  operationDocument: DocumentNode;
+  operationName?: string;
+}
+
+export function buildOperationContext({
+  schema,
+  operationDocument,
+  operationName,
+}: BuildOperationContextOptions): OperationContext {
+  let operation: OperationDefinitionNode | undefined;
+  let operationCount = 0;
+  const fragments: {
+    [fragmentName: string]: FragmentDefinitionNode;
+  } = Object.create(null);
+  operationDocument.definitions.forEach(definition => {
+    switch (definition.kind) {
+      case Kind.OPERATION_DEFINITION:
+        operationCount++;
+        if (!operationName && operationCount > 1) {
+          throw new GraphQLError(
+            'Must provide operation name if query contains ' +
+              'multiple operations.',
+          );
+        }
+        if (
+          !operationName ||
+          (definition.name && definition.name.value === operationName)
+        ) {
+          operation = definition;
+        }
+        break;
+      case Kind.FRAGMENT_DEFINITION:
+        fragments[definition.name.value] = definition;
+        break;
+    }
+  });
+  if (!operation) {
+    if (operationName) {
+      throw new GraphQLError(`Unknown operation named "${operationName}".`);
+    } else {
+      throw new GraphQLError('Must provide an operation.');
+    }
+  }
+
+  return {
+    schema,
+    operation,
+    fragments,
+  };
+}

package/src/outOfBandReporter.ts

@@ -0,0 +1,128 @@
+import { fetch, Response, Request } from 'apollo-server-env';
+import { GraphQLError } from 'graphql';
+import {
+  ErrorCode,
+  OobReportMutation,
+  OobReportMutationVariables,
+} from './__generated__/graphqlTypes';
+
+// Magic /* GraphQL */ comment below is for codegen, do not remove
+export const OUT_OF_BAND_REPORTER_QUERY = /* GraphQL */`#graphql
+  mutation OOBReport($input: APIMonitoringReport) {
+    reportError(report: $input)
+  }
+`;
+
+const { name, version } = require('../package.json');
+
+type OobReportMutationResult =
+  | OobReportMutationSuccess
+  | OobReportMutationFailure;
+
+interface OobReportMutationSuccess {
+  data: OobReportMutation;
+}
+
+interface OobReportMutationFailure {
+  data?: OobReportMutation;
+  errors: GraphQLError[];
+}
+export class OutOfBandReporter {
+  static endpoint: string | null = process.env.APOLLO_OUT_OF_BAND_REPORTER_ENDPOINT || null;
+
+  async submitOutOfBandReportIfConfigured({
+    error,
+    request,
+    response,
+    startedAt,
+    endedAt,
+    tags,
+    fetcher,
+  }: {
+    error: Error;
+    request: Request;
+    response?: Response;
+    startedAt: Date;
+    endedAt: Date;
+    tags?: string[];
+    fetcher: typeof fetch;
+  }) {
+
+    // don't send report if the endpoint url is not configured
+    if (!OutOfBandReporter.endpoint) {
+      return;
+    }
+
+    let errorCode: ErrorCode;
+    if (!response) {
+      errorCode = ErrorCode.ConnectionFailed;
+    } else {
+      // possible error situations to check against
+      switch (response.status) {
+        case 400:
+        case 413:
+        case 422:
+          errorCode = ErrorCode.InvalidBody;
+          break;
+        case 408:
+        case 504:
+          errorCode = ErrorCode.Timeout;
+          break;
+        case 502:
+        case 503:
+          errorCode = ErrorCode.ConnectionFailed;
+          break;
+        default:
+          errorCode = ErrorCode.Other;
+      }
+    }
+
+    const responseBody: string | undefined = await response?.text();
+
+    const variables: OobReportMutationVariables = {
+      input: {
+        error: {
+          code: errorCode,
+          message: error.message,
+        },
+        request: {
+          url: request.url,
+          body: await request.text(),
+        },
+        response: response
+          ? {
+              httpStatusCode: response.status,
+              body: responseBody,
+            }
+          : null,
+        startedAt: startedAt.toISOString(),
+        endedAt: endedAt.toISOString(),
+        tags: tags,
+      },
+    };
+
+    try {
+      const oobResponse = await fetcher(OutOfBandReporter.endpoint, {
+        method: 'POST',
+        body: JSON.stringify({
+          query: OUT_OF_BAND_REPORTER_QUERY,
+          variables,
+        }),
+        headers: {
+          'apollographql-client-name': name,
+          'apollographql-client-version': version,
+          'user-agent': `${name}/${version}`,
+          'content-type': 'application/json',
+        },
+      });
+      const parsedResponse: OobReportMutationResult = await oobResponse.json();
+      if (!parsedResponse?.data?.reportError) {
+        throw new Error(
+          `Out-of-band error reporting failed: ${oobResponse.status} ${oobResponse.statusText}`,
+        );
+      }
+    } catch (e) {
+      throw new Error(`Out-of-band error reporting failed: ${e.message ?? e}`);
+    }
+  }
+}

package/src/utilities/__tests__/cleanErrorOfInaccessibleElements.test.ts

@@ -0,0 +1,104 @@
+import { execute, GraphQLError, parse } from "graphql";
+import { cleanErrorOfInaccessibleNames } from "../cleanErrorOfInaccessibleNames";
+import { buildSchema } from "@apollo/federation-internals";
+
+describe('cleanErrorOfInaccessibleNames', () => {
+  const coreSchema = buildSchema(`
+    directive @core(
+      feature: String!,
+      as: String,
+      for: core__Purpose
+    ) repeatable on SCHEMA
+
+    directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION
+
+    schema
+      @core(feature: "https://specs.apollo.dev/core/v0.2")
+      @core(feature: "https://specs.apollo.dev/inaccessible/v0.1")
+    {
+      query: Query
+    }
+
+    enum core__Purpose {
+      EXECUTION
+      SECURITY
+    }
+
+    type Query {
+      fooField: Foo
+      bazField: Baz
+    }
+
+    interface Foo {
+      someField: String
+    }
+
+    type Bar implements Foo @inaccessible {
+      someField: String
+    }
+
+    type Bar2 @inaccessible {
+      anotherField: String
+    }
+
+    type Baz {
+      goodField: String
+      inaccessibleField: String @inaccessible
+    }
+  `);
+  const schema = coreSchema.toAPISchema().toGraphQLJSSchema();
+
+  it('removes inaccessible type names from error messages', async () => {
+    const result = await execute(schema, parse('{fooField{someField}}'), {
+      fooField: {
+        __typename: 'Bar',
+        someField: 'test',
+      },
+    });
+
+    const cleaned = cleanErrorOfInaccessibleNames(schema, result.errors![0]!);
+    expect(cleaned.message).toMatchInlineSnapshot(
+      `"Abstract type \\"Foo\\" was resolve to a type [inaccessible type] that does not exist inside schema."`,
+    );
+  });
+
+  it('removes multiple/repeated inaccessible type names from error messages', async () => {
+    const contrivedError = new GraphQLError(
+      `Something something "Bar" and "Bar" again, as well as "Bar2".`,
+    );
+    const cleaned = cleanErrorOfInaccessibleNames(schema, contrivedError);
+    expect(cleaned.message).toMatchInlineSnapshot(
+      `"Something something [inaccessible type] and [inaccessible type] again, as well as [inaccessible type]."`,
+    );
+  });
+
+  it('removes inaccessible field names from error messages', async () => {
+    const contrivedError = new GraphQLError(
+      `Can't query inaccessible field "Baz.inaccessibleField".`,
+    );
+    const cleaned = cleanErrorOfInaccessibleNames(schema, contrivedError);
+    expect(cleaned.message).toMatchInlineSnapshot(
+      `"Can't query inaccessible field [inaccessible field]."`,
+    );
+  });
+
+  it('removes multiple/repeated inaccessible field names from error messages', async () => {
+    const contrivedError = new GraphQLError(
+      `Can't query inaccessible field "Baz.inaccessibleField" and "Baz.inaccessibleField", as well as "Bar2.anotherField".`,
+    );
+    const cleaned = cleanErrorOfInaccessibleNames(schema, contrivedError);
+    expect(cleaned.message).toMatchInlineSnapshot(
+      `"Can't query inaccessible field [inaccessible field] and [inaccessible field], as well as [inaccessible field]."`,
+    );
+  });
+
+  it("doesn't remove special-case double-quoted words from graphql error messages", () => {
+    const graphqlError = new GraphQLError(
+      `Something something "resolveType" something something "isTypeOf".`,
+    );
+    const cleaned = cleanErrorOfInaccessibleNames(schema, graphqlError);
+    expect(cleaned.message).toMatchInlineSnapshot(
+      `"Something something \\"resolveType\\" something something \\"isTypeOf\\"."`,
+    );
+  });
+});

package/src/utilities/__tests__/tsconfig.json

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

package/src/utilities/array.ts

@@ -1,4 +1,8 @@
-import { isNotNullOrUndefined } from 'apollo-env';
+export function isNotNullOrUndefined<T>(
+  value: T | null | undefined,
+): value is T {
+  return value !== null && typeof value !== 'undefined';
+}
 
 export function compactMap<T, U>(
   array: T[],
@@ -16,32 +20,6 @@ export function compactMap<T, U>(
   );
 }
 
-export function partition<T, U extends T>(
-  array: T[],
-  predicate: (element: T, index: number, array: T[]) => element is U,
-): [U[], T[]];
-export function partition<T>(
-  array: T[],
-  predicate: (element: T, index: number, array: T[]) => boolean,
-): [T[], T[]];
-export function partition<T>(
-  array: T[],
-  predicate: (element: T, index: number, array: T[]) => boolean,
-): [T[], T[]] {
-  array.map;
-  return array.reduce(
-    (accumulator, element, index) => {
-      return (
-        predicate(element, index, array)
-          ? accumulator[0].push(element)
-          : accumulator[1].push(element),
-        accumulator
-      );
-    },
-    [[], []] as [T[], T[]],
-  );
-}
-
 export function findAndExtract<T>(
   array: T[],
   predicate: (element: T, index: number, array: T[]) => boolean,
@@ -49,7 +27,7 @@ export function findAndExtract<T>(
   const index = array.findIndex(predicate);
   if (index === -1) return [undefined, array];
 
-  let remaining = array.slice(0, index);
+  const remaining = array.slice(0, index);
   if (index < array.length - 1) {
     remaining.push(...array.slice(index + 1));
   }

package/src/utilities/assert.ts

@@ -0,0 +1,14 @@
+/**
+ * For lack of a "home of federation utilities", this function is copy/pasted
+ * verbatim across the federation, gateway, and query-planner packages. Any changes
+ * made here should be reflected in the other two locations as well.
+ *
+ * @param condition
+ * @param message
+ * @throws {@link Error}
+ */
+export function assert(condition: any, message: string): asserts condition {
+  if (!condition) {
+    throw new Error(message);
+  }
+}

package/src/utilities/cleanErrorOfInaccessibleNames.ts

@@ -0,0 +1,29 @@
+import { GraphQLError, GraphQLSchema } from 'graphql';
+
+export function cleanErrorOfInaccessibleNames(
+  schema: GraphQLSchema,
+  error: GraphQLError,
+): GraphQLError {
+
+  const typeDotFieldRegex = /"([_A-Za-z][_0-9A-Za-z]*)\.([_A-Za-z][_0-9A-Za-z]*)"/g;
+  error.message = error.message.replace(typeDotFieldRegex, (match: string) => {
+    const [typeName, fieldName] = match.replace(/"/g, '',).split('.');
+    const type = schema.getType(typeName);
+    if (!type) {
+      return '[inaccessible field]';
+    } else {
+      const field = 'getFields' in type ? type.getFields()[fieldName] : null;
+      return field ? match : '[inaccessible field]';
+    }
+  });
+
+  const typeRegex = /"([_A-Za-z][_0-9A-Za-z]*)"/g;
+  error.message = error.message.replace(typeRegex, (match: string) => {
+    // Special cases in graphql-js that happen to match our regex.
+    if (match === '"isTypeOf"' || match === '"resolveType"') return match;
+    const typeName = match.replace(/"/g, '',);
+    return schema.getType(typeName) ? match : '[inaccessible type]';
+  })
+
+  return error;
+}