@depup/apollo__server 5.5.0-depup.0

package/src/externalTypes/incrementalDeliveryPolyfillAlpha9.ts

@@ -0,0 +1,82 @@
+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 GraphQLExperimentalFormattedInitialIncrementalExecutionResultAlpha9<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> extends FormattedExecutionResult<TData, TExtensions> {
+  data: TData;
+  pending: ReadonlyArray<GraphQLExperimentalPendingResultAlpha9>;
+  hasNext: boolean;
+  extensions?: TExtensions;
+}
+
+export interface GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha9<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> {
+  hasNext: boolean;
+  pending?: ReadonlyArray<GraphQLExperimentalPendingResultAlpha9>;
+  incremental?: ReadonlyArray<
+    GraphQLExperimentalFormattedIncrementalResultAlpha9<TData, TExtensions>
+  >;
+  completed?: ReadonlyArray<GraphQLExperimentalFormattedCompletedResultAlpha9>;
+  extensions?: TExtensions;
+}
+
+export type GraphQLExperimentalFormattedIncrementalResultAlpha9<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> =
+  | GraphQLExperimentalFormattedIncrementalDeferResultAlpha9<TData, TExtensions>
+  | GraphQLExperimentalFormattedIncrementalStreamResultAlpha9<
+      TData,
+      TExtensions
+    >;
+
+export interface GraphQLExperimentalFormattedIncrementalDeferResultAlpha9<
+  TData = ObjMap<unknown>,
+  TExtensions = ObjMap<unknown>,
+> {
+  errors?: ReadonlyArray<GraphQLFormattedError>;
+  data: TData;
+  id: string;
+  subPath?: ReadonlyArray<string | number>;
+  extensions?: TExtensions;
+}
+
+export interface GraphQLExperimentalFormattedIncrementalStreamResultAlpha9<
+  TData = Array<unknown>,
+  TExtensions = ObjMap<unknown>,
+> {
+  errors?: ReadonlyArray<GraphQLFormattedError>;
+  items: TData;
+  id: string;
+  subPath?: ReadonlyArray<string | number>;
+  extensions?: TExtensions;
+}
+
+export interface GraphQLExperimentalPendingResultAlpha9 {
+  id: string;
+  path: ReadonlyArray<string | number>;
+  label?: string;
+}
+
+// Deviation. The type implemented in alpha.9 is wrong. The type below is the
+// correct type implementation. We may or may not need to provide a patch.
+//
+// This has been fixed by https://github.com/graphql/graphql-js/pull/4481
+export interface GraphQLExperimentalFormattedCompletedResultAlpha9 {
+  id: string;
+  errors?: ReadonlyArray<GraphQLFormattedError>;
+}

package/src/externalTypes/index.ts

@@ -0,0 +1,73 @@
+/**
+ * This file represents the external type definitions needed by end users,
+ * integration implementors, and plugin implementors. Everything from this file
+ * is re-exported by the root (via * export), so add exports to this file with
+ * intention (it's public API).
+ */
+export type { BaseContext, ContextFunction, ContextThunk } from './context.js';
+export type {
+  GraphQLRequest,
+  GraphQLResponse,
+  LegacyExperimentalExecuteIncrementally,
+} from './graphql.js';
+export type {
+  HTTPGraphQLRequest,
+  HTTPGraphQLResponse,
+  HTTPGraphQLHead,
+} from './http.js';
+export type {
+  ApolloServerPlugin,
+  GraphQLFieldResolverParams,
+  GraphQLRequestExecutionListener,
+  GraphQLRequestListener,
+  GraphQLRequestListenerDidResolveField,
+  GraphQLRequestListenerExecutionDidEnd,
+  GraphQLRequestListenerParsingDidEnd,
+  GraphQLRequestListenerValidationDidEnd,
+  GraphQLSchemaContext,
+  GraphQLServerListener,
+  GraphQLServerContext,
+  LandingPage,
+} from './plugins.js';
+export type {
+  GraphQLRequestContext,
+  GraphQLRequestMetrics,
+  GraphQLRequestContextDidEncounterErrors,
+  GraphQLRequestContextDidResolveOperation,
+  GraphQLRequestContextDidResolveSource,
+  GraphQLRequestContextExecutionDidStart,
+  GraphQLRequestContextParsingDidStart,
+  GraphQLRequestContextResponseForOperation,
+  GraphQLRequestContextValidationDidStart,
+  GraphQLRequestContextWillSendResponse,
+} from './requestPipeline.js';
+export type {
+  DocumentStore,
+  ApolloConfigInput,
+  ApolloConfig,
+  PersistedQueryOptions,
+  CSRFPreventionOptions,
+  ApolloServerOptionsWithSchema,
+  ApolloServerOptionsWithTypeDefs,
+  ApolloServerOptionsWithStaticSchema,
+  ApolloServerOptionsWithGateway,
+  ApolloServerOptions,
+} from './constructor.js';
+
+export type {
+  GraphQLExperimentalFormattedInitialIncrementalExecutionResultAlpha2,
+  GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha2,
+  GraphQLExperimentalFormattedIncrementalResultAlpha2,
+  GraphQLExperimentalFormattedIncrementalDeferResultAlpha2,
+  GraphQLExperimentalFormattedIncrementalStreamResultAlpha2,
+} from './incrementalDeliveryPolyfillAlpha2.js';
+
+export type {
+  GraphQLExperimentalFormattedInitialIncrementalExecutionResultAlpha9,
+  GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha9,
+  GraphQLExperimentalFormattedIncrementalStreamResultAlpha9,
+  GraphQLExperimentalFormattedIncrementalDeferResultAlpha9,
+  GraphQLExperimentalFormattedCompletedResultAlpha9,
+  GraphQLExperimentalFormattedIncrementalResultAlpha9,
+  GraphQLExperimentalPendingResultAlpha9,
+} from './incrementalDeliveryPolyfillAlpha9.js';

package/src/externalTypes/plugins.ts

@@ -0,0 +1,222 @@
+/**
+ * The types defined in this file are useful to plugin authors. In particular,
+ * defining a plugin as an `ApolloServerPlugin` will provide typings for all of
+ * the hooks that are available to a plugin.
+ */
+import type { KeyValueCache } from '@apollo/utils.keyvaluecache';
+import type { Logger } from '@apollo/utils.logger';
+import type { GraphQLError, GraphQLResolveInfo, GraphQLSchema } from 'graphql';
+import type { ApolloConfig } from './constructor.js';
+import type { BaseContext } from './context.js';
+import type { GraphQLResponse } from './graphql.js';
+import type { GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha2 } from './incrementalDeliveryPolyfillAlpha2.js';
+import type {
+  GraphQLRequestContext,
+  GraphQLRequestContextDidEncounterErrors,
+  GraphQLRequestContextDidEncounterSubsequentErrors,
+  GraphQLRequestContextDidResolveOperation,
+  GraphQLRequestContextDidResolveSource,
+  GraphQLRequestContextExecutionDidStart,
+  GraphQLRequestContextParsingDidStart,
+  GraphQLRequestContextResponseForOperation,
+  GraphQLRequestContextValidationDidStart,
+  GraphQLRequestContextWillSendResponse,
+  GraphQLRequestContextWillSendSubsequentPayload,
+} from './requestPipeline.js';
+import type { GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha9 } from './incrementalDeliveryPolyfillAlpha9.js';
+
+export interface GraphQLServerContext {
+  readonly logger: Logger;
+  readonly cache: KeyValueCache<string>;
+
+  schema: GraphQLSchema;
+  apollo: ApolloConfig;
+  startedInBackground: boolean;
+}
+
+export interface GraphQLSchemaContext {
+  apiSchema: GraphQLSchema;
+  coreSupergraphSdl?: string;
+}
+
+export interface ApolloServerPlugin<
+  in TContext extends BaseContext = BaseContext,
+> {
+  // Called once on server startup, after the schema has been loaded.
+  serverWillStart?(
+    service: GraphQLServerContext,
+  ): Promise<GraphQLServerListener | void>;
+
+  // Called once per request, before parsing or validation of the request has
+  // occurred. This hook can return an object of more fine-grained hooks (see
+  // `GraphQLRequestListener`) which pertain to the lifecycle of the request.
+  requestDidStart?(
+    requestContext: GraphQLRequestContext<TContext>,
+  ): Promise<GraphQLRequestListener<TContext> | void>;
+
+  /**
+   * "Unexpected" errors do not include more common errors like validation,
+   * parsing, or graphql execution errors. Rather, an unexpected error might
+   * occur when a plugin hook throws unexpectedly or a bug in Apollo Server is
+   * encountered. Notably, when errors like this occur, the error is masked to
+   * the client.
+   */
+  unexpectedErrorProcessingRequest?({
+    requestContext,
+    error,
+  }: {
+    requestContext: GraphQLRequestContext<TContext>;
+    error: Error;
+  }): Promise<void>;
+  // Called specifically when the user-provided `context` function throws an
+  // error.
+  contextCreationDidFail?({ error }: { error: Error }): Promise<void>;
+  /**
+   * This hook is called any time a "Bad Request" error is thrown during request
+   * execution. This includes CSRF prevention and malformed requests (e.g.
+   * incorrect headers, invalid JSON body, or invalid search params for GET),
+   * but does not include malformed GraphQL.
+   */
+  invalidRequestWasReceived?({ error }: { error: Error }): Promise<void>;
+  // Called on startup fail. This can occur if the schema fails to load or if a
+  // `serverWillStart` or `renderLandingPage` hook throws.
+  startupDidFail?({ error }: { error: Error }): Promise<void>;
+}
+
+export interface GraphQLServerListener {
+  // Called on server startup after a successful schema load and on successful
+  // schema updates when running in `gateway` mode.
+  schemaDidLoadOrUpdate?(schemaContext: GraphQLSchemaContext): void;
+
+  // When your server is stopped (by calling `stop()` or via the
+  // `SIGINT`/`SIGTERM` handlers), Apollo Server first awaits all `drainServer`
+  // hooks in parallel. GraphQL operations can still execute while `drainServer`
+  // is in progress. A typical use is to stop listening for new connections and
+  // wait until all current connections are idle. The built-in
+  // ApolloServerPluginDrainHttpServer implements this method.
+  drainServer?(): Promise<void>;
+
+  // When your server is stopped (by calling `stop()` or via the
+  // `SIGINT`/`SIGTERM` handlers) then (after the `drainServer` phase finishes)
+  // Apollo Server transitions into a state where no new operations will run and
+  // then awaits all `drainServer` hooks in parallel. A typical use is to flush
+  // outstanding observability data.
+  serverWillStop?(): Promise<void>;
+
+  // At most one plugin's serverWillStart may return a GraphQLServerListener
+  // with this method. If one does, it is called once on server startup and the
+  // page it returns is served to clients with `accept: text/html` headers. This
+  // is an intentionally simple API; if you want to do something fancy to serve
+  // a landing page, you probably should just define a handler in your web
+  // framework.
+  renderLandingPage?(): Promise<LandingPage>;
+}
+
+// The page served to clients with `accept: text/html` headers.
+export interface LandingPage {
+  html: string | (() => Promise<string>);
+}
+
+export type GraphQLRequestListenerParsingDidEnd = (
+  err?: Error,
+) => Promise<void>;
+export type GraphQLRequestListenerValidationDidEnd = (
+  err?: ReadonlyArray<Error>,
+) => Promise<void>;
+export type GraphQLRequestListenerExecutionDidEnd = (
+  err?: Error,
+) => Promise<void>;
+export type GraphQLRequestListenerDidResolveField = (
+  error: Error | null,
+  result?: any,
+) => void;
+
+export interface GraphQLRequestListener<TContext extends BaseContext> {
+  didResolveSource?(
+    requestContext: GraphQLRequestContextDidResolveSource<TContext>,
+  ): Promise<void>;
+
+  parsingDidStart?(
+    requestContext: GraphQLRequestContextParsingDidStart<TContext>,
+  ): Promise<GraphQLRequestListenerParsingDidEnd | void>;
+
+  validationDidStart?(
+    requestContext: GraphQLRequestContextValidationDidStart<TContext>,
+  ): Promise<GraphQLRequestListenerValidationDidEnd | void>;
+
+  didResolveOperation?(
+    requestContext: GraphQLRequestContextDidResolveOperation<TContext>,
+  ): Promise<void>;
+
+  didEncounterErrors?(
+    requestContext: GraphQLRequestContextDidEncounterErrors<TContext>,
+  ): Promise<void>;
+
+  // If this hook is defined, it is invoked immediately before GraphQL execution
+  // would take place. If its return value resolves to a non-null
+  // GraphQLResponse, that result is used instead of executing the query.
+  // Hooks from different plugins are invoked in series and the first non-null
+  // response is used.
+  responseForOperation?(
+    requestContext: GraphQLRequestContextResponseForOperation<TContext>,
+  ): Promise<GraphQLResponse | null>;
+
+  // Note that in the case of incremental delivery, the end hook gets called
+  // when the initial response is ready to go: further execution can still occur.
+  executionDidStart?(
+    requestContext: GraphQLRequestContextExecutionDidStart<TContext>,
+  ): Promise<GraphQLRequestExecutionListener<TContext> | void>;
+
+  // Note that in the case of incremental delivery, this is called when the
+  // initial response is ready to go.
+  willSendResponse?(
+    requestContext: GraphQLRequestContextWillSendResponse<TContext>,
+  ): Promise<void>;
+
+  didEncounterSubsequentErrors?(
+    requestContext: GraphQLRequestContextDidEncounterSubsequentErrors<TContext>,
+    errors: ReadonlyArray<GraphQLError>,
+  ): Promise<void>;
+
+  // You can use hasNext to tell if this is the end or not.
+  willSendSubsequentPayload?(
+    requestContext: GraphQLRequestContextWillSendSubsequentPayload<TContext>,
+    payload:
+      | GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha2
+      | GraphQLExperimentalFormattedSubsequentIncrementalExecutionResultAlpha9,
+  ): Promise<void>;
+}
+
+/**
+ * This is an object form of the parameters received by typical
+ * `graphql-js` resolvers.  The function type is `GraphQLFieldResolver`
+ * and normally uses positional parameters.  In order to facilitate better
+ * ergonomics in the Apollo Server plugin API, these have been converted to
+ * named properties on the object using their names from the upstream
+ * `GraphQLFieldResolver` type signature.  Ergonomic wins, in this case,
+ * include not needing to have three unused variables in scope just because
+ * there was a need to access the `info` property in a wrapped plugin.
+ */
+export type GraphQLFieldResolverParams<
+  TSource,
+  TContext,
+  TArgs = { [argName: string]: any },
+> = {
+  source: TSource;
+  args: TArgs;
+  contextValue: TContext;
+  info: GraphQLResolveInfo;
+};
+
+export interface GraphQLRequestExecutionListener<TContext extends BaseContext> {
+  executionDidEnd?: GraphQLRequestListenerExecutionDidEnd;
+  // willResolveField is not async because we've observed that it already has
+  // quite a performance impact on execution even without involving the Promise
+  // queue. If we can come up with ways to alleviate the burden (eg having an
+  // uninstrumented schema and an instrumented schema and only using the
+  // instrumented schema for a subset of operations that need detailed
+  // performance traces) we could be happier supporting async willResolveField.
+  willResolveField?(
+    fieldResolverParams: GraphQLFieldResolverParams<any, TContext>,
+  ): GraphQLRequestListenerDidResolveField | void;
+}

package/src/externalTypes/requestPipeline.ts

@@ -0,0 +1,123 @@
+// This file defines the GraphQLRequestContext type which is an argument to most
+// plugin hooks, as well as a variety of variants on it which assert that
+// particular sub-fields are set by a particular point in the request pipeline.
+
+import type { WithRequired } from '@apollo/utils.withrequired';
+import type { Trace } from '@apollo/usage-reporting-protobuf';
+import type { BaseContext } from './context.js';
+import type {
+  GraphQLInProgressResponse,
+  GraphQLRequest,
+  GraphQLResponse,
+} from './graphql.js';
+import type { Logger } from '@apollo/utils.logger';
+import type { KeyValueCache } from '@apollo/utils.keyvaluecache';
+import type {
+  DocumentNode,
+  GraphQLError,
+  GraphQLSchema,
+  OperationDefinitionNode,
+} from 'graphql';
+import type { CachePolicy } from '@apollo/cache-control-types';
+import type { NonFtv1ErrorPath } from '@apollo/server-gateway-interface';
+
+export interface GraphQLRequestMetrics {
+  // It would be more accurate to call this fieldLevelInstrumentation (it is
+  // true if the hook of that name returns truthy) but for backwards
+  // compatibility we keep this name (this field is read by `@apollo/gateway` to
+  // decide whether or not to send the apollo-federation-include-trace header).
+  captureTraces?: boolean;
+  persistedQueryHit?: boolean;
+  persistedQueryRegister?: boolean;
+  responseCacheHit?: boolean;
+  forbiddenOperation?: boolean;
+  registeredOperation?: boolean;
+  startHrTime?: [number, number];
+  queryPlanTrace?: Trace.QueryPlanNode;
+  nonFtv1ErrorPaths?: NonFtv1ErrorPath[];
+}
+
+export interface GraphQLRequestContext<TContext extends BaseContext> {
+  readonly logger: Logger;
+  readonly cache: KeyValueCache<string>;
+
+  readonly request: GraphQLRequest;
+  readonly response: GraphQLInProgressResponse;
+
+  readonly schema: GraphQLSchema;
+
+  readonly contextValue: TContext;
+
+  readonly queryHash?: string;
+
+  readonly document?: DocumentNode;
+  readonly source?: string;
+
+  // `operationName` is set based on the operation AST, so it is defined even if
+  // no `request.operationName` was passed in.  It will be set to `null` for an
+  // anonymous operation, or if `requestName.operationName` was passed in but
+  // doesn't resolve to an operation in the document.
+  readonly operationName?: string | null;
+  readonly operation?: OperationDefinitionNode;
+
+  /**
+   * Unformatted errors which have occurred during the request. Note that these
+   * are present earlier in the request pipeline and differ from **formatted**
+   * errors which are the result of running the user-configurable `formatError`
+   * transformation function over specific errors; these can eventually be found
+   * in `response.result.errors`.
+   */
+  readonly errors?: ReadonlyArray<GraphQLError>;
+
+  readonly metrics: GraphQLRequestMetrics;
+
+  readonly overallCachePolicy: CachePolicy;
+
+  /**
+   * True if this request is part of a potentially multi-operation batch. Note
+   * that if this is true, `response.http` will be shared with the other
+   * operations in the batch.
+   */
+  readonly requestIsBatched: boolean;
+}
+
+export type GraphQLRequestContextDidResolveSource<
+  TContext extends BaseContext,
+> = WithRequired<GraphQLRequestContext<TContext>, 'source' | 'queryHash'>;
+export type GraphQLRequestContextParsingDidStart<TContext extends BaseContext> =
+  GraphQLRequestContextDidResolveSource<TContext>;
+export type GraphQLRequestContextValidationDidStart<
+  TContext extends BaseContext,
+> = GraphQLRequestContextParsingDidStart<TContext> &
+  WithRequired<GraphQLRequestContext<TContext>, 'document'>;
+export type GraphQLRequestContextDidResolveOperation<
+  TContext extends BaseContext,
+> = GraphQLRequestContextValidationDidStart<TContext> &
+  WithRequired<GraphQLRequestContext<TContext>, 'operationName'>;
+export type GraphQLRequestContextDidEncounterErrors<
+  TContext extends BaseContext,
+> = WithRequired<GraphQLRequestContext<TContext>, 'errors'>;
+export type GraphQLRequestContextResponseForOperation<
+  TContext extends BaseContext,
+> = WithRequired<
+  GraphQLRequestContext<TContext>,
+  'source' | 'document' | 'operation' | 'operationName'
+>;
+export type GraphQLRequestContextExecutionDidStart<
+  TContext extends BaseContext,
+> = GraphQLRequestContextParsingDidStart<TContext> &
+  WithRequired<
+    GraphQLRequestContext<TContext>,
+    'document' | 'operation' | 'operationName'
+  >;
+export type GraphQLRequestContextWillSendResponse<
+  TContext extends BaseContext,
+> = GraphQLRequestContextDidResolveSource<TContext> & {
+  readonly response: GraphQLResponse;
+};
+export type GraphQLRequestContextDidEncounterSubsequentErrors<
+  TContext extends BaseContext,
+> = GraphQLRequestContextWillSendResponse<TContext>;
+export type GraphQLRequestContextWillSendSubsequentPayload<
+  TContext extends BaseContext,
+> = GraphQLRequestContextWillSendResponse<TContext>;

package/src/generated/packageVersion.ts

@@ -0,0 +1 @@
+export const packageVersion = "5.5.0";

package/src/httpBatching.ts

@@ -0,0 +1,105 @@
+import type {
+  BaseContext,
+  HTTPGraphQLRequest,
+  HTTPGraphQLResponse,
+} from './externalTypes/index.js';
+import type {
+  ApolloServer,
+  ApolloServerInternals,
+  SchemaDerivedData,
+} from './ApolloServer';
+import { newHTTPGraphQLHead, runHttpQuery } from './runHttpQuery.js';
+import { BadRequestError } from './internalErrorClasses.js';
+
+async function runBatchedHttpQuery<TContext extends BaseContext>({
+  server,
+  batchRequest,
+  body,
+  contextValue,
+  schemaDerivedData,
+  internals,
+}: {
+  server: ApolloServer<TContext>;
+  batchRequest: HTTPGraphQLRequest;
+  body: unknown[];
+  contextValue: TContext;
+  schemaDerivedData: SchemaDerivedData;
+  internals: ApolloServerInternals<TContext>;
+}): Promise<HTTPGraphQLResponse> {
+  if (body.length === 0) {
+    throw new BadRequestError('No operations found in request.');
+  }
+
+  // This single HTTPGraphQLHead is shared across all the operations in the
+  // batch. This means that any changes to response headers or status code from
+  // one operation can be immediately seen by other operations. Plugins that set
+  // response headers or status code can then choose to combine the data they
+  // are setting with data that may already be there from another operation as
+  // they choose.
+  const sharedResponseHTTPGraphQLHead = newHTTPGraphQLHead();
+  const responseBodies = await Promise.all(
+    body.map(async (bodyPiece: unknown) => {
+      const singleRequest: HTTPGraphQLRequest = {
+        ...batchRequest,
+        body: bodyPiece,
+      };
+
+      const response = await runHttpQuery({
+        server,
+        httpRequest: singleRequest,
+        contextValue,
+        schemaDerivedData,
+        internals,
+        sharedResponseHTTPGraphQLHead,
+      });
+
+      if (response.body.kind === 'chunked') {
+        throw Error(
+          'Incremental delivery is not implemented for batch requests',
+        );
+      }
+      return response.body.string;
+    }),
+  );
+  return {
+    ...sharedResponseHTTPGraphQLHead,
+    body: { kind: 'complete', string: `[${responseBodies.join(',')}]` },
+  };
+}
+
+export async function runPotentiallyBatchedHttpQuery<
+  TContext extends BaseContext,
+>(
+  server: ApolloServer<TContext>,
+  httpGraphQLRequest: HTTPGraphQLRequest,
+  contextValue: TContext,
+  schemaDerivedData: SchemaDerivedData,
+  internals: ApolloServerInternals<TContext>,
+): Promise<HTTPGraphQLResponse> {
+  if (
+    !(
+      httpGraphQLRequest.method === 'POST' &&
+      Array.isArray(httpGraphQLRequest.body)
+    )
+  ) {
+    return await runHttpQuery({
+      server,
+      httpRequest: httpGraphQLRequest,
+      contextValue,
+      schemaDerivedData,
+      internals,
+      sharedResponseHTTPGraphQLHead: null,
+    });
+  }
+  if (internals.allowBatchedHttpRequests) {
+    return await runBatchedHttpQuery({
+      server,
+      batchRequest: httpGraphQLRequest,
+      body: httpGraphQLRequest.body as unknown[],
+      contextValue,
+      schemaDerivedData,
+      internals,
+    });
+  }
+  throw new BadRequestError('Operation batching disabled.');
+}