@apollo/gateway 2.0.0-alpha.0 → 2.0.0-alpha.4

package/src/supergraphManagers/UplinkFetcher/outOfBandReporter.ts

@@ -0,0 +1,126 @@
+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 async function submitOutOfBandReportIfConfigured({
+  error,
+  request,
+  endpoint,
+  response,
+  startedAt,
+  endedAt,
+  tags,
+  fetcher,
+}: {
+  error: Error;
+  request: Request;
+  endpoint: string | undefined;
+  response?: Response;
+  startedAt: Date;
+  endedAt: Date;
+  tags?: string[];
+  fetcher: typeof fetch;
+}) {
+  // don't send report if the endpoint url is not configured
+  if (!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(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/supergraphManagers/index.ts

@@ -0,0 +1,4 @@
+export { LocalCompose } from './LocalCompose';
+export { LegacyFetcher } from './LegacyFetcher';
+export { IntrospectAndCompose } from './IntrospectAndCompose';
+export { UplinkFetcher } from './UplinkFetcher';

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

@@ -1,6 +1,6 @@
-import { execute, GraphQLError, parse } from "graphql";
-import { cleanErrorOfInaccessibleNames } from "../cleanErrorOfInaccessibleNames";
-import { buildSchema } from "@apollo/federation-internals";
+import { execute, GraphQLError, parse } from 'graphql';
+import { cleanErrorOfInaccessibleNames } from '../cleanErrorOfInaccessibleNames';
+import { buildSchema } from '@apollo/federation-internals';
 
 describe('cleanErrorOfInaccessibleNames', () => {
   const coreSchema = buildSchema(`
@@ -49,19 +49,22 @@ describe('cleanErrorOfInaccessibleNames', () => {
   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 result = await execute({
+      schema,
+      document: parse('{fooField{someField}}'),
+      rootValue: {
+        fooField: {
+          __typename: 'Bar',
+          someField: 'test',
+        },
       },
     });
 
-    const cleaned = cleanErrorOfInaccessibleNames(schema, result.errors?.[0]!);
+    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."`,
+      `"Abstract type \\"Foo\\" was resolved to a type [inaccessible type] that does not exist inside the 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".`,

package/src/utilities/array.ts

@@ -27,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/createHash.ts

@@ -0,0 +1,10 @@
+import isNodeLike from './isNodeLike';
+
+export function createHash (kind: string): import('crypto').Hash {
+  if (isNodeLike) {
+    // Use module.require instead of just require to avoid bundling whatever
+    // crypto polyfills a non-Node bundler might fall back to.
+    return module.require('crypto').createHash(kind);
+  }
+  return require('sha.js')(kind);
+}

package/src/utilities/isNodeLike.ts

@@ -0,0 +1,11 @@
+export default typeof process === 'object' &&
+  process &&
+  // We used to check `process.release.name === "node"`, however that doesn't
+  // account for certain forks of Node.js which are otherwise identical to
+  // Node.js.  For example, NodeSource's N|Solid reports itself as "nsolid",
+  // though it's mostly the same build of Node.js with an extra addon.
+  process.release &&
+  process.versions &&
+  // The one thing which is present on both Node.js and N|Solid (a fork of
+  // Node.js), is `process.versions.node` being defined.
+  typeof process.versions.node === 'string';