@depup/apollo__server 5.5.0-depup.0

package/src/cachePolicy.ts

@@ -0,0 +1,33 @@
+import type { CacheHint, CachePolicy } from '@apollo/cache-control-types';
+
+export function newCachePolicy(): CachePolicy {
+  return {
+    maxAge: undefined,
+    scope: undefined,
+    restrict(hint: CacheHint) {
+      if (
+        hint.maxAge !== undefined &&
+        (this.maxAge === undefined || hint.maxAge < this.maxAge)
+      ) {
+        this.maxAge = hint.maxAge;
+      }
+      if (hint.scope !== undefined && this.scope !== 'PRIVATE') {
+        this.scope = hint.scope;
+      }
+    },
+    replace(hint: CacheHint) {
+      if (hint.maxAge !== undefined) {
+        this.maxAge = hint.maxAge;
+      }
+      if (hint.scope !== undefined) {
+        this.scope = hint.scope;
+      }
+    },
+    policyIfCacheable() {
+      if (this.maxAge === undefined || this.maxAge === 0) {
+        return null;
+      }
+      return { maxAge: this.maxAge, scope: this.scope ?? 'PUBLIC' };
+    },
+  };
+}

package/src/determineApolloConfig.ts

@@ -0,0 +1,95 @@
+import { createHash } from '@apollo/utils.createhash';
+import type { ApolloConfig, ApolloConfigInput } from './externalTypes/index.js';
+import type { Logger } from '@apollo/utils.logger';
+
+// This function combines the `apollo` constructor argument and some environment
+// variables to come up with a full ApolloConfig.
+export function determineApolloConfig(
+  input: ApolloConfigInput | undefined,
+  logger: Logger,
+): ApolloConfig {
+  const apolloConfig: ApolloConfig = {};
+
+  const {
+    APOLLO_KEY,
+    APOLLO_GRAPH_REF,
+    APOLLO_GRAPH_ID,
+    APOLLO_GRAPH_VARIANT,
+  } = process.env;
+
+  // Determine key.
+  if (input?.key) {
+    apolloConfig.key = input.key.trim();
+  } else if (APOLLO_KEY) {
+    apolloConfig.key = APOLLO_KEY.trim();
+  }
+  if ((input?.key ?? APOLLO_KEY) !== apolloConfig.key) {
+    logger.warn(
+      'The provided API key has unexpected leading or trailing whitespace. ' +
+        'Apollo Server will trim the key value before use.',
+    );
+  }
+
+  // Assert API key is a valid header value, since it's going to be used as one
+  // throughout.
+  if (apolloConfig.key) {
+    assertValidHeaderValue(apolloConfig.key);
+  }
+
+  // Determine key hash.
+  if (apolloConfig.key) {
+    apolloConfig.keyHash = createHash('sha512')
+      .update(apolloConfig.key)
+      .digest('hex');
+  }
+
+  // Determine graph ref, if provided together.
+  if (input?.graphRef) {
+    apolloConfig.graphRef = input.graphRef;
+  } else if (APOLLO_GRAPH_REF) {
+    apolloConfig.graphRef = APOLLO_GRAPH_REF;
+  }
+
+  // See if graph ID and variant were provided separately.
+  const graphId = input?.graphId ?? APOLLO_GRAPH_ID;
+  const graphVariant = input?.graphVariant ?? APOLLO_GRAPH_VARIANT;
+
+  if (apolloConfig.graphRef) {
+    if (graphId) {
+      throw new Error(
+        'Cannot specify both graph ref and graph ID. Please use ' +
+          '`apollo.graphRef` or `APOLLO_GRAPH_REF` without also setting the graph ID.',
+      );
+    }
+    if (graphVariant) {
+      throw new Error(
+        'Cannot specify both graph ref and graph variant. Please use ' +
+          '`apollo.graphRef` or `APOLLO_GRAPH_REF` without also setting the graph variant.',
+      );
+    }
+  } else if (graphId) {
+    // Graph ref is not specified, but the ID is. We can construct the ref
+    // from the ID and variant. Note that after this, we stop tracking the ID
+    // and variant, because Apollo Server 3 does not assume that all graph refs
+    // can be decomposed into ID and variant (except in the op reg plugin).
+    apolloConfig.graphRef = graphVariant
+      ? `${graphId}@${graphVariant}`
+      : graphId;
+  }
+
+  return apolloConfig;
+}
+
+function assertValidHeaderValue(value: string) {
+  // Ref: node-fetch@2.x `Headers` validation
+  // https://github.com/node-fetch/node-fetch/blob/9b9d45881e5ca68757077726b3c0ecf8fdca1f29/src/headers.js#L18
+  const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/g;
+  if (invalidHeaderCharRegex.test(value)) {
+    const invalidChars = value.match(invalidHeaderCharRegex)!;
+    throw new Error(
+      `The API key provided to Apollo Server contains characters which are invalid as HTTP header values. The following characters found in the key are invalid: ${invalidChars.join(
+        ', ',
+      )}. Valid header values may only contain ASCII visible characters. If you think there is an issue with your key, please contact Apollo support.`,
+    );
+  }
+}

package/src/errorNormalize.ts

@@ -0,0 +1,114 @@
+// The functions in this file are not part of Apollo Server's external API.
+
+import {
+  GraphQLError,
+  type GraphQLErrorExtensions,
+  type GraphQLFormattedError,
+} from 'graphql';
+import { ApolloServerErrorCode } from './errors/index.js';
+import type { HTTPGraphQLHead } from './externalTypes/http.js';
+import { mergeHTTPGraphQLHead, newHTTPGraphQLHead } from './runHttpQuery.js';
+import { HeaderMap } from './utils/HeaderMap.js';
+
+// This function accepts any value that were thrown and convert it to GraphQLFormattedError.
+// It also add default extensions.code and copy stack trace onto an extension if requested.
+// Additionally, it returns an `HTTPGraphQLHead` created from combining the values of any
+// `HTTPGraphqlHead` objects found on `extensions.http` (the behavior when multiple errors
+// set a status code or set the same header should be treated as undefined); these extensions
+// are removed from the formatted error.
+//
+// This function should not throw.
+export function normalizeAndFormatErrors(
+  errors: ReadonlyArray<unknown>,
+  options: {
+    formatError?: (
+      formattedError: GraphQLFormattedError,
+      error: unknown,
+    ) => GraphQLFormattedError;
+    includeStacktraceInErrorResponses?: boolean;
+  } = {},
+): {
+  formattedErrors: Array<GraphQLFormattedError>;
+  httpFromErrors: HTTPGraphQLHead;
+} {
+  const formatError = options.formatError ?? ((error) => error);
+  const httpFromErrors = newHTTPGraphQLHead();
+
+  return {
+    httpFromErrors,
+    formattedErrors: errors.map((error) => {
+      try {
+        return formatError(enrichError(error), error);
+      } catch (formattingError) {
+        if (options.includeStacktraceInErrorResponses) {
+          // includeStacktraceInErrorResponses is used in development
+          // so it will be helpful to show errors thrown by formatError hooks in that mode
+          return enrichError(formattingError);
+        } else {
+          // obscure error
+          return {
+            message: 'Internal server error',
+            extensions: { code: ApolloServerErrorCode.INTERNAL_SERVER_ERROR },
+          };
+        }
+      }
+    }),
+  };
+
+  function enrichError(maybeError: unknown): GraphQLFormattedError {
+    const graphqlError = ensureGraphQLError(maybeError);
+
+    const extensions: GraphQLErrorExtensions = {
+      ...graphqlError.extensions,
+      code:
+        graphqlError.extensions.code ??
+        ApolloServerErrorCode.INTERNAL_SERVER_ERROR,
+    };
+
+    if (isPartialHTTPGraphQLHead(extensions.http)) {
+      mergeHTTPGraphQLHead(httpFromErrors, {
+        headers: new HeaderMap(),
+        ...extensions.http,
+      });
+      delete extensions.http;
+    }
+
+    if (options.includeStacktraceInErrorResponses) {
+      // Note that if ensureGraphQLError created graphqlError from an
+      // originalError, graphqlError.stack will be the same as
+      // originalError.stack due to some special code in the GraphQLError
+      // constructor.
+      extensions.stacktrace = graphqlError.stack?.split('\n');
+    }
+
+    return { ...graphqlError.toJSON(), extensions };
+  }
+}
+
+export function ensureError(maybeError: unknown): Error {
+  return maybeError instanceof Error
+    ? maybeError
+    : new GraphQLError('Unexpected error value: ' + String(maybeError));
+}
+
+export function ensureGraphQLError(
+  maybeError: unknown,
+  messagePrefixIfNotGraphQLError: string = '',
+): GraphQLError {
+  const error: Error = ensureError(maybeError);
+
+  return error instanceof GraphQLError
+    ? error
+    : new GraphQLError(messagePrefixIfNotGraphQLError + error.message, {
+        originalError: error,
+      });
+}
+
+function isPartialHTTPGraphQLHead(x: unknown): x is Partial<HTTPGraphQLHead> {
+  return (
+    !!x &&
+    typeof x === 'object' &&
+    (!('status' in x) || typeof (x as any).status === 'number') &&
+    (!('headers' in x) || (x as any).headers instanceof Map)
+  );
+}

package/src/errors/index.ts

@@ -0,0 +1,33 @@
+import { GraphQLError } from 'graphql';
+
+export enum ApolloServerErrorCode {
+  INTERNAL_SERVER_ERROR = 'INTERNAL_SERVER_ERROR',
+  GRAPHQL_PARSE_FAILED = 'GRAPHQL_PARSE_FAILED',
+  GRAPHQL_VALIDATION_FAILED = 'GRAPHQL_VALIDATION_FAILED',
+  PERSISTED_QUERY_NOT_FOUND = 'PERSISTED_QUERY_NOT_FOUND',
+  PERSISTED_QUERY_NOT_SUPPORTED = 'PERSISTED_QUERY_NOT_SUPPORTED',
+  BAD_USER_INPUT = 'BAD_USER_INPUT',
+  OPERATION_RESOLUTION_FAILURE = 'OPERATION_RESOLUTION_FAILURE',
+  BAD_REQUEST = 'BAD_REQUEST',
+}
+
+export enum ApolloServerValidationErrorCode {
+  INTROSPECTION_DISABLED = 'INTROSPECTION_DISABLED',
+  MAX_RECURSIVE_SELECTIONS_EXCEEDED = 'MAX_RECURSIVE_SELECTIONS_EXCEEDED',
+}
+
+/**
+ * unwrapResolverError is a useful helper function for `formatError` hooks.
+ * Errors thrown in resolvers are wrapped by graphql-js in a GraphQLError that
+ * adds context such as the `path` to the field in the operation. If you'd like
+ * to look directly at the original error thrown in the resolver (with whatever
+ * data is on that error object, but without fields like `path`), you can use
+ * this function. Note that other GraphQLErrors that contain `originalError`
+ * (like parse errors) are not unwrapped by this function.
+ */
+export function unwrapResolverError(error: unknown): unknown {
+  if (error instanceof GraphQLError && error.path && error.originalError) {
+    return error.originalError;
+  }
+  return error;
+}

package/src/externalTypes/constructor.ts

@@ -0,0 +1,174 @@
+/**
+ * This file consists of types used to define the arguments to the ApolloServer
+ * constructor. The top-level and likely most interesting type exported from
+ * here is `ApolloServerOptions` which is used to define the input object to the
+ * `ApolloServer` constructor.
+ */
+import type { Logger } from '@apollo/utils.logger';
+import type { IExecutableSchemaDefinition } from '@graphql-tools/schema';
+import type {
+  DocumentNode,
+  ExecutionArgs,
+  FormattedExecutionResult,
+  GraphQLFieldResolver,
+  GraphQLFormattedError,
+  GraphQLSchema,
+  ParseOptions,
+  ValidationRule,
+} from 'graphql';
+import type { KeyValueCache } from '@apollo/utils.keyvaluecache';
+import type { GatewayInterface } from '@apollo/server-gateway-interface';
+import type { ApolloServerPlugin } from './plugins.js';
+import type {
+  BaseContext,
+  LegacyExperimentalExecuteIncrementally,
+} from './index.js';
+import type {
+  GraphQLExperimentalIncrementalExecutionResultsAlpha2,
+  GraphQLExperimentalIncrementalExecutionResultsAlpha9,
+} from '../incrementalDeliveryPolyfill.js';
+import type { ValidationOptions } from '../ApolloServer.js';
+
+export type DocumentStore = KeyValueCache<DocumentNode>;
+
+// Configuration for how Apollo Server talks to the Apollo registry, as passed
+// to the ApolloServer constructor. Each field can also be provided as an
+// environment variable.
+export interface ApolloConfigInput {
+  // Your Apollo API key. Environment variable: APOLLO_KEY.
+  key?: string;
+  // The graph ref for your graph, eg `my-graph@my-variant` or `my-graph` to use
+  // your graph's default variant. Environment variable: APOLLO_GRAPH_REF. For
+  // backwards compatibility, may alternatively specify the ref as graphId and
+  // graphVariant separately.
+  graphRef?: string;
+  // The graph ID of your graph, eg `my-graph`. Environment variable:
+  // APOLLO_GRAPH_ID.
+  graphId?: string;
+  // Your graph's variant name, eg `my-variant`. Environment variable:
+  // APOLLO_GRAPH_VARIANT.
+  graphVariant?: string;
+}
+
+// some defaults filled in from the ApolloConfigInput passed to the constructor.
+export interface ApolloConfig {
+  key?: string;
+  keyHash?: string;
+  graphRef?: string;
+}
+
+export interface PersistedQueryOptions {
+  cache?: KeyValueCache<string>;
+  /**
+   * Specified in **seconds**, this time-to-live (TTL) value limits the lifespan
+   * of how long the persisted query should be cached.  To specify a desired
+   * lifespan of "infinite", set this to `null`, in which case the eviction will
+   * be determined by the cache's eviction policy, but the record will never
+   * simply expire.
+   */
+  ttl?: number | null;
+}
+
+export interface CSRFPreventionOptions {
+  // CSRF prevention works by only processing operations from requests whose
+  // structure indicates that if they were sent by a web browser, then the
+  // browser would have had to send a preflight OPTIONS request already. We do
+  // this by specifying some headers that a browser will never automatically set
+  // and which will trigger the browser to preflight. Apollo Server will reject
+  // any operation that does not set at least one of these headers *and* does
+  // not set a content-type (to a header whose parsed type is not
+  // application/x-www-form-urlencoded, multipart/form-data, or text/plain). If
+  // CSRF prevention is enabled (eg, with `csrfPrevention: true`) this list
+  // defaults to ['x-apollo-operation-name', 'apollo-require-preflight']. This
+  // will allow POST operations from any client and GET operations from Apollo
+  // Client Web, Apollo iOS, and Apollo Kotlin.
+  requestHeaders?: string[];
+}
+
+interface ApolloServerOptionsBase<TContext extends BaseContext> {
+  formatError?: (
+    formattedError: GraphQLFormattedError,
+    error: unknown,
+  ) => GraphQLFormattedError;
+  rootValue?: ((parsedQuery: DocumentNode) => unknown) | unknown;
+  validationRules?: Array<ValidationRule>;
+  fieldResolver?: GraphQLFieldResolver<any, TContext>;
+  cache?: KeyValueCache<string> | 'bounded';
+  includeStacktraceInErrorResponses?: boolean;
+  logger?: Logger;
+  allowBatchedHttpRequests?: boolean;
+  stringifyResult?: (
+    value: FormattedExecutionResult,
+  ) => string | Promise<string>;
+  introspection?: boolean;
+  maxRecursiveSelections?: boolean | number;
+  hideSchemaDetailsFromClientErrors?: boolean;
+  plugins?: ApolloServerPlugin<TContext>[];
+  persistedQueries?: PersistedQueryOptions | false;
+  stopOnTerminationSignals?: boolean;
+  apollo?: ApolloConfigInput;
+  nodeEnv?: string;
+  documentStore?: DocumentStore | null;
+  dangerouslyDisableValidation?: boolean;
+  validationOptions?: ValidationOptions;
+  csrfPrevention?: CSRFPreventionOptions | boolean;
+
+  // Used for parsing operations; unlike in AS3, this is not also used for
+  // parsing the schema.
+  parseOptions?: ParseOptions;
+
+  executionOptions?: ExecutionArgs['options'];
+
+  // TODO(AS6): remove this option. Configuration to `true` is default behavior
+  // and configuration to `false` is deprecated. If you depend on `false`
+  // behavior, we recommend migrating away from that at your earliest
+  // convenience since it won't be supported in the next major version.
+  /**
+   * @deprecated `true` is now the default behavior in AS5. `false` will not be
+   * supported in AS6 since this option will be removed.
+   */
+  status400ForVariableCoercionErrors?: boolean;
+
+  legacyExperimentalExecuteIncrementally?: LegacyExperimentalExecuteIncrementally;
+
+  // For testing only.
+  __testing_incrementalExecutionResults?:
+    | GraphQLExperimentalIncrementalExecutionResultsAlpha2
+    | GraphQLExperimentalIncrementalExecutionResultsAlpha9;
+}
+
+export interface ApolloServerOptionsWithGateway<TContext extends BaseContext>
+  extends ApolloServerOptionsBase<TContext> {
+  gateway: GatewayInterface;
+  schema?: undefined;
+  typeDefs?: undefined;
+  resolvers?: undefined;
+}
+
+export interface ApolloServerOptionsWithSchema<TContext extends BaseContext>
+  extends ApolloServerOptionsBase<TContext> {
+  schema: GraphQLSchema;
+  gateway?: undefined;
+  typeDefs?: undefined;
+  resolvers?: undefined;
+}
+
+export interface ApolloServerOptionsWithTypeDefs<TContext extends BaseContext>
+  extends ApolloServerOptionsBase<TContext> {
+  // These two options are always only passed directly through to
+  // makeExecutableSchema. (If you don't want to use makeExecutableSchema, pass
+  // `schema` instead.)
+  typeDefs: IExecutableSchemaDefinition<TContext>['typeDefs'];
+  resolvers?: IExecutableSchemaDefinition<TContext>['resolvers'];
+  gateway?: undefined;
+  schema?: undefined;
+}
+
+// Used internally in ApolloServer.ts but not publicly exported.
+export type ApolloServerOptionsWithStaticSchema<TContext extends BaseContext> =
+  | ApolloServerOptionsWithSchema<TContext>
+  | ApolloServerOptionsWithTypeDefs<TContext>;
+
+export type ApolloServerOptions<TContext extends BaseContext> =
+  | ApolloServerOptionsWithGateway<TContext>
+  | ApolloServerOptionsWithStaticSchema<TContext>;

package/src/externalTypes/context.ts

@@ -0,0 +1,18 @@
+// The default `contextValue` is an empty object. Generics related to the
+// context type of `ApolloServer` should `extends BasedContext` as we do
+// throughout this repository.
+export type BaseContext = {};
+
+// Integration authors should use this type for typing their own user-provided
+// context function. See `@as-integrations/express5` for a usage example.
+export type ContextFunction<
+  TIntegrationSpecificArgs extends any[],
+  TContext extends BaseContext = BaseContext,
+> = (...integrationContext: TIntegrationSpecificArgs) => Promise<TContext>;
+
+// This is used in `executeHTTPGraphQLRequest` so that that function can apply
+// consistent error handling if it throws. Web framework integrations typically
+// pass a function which passes integration-specific parameters to a
+// user-provided `ContextFunction`.
+export type ContextThunk<TContext extends BaseContext = BaseContext> =
+  () => Promise<TContext>;

package/src/externalTypes/graphql.ts

@@ -0,0 +1,81 @@
+/**
+ * This file exports types related specifically to GraphQL execution, most
+ * notably `GraphQLRequest` and `GraphQLResponse`, used most heavily by
+ * `executeHTTPGraphQLRequest` and `executeOperation`. The
+ * `responseForOperation` plugin hook also returns a `GraphQLResponse`.
+ */
+import type {
+  ExecutionArgs,
+  ExecutionResult,
+  FormattedExecutionResult,
+} from 'graphql';
+import type { BaseContext } from './context.js';
+import type { HTTPGraphQLHead, HTTPGraphQLRequest } from './http.js';
+import type { WithRequired } from '@apollo/utils.withrequired';
+import type {
+  GraphQLExperimentalFormattedInitialIncrementalExecutionResultAlpha2,
+  GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha2,
+} from './incrementalDeliveryPolyfillAlpha2.js';
+import type {
+  GraphQLExperimentalFormattedInitialIncrementalExecutionResultAlpha9,
+  GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha9,
+} from './incrementalDeliveryPolyfillAlpha9.js';
+import { type GraphQLExperimentalIncrementalExecutionResultsAlpha2 } from '../incrementalDeliveryPolyfill.js';
+
+export interface GraphQLRequest<
+  TVariables extends VariableValues = VariableValues,
+> {
+  query?: string;
+  operationName?: string;
+  variables?: TVariables;
+  extensions?: Record<string, any>;
+  http?: HTTPGraphQLRequest;
+}
+
+export type VariableValues = { [name: string]: any };
+
+// A GraphQL response can either be a single result, or an initial result
+// followed by a stream of subsequent results. The latter occurs when the
+// GraphQL operation uses incremental delivery directives such as `@defer` or
+// `@stream`. Note that incremental delivery currently requires using a
+// pre-release of graphql-js v17.
+export type GraphQLResponseBody<TData = Record<string, unknown>> =
+  | {
+      kind: 'single';
+      singleResult: FormattedExecutionResult<TData>;
+    }
+  | {
+      kind: 'incremental';
+      initialResult: GraphQLExperimentalFormattedInitialIncrementalExecutionResultAlpha2;
+      subsequentResults: AsyncIterable<GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha2>;
+    }
+  | {
+      kind: 'incremental';
+      initialResult: GraphQLExperimentalFormattedInitialIncrementalExecutionResultAlpha9;
+      subsequentResults: AsyncIterable<GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha9>;
+    };
+
+export type GraphQLInProgressResponse<TData = Record<string, unknown>> = {
+  http: HTTPGraphQLHead;
+  body?: GraphQLResponseBody<TData>;
+};
+
+export type GraphQLResponse<TData = Record<string, unknown>> = WithRequired<
+  GraphQLInProgressResponse<TData>,
+  'body'
+>;
+export interface ExecuteOperationOptions<TContext extends BaseContext> {
+  contextValue?: TContext;
+}
+
+type PromiseOrValue<T> = Promise<T> | T;
+
+export type LegacyExperimentalExecuteIncrementally<
+  TData = Record<string, unknown>,
+  TExtensions = Record<string, unknown>,
+> = (
+  args: ExecutionArgs,
+) => PromiseOrValue<
+  | ExecutionResult<TData, TExtensions>
+  | GraphQLExperimentalIncrementalExecutionResultsAlpha2<TData, TExtensions>
+>;

package/src/externalTypes/http.ts

@@ -0,0 +1,44 @@
+/**
+ * This file exports types related to GraphQL execution with respect to HTTP.
+ * These types define the inputs and outputs for `executeHTTPGraphQLRequest` and
+ * are most interesting for integration authors.
+ */
+import type { HeaderMap } from '../utils/HeaderMap.js';
+
+export interface HTTPGraphQLRequest {
+  // capitalized (GET, POST, etc)
+  method: string;
+  // lowercase header name, multiple headers joined with ', ' like Headers.get
+  // does
+  headers: HeaderMap;
+  /**
+   * The part of the URL after the question mark (not including the #fragment),
+   * or the empty string if there is no question mark. Including the question
+   * mark in this string is allowed but not required. Do not %-decode this
+   * string. You can get this from a standard Node request with
+   * `url.parse(request.url).search ?? ''`.
+   */
+  search: string;
+  // read by your body-parser or whatever. we poke at it to make it into
+  // the right real type.
+  body: unknown;
+}
+
+export interface HTTPGraphQLHead {
+  status?: number;
+  headers: HeaderMap;
+}
+
+/**
+ * Here we use `string`s for the response body since the response can be either
+ * HTML (for the landing page - see `executeHTTPGraphQLRequest`) or JSON (for a
+ * GraphQL response). Based on `headers` and `method` on the request, we know
+ * how to correctly interpret the response body.
+ */
+export type HTTPGraphQLResponseBody =
+  | { kind: 'complete'; string: string }
+  | { kind: 'chunked'; asyncIterator: AsyncIterableIterator<string> };
+
+export type HTTPGraphQLResponse = HTTPGraphQLHead & {
+  body: HTTPGraphQLResponseBody;
+};

package/src/externalTypes/incrementalDeliveryPolyfillAlpha2.ts

@@ -0,0 +1,63 @@
+import type { FormattedExecutionResult, GraphQLFormattedError } from 'graphql';
+
+// This file defines types used in our public interface that will be imported
+// from `graphql-js` once graphql 17 is released. It is possible that these
+// types will change slightly before the final v17 is released, in which case
+// the relevant parts of our API may change incompatibly in a minor version of
+// AS5; this should not affect any users who aren't explicitly installing
+// pre-releases of graphql 17.
+
+interface ObjMap<T> {
+  [key: string]: T;
+}
+
+export interface GraphQLExperimentalFormattedInitialIncrementalExecutionResultAlpha2<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> extends FormattedExecutionResult<TData, TExtensions> {
+  hasNext: boolean;
+  incremental?: ReadonlyArray<
+    GraphQLExperimentalFormattedIncrementalResultAlpha2<TData, TExtensions>
+  >;
+  extensions?: TExtensions;
+}
+
+export interface GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha2<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> {
+  hasNext: boolean;
+  incremental?: ReadonlyArray<
+    GraphQLExperimentalFormattedIncrementalResultAlpha2<TData, TExtensions>
+  >;
+  extensions?: TExtensions;
+}
+
+export type GraphQLExperimentalFormattedIncrementalResultAlpha2<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> =
+  | GraphQLExperimentalFormattedIncrementalDeferResultAlpha2<TData, TExtensions>
+  | GraphQLExperimentalFormattedIncrementalStreamResultAlpha2<
+      TData,
+      TExtensions
+    >;
+
+export interface GraphQLExperimentalFormattedIncrementalDeferResultAlpha2<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> extends FormattedExecutionResult<TData, TExtensions> {
+  path?: ReadonlyArray<string | number>;
+  label?: string;
+}
+
+export interface GraphQLExperimentalFormattedIncrementalStreamResultAlpha2<
+  TData = Array<unknown>,
+  TExtensions = ObjMap<unknown>,
+> {
+  errors?: ReadonlyArray<GraphQLFormattedError>;
+  items?: TData | null;
+  path?: ReadonlyArray<string | number>;
+  label?: string;
+  extensions?: TExtensions;
+}