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

package/src/legacyLoadServicesFromStorage.ts

@@ -1,170 +0,0 @@
-import { fetch } from 'apollo-server-env';
-import { parse } from 'graphql';
-import { ServiceDefinitionUpdate } from './config';
-
-interface LinkFileResult {
-  configPath: string;
-  formatVersion: number;
-}
-
-interface ImplementingService {
-  formatVersion: number;
-  graphID: string;
-  graphVariant: string;
-  name: string;
-  revision: string;
-  url: string;
-  partialSchemaPath: string;
-}
-
-interface ImplementingServiceLocation {
-  name: string;
-  path: string;
-}
-
-export interface CompositionMetadata {
-  formatVersion: number;
-  id: string;
-  implementingServiceLocations: ImplementingServiceLocation[];
-  schemaHash: string;
-}
-
-const envOverridePartialSchemaBaseUrl = 'APOLLO_PARTIAL_SCHEMA_BASE_URL';
-const envOverrideStorageSecretBaseUrl = 'APOLLO_STORAGE_SECRET_BASE_URL';
-
-const urlFromEnvOrDefault = (envKey: string, fallback: string) =>
-  (process.env[envKey] || fallback).replace(/\/$/, '');
-
-// Generate and cache our desired operation manifest URL.
-const urlPartialSchemaBase = urlFromEnvOrDefault(
-  envOverridePartialSchemaBaseUrl,
-  'https://federation.api.apollographql.com/',
-);
-
-const urlStorageSecretBase: string = urlFromEnvOrDefault(
-  envOverrideStorageSecretBaseUrl,
-  'https://storage-secrets.api.apollographql.com/',
-);
-
-function getStorageSecretUrl(graphId: string, apiKeyHash: string): string {
-  return `${urlStorageSecretBase}/${graphId}/storage-secret/${apiKeyHash}.json`;
-}
-
-function fetchApolloGcs(
-  fetcher: typeof fetch,
-  ...args: Parameters<typeof fetch>
-): ReturnType<typeof fetch> {
-  const [input, init] = args;
-
-  // Used in logging.
-  const url = (typeof input === 'object' && input.url) || input;
-
-  return fetcher(input, init)
-    .catch((fetchError) => {
-      throw new Error('Cannot access Apollo storage: ' + fetchError);
-    })
-    .then(async (response) => {
-      // If the fetcher has a cache and has implemented ETag validation, then
-      // a 304 response may be returned.  Either way, we will return the
-      // non-JSON-parsed version and let the caller decide if that's important
-      // to their needs.
-      if (response.ok || response.status === 304) {
-        return response;
-      }
-
-      // We won't make any assumptions that the body is anything but text, to
-      // avoid parsing errors in this unknown condition.
-      const body = await response.text();
-
-      // Google Cloud Storage returns an `application/xml` error under error
-      // conditions.  We'll special-case our known errors, and resort to
-      // printing the body for others.
-      if (response.status === 403 && body.includes('AccessDenied')) {
-        throw new Error(
-          'Unable to authenticate with Apollo storage ' +
-            'while fetching ' +
-            url +
-            '.  Ensure that the API key is ' +
-            'configured properly and that a federated service has been ' +
-            'pushed.  For details, see ' +
-            'https://go.apollo.dev/g/resolve-access-denied.',
-        );
-      }
-
-      // Normally, we'll try to keep the logs clean with errors we expect.
-      // If it's not a known error, reveal the full body for debugging.
-      throw new Error('Could not communicate with Apollo storage: ' + body);
-    });
-}
-
-export async function getServiceDefinitionsFromStorage({
-  graphRef,
-  apiKeyHash,
-  federationVersion,
-  fetcher,
-}: {
-  graphRef: string;
-  apiKeyHash: string;
-  federationVersion: number;
-  fetcher: typeof fetch;
-}): Promise<ServiceDefinitionUpdate> {
-  // The protocol for talking to GCS requires us to split the graph ref
-  // into ID and variant; sigh.
-  const at = graphRef.indexOf('@');
-  const graphId = at === -1 ? graphRef : graphRef.substring(0, at);
-  const graphVariant = at === -1 ? 'current' : graphRef.substring(at + 1);
-
-  // fetch the storage secret
-  const storageSecretUrl = getStorageSecretUrl(graphId, apiKeyHash);
-
-  // The storage secret is a JSON string (e.g. `"secret"`).
-  const secret: string = await fetchApolloGcs(
-    fetcher,
-    storageSecretUrl,
-  ).then((res) => res.json());
-
-  const baseUrl = `${urlPartialSchemaBase}/${secret}/${graphVariant}/v${federationVersion}`;
-
-  const compositionConfigResponse = await fetchApolloGcs(
-    fetcher,
-    `${baseUrl}/composition-config-link`,
-  );
-
-  if (compositionConfigResponse.status === 304) {
-    return { isNewSchema: false };
-  }
-
-  const linkFileResult: LinkFileResult = await compositionConfigResponse.json();
-
-  const compositionMetadata: CompositionMetadata = await fetchApolloGcs(
-    fetcher,
-    `${urlPartialSchemaBase}/${linkFileResult.configPath}`,
-  ).then((res) => res.json());
-
-  // It's important to maintain the original order here
-  const serviceDefinitions = await Promise.all(
-    compositionMetadata.implementingServiceLocations.map(
-      async ({ name, path }) => {
-        const { url, partialSchemaPath }: ImplementingService = await fetcher(
-          `${urlPartialSchemaBase}/${path}`,
-        ).then((response) => response.json());
-
-        const sdl = await fetcher(
-          `${urlPartialSchemaBase}/${partialSchemaPath}`,
-        ).then((response) => response.text());
-
-        return { name, url, typeDefs: parse(sdl) };
-      },
-    ),
-  );
-
-  // explicity return that this is a new schema, as the link file has changed.
-  // we can't use the hit property of the fetchPartialSchemaFiles, as the partial
-  // schema may all be cache hits with the final schema still being new
-  // (for instance if a partial schema is removed or a partial schema is rolled back to a prior version, which is still in cache)
-  return {
-    serviceDefinitions,
-    compositionMetadata,
-    isNewSchema: true,
-  };
-}

package/src/outOfBandReporter.ts

@@ -1,128 +0,0 @@
-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}`);
-    }
-  }
-}