@depup/apollo__server 5.5.0-depup.0

package/src/incrementalDeliveryPolyfill.ts

@@ -0,0 +1,253 @@
+import {
+  execute,
+  type ExecutionArgs,
+  type ExecutionResult,
+  type GraphQLError,
+} from 'graphql';
+import { BadRequestError } from './internalErrorClasses.js';
+import { MEDIA_TYPES } from './ApolloServer.js';
+import { type LegacyExperimentalExecuteIncrementally } from './externalTypes/graphql.js';
+
+// This file "polyfills" graphql@17's experimentalExecuteIncrementally (by
+// returning a function that does not understand incremental directives if
+// you're using graphql@16). The types defined in this file are largely copied
+// from graphql-js.
+
+interface ObjMap<T> {
+  [key: string]: T;
+}
+
+// 17.0.0-alpha.2
+export interface GraphQLExperimentalInitialIncrementalExecutionResultAlpha2<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> extends ExecutionResult<TData, TExtensions> {
+  hasNext: boolean;
+  incremental?: ReadonlyArray<
+    GraphQLExperimentalIncrementalResultAlpha2<TData, TExtensions>
+  >;
+  extensions?: TExtensions;
+}
+
+export interface GraphQLExperimentalSubsequentIncrementalExecutionResultAlpha2<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> {
+  hasNext: boolean;
+  incremental?: ReadonlyArray<
+    GraphQLExperimentalIncrementalResultAlpha2<TData, TExtensions>
+  >;
+  extensions?: TExtensions;
+}
+
+type GraphQLExperimentalIncrementalResultAlpha2<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> =
+  | GraphQLExperimentalIncrementalDeferResultAlpha2<TData, TExtensions>
+  | GraphQLExperimentalIncrementalStreamResultAlpha2<TData, TExtensions>;
+
+interface GraphQLExperimentalIncrementalDeferResultAlpha2<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> extends ExecutionResult<TData, TExtensions> {
+  path?: ReadonlyArray<string | number>;
+  label?: string;
+}
+
+interface GraphQLExperimentalIncrementalStreamResultAlpha2<
+  TData = Array<unknown>,
+  TExtensions = ObjMap<unknown>,
+> {
+  errors?: ReadonlyArray<GraphQLError>;
+  items?: TData | null;
+  path?: ReadonlyArray<string | number>;
+  label?: string;
+  extensions?: TExtensions;
+}
+
+export interface GraphQLExperimentalIncrementalExecutionResultsAlpha2<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> {
+  initialResult: GraphQLExperimentalInitialIncrementalExecutionResultAlpha2<
+    TData,
+    TExtensions
+  >;
+  subsequentResults: AsyncGenerator<
+    GraphQLExperimentalSubsequentIncrementalExecutionResultAlpha2<
+      TData,
+      TExtensions
+    >,
+    void,
+    void
+  >;
+}
+
+// 17.0.0-alpha.9
+export interface GraphQLExperimentalInitialIncrementalExecutionResultAlpha9<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> extends ExecutionResult<TData, TExtensions> {
+  data: TData;
+  pending: ReadonlyArray<GraphQLExperimentalPendingResultAlpha9>;
+  hasNext: true;
+  extensions?: TExtensions;
+}
+
+export interface GraphQLExperimentalSubsequentIncrementalExecutionResultAlpha9<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> {
+  pending?: ReadonlyArray<GraphQLExperimentalPendingResultAlpha9>;
+  incremental?: ReadonlyArray<
+    GraphQLExperimentalIncrementalResultAlpha9<TData, TExtensions>
+  >;
+  completed?: ReadonlyArray<GraphQLExperimentalCompletedResultAlpha9>;
+  hasNext: boolean;
+  extensions?: TExtensions;
+}
+
+interface GraphQLExperimentalExecutionGroupResultAlpha9<
+  TData = ObjMap<unknown>,
+> {
+  errors?: ReadonlyArray<GraphQLError>;
+  data: TData;
+}
+
+interface GraphQLExperimentalIncrementalDeferResultAlpha9<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> extends GraphQLExperimentalExecutionGroupResultAlpha9<TData> {
+  id: string;
+  subPath?: ReadonlyArray<string | number>;
+  extensions?: TExtensions;
+}
+
+interface GraphQLExperimentalStreamItemsRecordResultAlpha9<
+  TData = ReadonlyArray<unknown>,
+> {
+  errors?: ReadonlyArray<GraphQLError>;
+  items: TData;
+}
+
+interface GraphQLExperimentalIncrementalStreamResultAlpha9<
+  TData = ReadonlyArray<unknown>,
+  TExtensions = ObjMap<unknown>,
+> extends GraphQLExperimentalStreamItemsRecordResultAlpha9<TData> {
+  id: string;
+  subPath?: ReadonlyArray<string | number>;
+  extensions?: TExtensions;
+}
+
+type GraphQLExperimentalIncrementalResultAlpha9<
+  TData = unknown,
+  TExtensions = ObjMap<unknown>,
+> =
+  | GraphQLExperimentalIncrementalDeferResultAlpha9<TData, TExtensions>
+  | GraphQLExperimentalIncrementalStreamResultAlpha9<TData, TExtensions>;
+
+interface GraphQLExperimentalPendingResultAlpha9 {
+  id: string;
+  path: ReadonlyArray<string | number>;
+  label?: string;
+}
+
+interface GraphQLExperimentalCompletedResultAlpha9 {
+  id: string;
+  errors?: ReadonlyArray<GraphQLError>;
+}
+
+export interface GraphQLExperimentalIncrementalExecutionResultsAlpha9<
+  TInitial = ObjMap<unknown>,
+  TSubsequent = unknown,
+  TExtensions = ObjMap<unknown>,
+> {
+  initialResult: GraphQLExperimentalInitialIncrementalExecutionResultAlpha9<
+    TInitial,
+    TExtensions
+  >;
+  subsequentResults: AsyncGenerator<
+    GraphQLExperimentalSubsequentIncrementalExecutionResultAlpha9<
+      TSubsequent,
+      TExtensions
+    >,
+    void,
+    void
+  >;
+}
+
+type PromiseOrValue<T> = Promise<T> | T;
+
+// This starts as undefined and is set to a function or null by running
+// tryToLoadGraphQL17(). If graphql-js 17 is installed, it is set to the
+// experimentalExecuteIncrementally function from that package; otherwise it is
+// set to null.
+let graphqlExperimentalExecuteIncrementally:
+  | ((
+      args: ExecutionArgs,
+    ) => PromiseOrValue<
+      ExecutionResult | GraphQLExperimentalIncrementalExecutionResultsAlpha9
+    >)
+  | null
+  | undefined = undefined;
+
+async function tryToLoadGraphQL17() {
+  if (graphqlExperimentalExecuteIncrementally !== undefined) {
+    return;
+  }
+
+  const graphql = await import('graphql');
+  if (
+    graphql.version === '17.0.0-alpha.9' &&
+    'experimentalExecuteIncrementally' in graphql
+  ) {
+    graphqlExperimentalExecuteIncrementally = (graphql as any)
+      .experimentalExecuteIncrementally;
+  } else {
+    graphqlExperimentalExecuteIncrementally = null;
+  }
+}
+
+export async function executeIncrementally({
+  useLegacyIncremental,
+  legacyExperimentalExecuteIncrementally,
+  ...args
+}: ExecutionArgs & {
+  useLegacyIncremental?: boolean;
+  legacyExperimentalExecuteIncrementally:
+    | LegacyExperimentalExecuteIncrementally
+    | undefined;
+}): Promise<
+  | ExecutionResult
+  | GraphQLExperimentalIncrementalExecutionResultsAlpha2
+  | GraphQLExperimentalIncrementalExecutionResultsAlpha9
+> {
+  await tryToLoadGraphQL17();
+
+  if (useLegacyIncremental) {
+    if (legacyExperimentalExecuteIncrementally) {
+      return legacyExperimentalExecuteIncrementally(args);
+    }
+
+    // Only throw if the server supports incremental delivery with the new
+    // format, but not the legacy format. We don't want to accidentally send
+    // alpha.9 format when the client requested the legacy format.
+    if (graphqlExperimentalExecuteIncrementally) {
+      throw new BadRequestError(
+        'Apollo Server received an operation that uses incremental delivery ' +
+          '(@defer or @stream) with the legacy incremental format, but the server ' +
+          'does not support the legacy incremental delivery format. Add the HTTP ' +
+          `header: 'Accept: ${MEDIA_TYPES.MULTIPART_MIXED_EXPERIMENTAL_ALPHA_9}' ` +
+          'to use the current incremental delivery format',
+        // Use 406 Not Accepted
+        { extensions: { http: { status: 406 } } },
+      );
+    }
+  }
+
+  if (graphqlExperimentalExecuteIncrementally) {
+    return graphqlExperimentalExecuteIncrementally(args);
+  }
+  return execute(args);
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { ApolloServer } from './ApolloServer.js';
+export { HeaderMap } from './utils/HeaderMap.js';
+// Note that this is purely a type export.
+export * from './externalTypes/index.js';

package/src/internalErrorClasses.ts

@@ -0,0 +1,123 @@
+import { GraphQLError, type GraphQLErrorOptions } from 'graphql';
+import { ApolloServerErrorCode } from './errors/index.js';
+import { newHTTPGraphQLHead } from './runHttpQuery.js';
+import { HeaderMap } from './utils/HeaderMap.js';
+
+// These error classes are not part of Apollo Server's external API; the
+// ApolloServerErrorCode enum is (exported from `@apollo/server/errors`).
+
+class GraphQLErrorWithCode extends GraphQLError {
+  constructor(
+    message: string,
+    code: ApolloServerErrorCode,
+    options?: GraphQLErrorOptions,
+  ) {
+    super(message, {
+      ...options,
+      extensions: { ...options?.extensions, code },
+    });
+    this.name = this.constructor.name;
+  }
+}
+
+export class SyntaxError extends GraphQLErrorWithCode {
+  constructor(graphqlError: GraphQLError) {
+    super(graphqlError.message, ApolloServerErrorCode.GRAPHQL_PARSE_FAILED, {
+      source: graphqlError.source,
+      positions: graphqlError.positions,
+      extensions: { http: newHTTPGraphQLHead(400), ...graphqlError.extensions },
+      originalError: graphqlError,
+    });
+  }
+}
+
+export class ValidationError extends GraphQLErrorWithCode {
+  constructor(graphqlError: GraphQLError) {
+    super(
+      graphqlError.message,
+      ApolloServerErrorCode.GRAPHQL_VALIDATION_FAILED,
+      {
+        nodes: graphqlError.nodes,
+        extensions: {
+          http: newHTTPGraphQLHead(400),
+          ...graphqlError.extensions,
+        },
+        originalError: graphqlError.originalError ?? graphqlError,
+      },
+    );
+  }
+}
+
+// Persisted query errors (especially "not found") need to be uncached, because
+// hopefully we're about to fill in the APQ cache and the same request will
+// succeed next time. We also want a 200 response to avoid any error handling
+// that may mask the contents of an error response. (Otherwise, the default
+// status code for a response with `errors` but no `data` (even null) is 400.)
+const getPersistedQueryErrorHttp = () => ({
+  status: 200,
+  headers: new HeaderMap([
+    ['cache-control', 'private, no-cache, must-revalidate'],
+  ]),
+});
+
+export class PersistedQueryNotFoundError extends GraphQLErrorWithCode {
+  constructor() {
+    super(
+      'PersistedQueryNotFound',
+      ApolloServerErrorCode.PERSISTED_QUERY_NOT_FOUND,
+      { extensions: { http: getPersistedQueryErrorHttp() } },
+    );
+  }
+}
+
+export class PersistedQueryNotSupportedError extends GraphQLErrorWithCode {
+  constructor() {
+    super(
+      'PersistedQueryNotSupported',
+      ApolloServerErrorCode.PERSISTED_QUERY_NOT_SUPPORTED,
+      // Not super clear why we need this to be uncached (makes sense for
+      // PersistedQueryNotFoundError, because there we're about to fill the
+      // cache and make the next copy of the same request succeed) but we've
+      // been doing it for years so :shrug:
+      { extensions: { http: getPersistedQueryErrorHttp() } },
+    );
+  }
+}
+
+export class UserInputError extends GraphQLErrorWithCode {
+  constructor(graphqlError: GraphQLError) {
+    super(graphqlError.message, ApolloServerErrorCode.BAD_USER_INPUT, {
+      nodes: graphqlError.nodes,
+      originalError: graphqlError.originalError ?? graphqlError,
+      extensions: graphqlError.extensions,
+    });
+  }
+}
+
+export class OperationResolutionError extends GraphQLErrorWithCode {
+  constructor(graphqlError: GraphQLError) {
+    super(
+      graphqlError.message,
+      ApolloServerErrorCode.OPERATION_RESOLUTION_FAILURE,
+      {
+        nodes: graphqlError.nodes,
+        originalError: graphqlError.originalError ?? graphqlError,
+        extensions: {
+          http: newHTTPGraphQLHead(400),
+          ...graphqlError.extensions,
+        },
+      },
+    );
+  }
+}
+
+export class BadRequestError extends GraphQLErrorWithCode {
+  constructor(message: string, options?: GraphQLErrorOptions) {
+    super(message, ApolloServerErrorCode.BAD_REQUEST, {
+      ...options,
+      // Default to 400 status code, but caller can override. (If caller just
+      // wants to override headers... well, they can't, sorry.)
+      extensions: { http: newHTTPGraphQLHead(400), ...options?.extensions },
+    });
+  }
+}

package/src/internalPlugin.ts

@@ -0,0 +1,42 @@
+import type { BaseContext, ApolloServerPlugin } from './externalTypes/index.js';
+
+// This file's exports should not be exported from the overall
+// @apollo/server module.
+
+// The internal plugins implement this interface which
+// ApolloServer.ensurePluginInstantiation uses to figure out if the plugins have
+// already been installed (or explicitly disabled via the matching Disable
+// plugins).
+export interface InternalApolloServerPlugin<TContext extends BaseContext>
+  extends ApolloServerPlugin<TContext> {
+  // Used to identify a few specific plugins that are instantiated
+  // by default if not explicitly used or disabled.
+  __internal_plugin_id__: InternalPluginId;
+  __is_disabled_plugin__: boolean;
+}
+
+// Helper function for writing internal plugins which lets you write an object
+// that is type-checked as InternalApolloServerPlugin but is still only of type
+// ApolloServerPlugin (as appropriate for externally-exported plugin-returning
+// functions).
+export function internalPlugin<TContext extends BaseContext>(
+  p: InternalApolloServerPlugin<TContext>,
+): ApolloServerPlugin<TContext> {
+  return p;
+}
+
+export type InternalPluginId =
+  | 'CacheControl'
+  | 'LandingPageDisabled'
+  | 'SchemaReporting'
+  | 'InlineTrace'
+  | 'UsageReporting'
+  | 'DisableSuggestions';
+
+export function pluginIsInternal<TContext extends BaseContext>(
+  plugin: ApolloServerPlugin<TContext>,
+): plugin is InternalApolloServerPlugin<TContext> {
+  // We could call the function and compare it to the list above, but this seems
+  // good enough.
+  return '__internal_plugin_id__' in plugin;
+}