Add pluggable executor

packages/apollo-engine-reporting/src/extension.ts

@@ -8,11 +8,7 @@ import {
   ExecutionArgs,
   GraphQLError,
 } from 'graphql';
-import {
-  GraphQLExtension,
-  GraphQLResponse,
-  EndHandler,
-} from 'graphql-extensions';
+import { GraphQLExtension, EndHandler } from 'graphql-extensions';
 import { Trace, google } from 'apollo-engine-reporting-protobuf';
 
 import { EngineReportingOptions, GenerateClientInfo } from './agent';
@@ -279,8 +275,7 @@ export class EngineReportingExtension<TContext = any>
     };
   }
 
-  public willSendResponse(o: { graphqlResponse: GraphQLResponse }) {
-    const { errors } = o.graphqlResponse;
+  public didEncounterErrors(errors: GraphQLError[]) {
     if (errors) {
       errors.forEach((error: GraphQLError) => {
         // By default, put errors on the root node.

packages/apollo-server-core/src/ApolloServer.ts

@@ -43,8 +43,6 @@ import {
   PluginDefinition,
 } from './types';
 
-import { FormatErrorExtension } from './formatters';
-
 import { gql } from './index';
 
 import {
@@ -331,17 +329,6 @@ export class ApolloServerBase {
     // or cacheControl.
     this.extensions = [];
 
-    const debugDefault =
-      process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test';
-    const debug =
-      requestOptions.debug !== undefined ? requestOptions.debug : debugDefault;
-
-    // Error formatting should happen after the engine reporting agent, so that
-    // engine gets the unmasked errors if necessary
-    this.extensions.push(
-      () => new FormatErrorExtension(requestOptions.formatError, debug),
-    );
-
     // In an effort to avoid over-exposing the API key itself, extract the
     // service ID from the API key for plugins which only needs service ID.
     // The truthyness of this value can also be used in other forks of logic

packages/apollo-server-core/src/graphqlOptions.ts

@@ -13,6 +13,7 @@ import { DataSource } from 'apollo-datasource';
 import { ApolloServerPlugin } from 'apollo-server-plugin-base';
 import { GraphQLParseOptions } from 'graphql-tools';
 import { ValueOrPromise } from 'apollo-server-env';
+import { GraphQLExecutor } from '../dist/requestPipelineAPI';
 
 /*
  * GraphQLServerOptions
@@ -38,6 +39,7 @@ export interface GraphQLServerOptions<
   rootValue?: ((parsedQuery: DocumentNode) => TRootValue) | TRootValue;
   context?: TContext | (() => never);
   validationRules?: Array<(context: ValidationContext) => any>;
+  executor?: GraphQLExecutor;
   formatResponse?: Function;
   fieldResolver?: GraphQLFieldResolver<any, TContext>;
   debug?: boolean;

packages/apollo-server-core/src/index.ts

@@ -31,6 +31,7 @@ export {
 // ApolloServer Base class
 export { ApolloServerBase } from './ApolloServer';
 export * from './types';
+export * from './requestPipelineAPI';
 
 // This currently provides the ability to have syntax highlighting as well as
 // consistency between client and server gql tags

packages/apollo-server-core/src/requestPipeline.ts

@@ -5,7 +5,6 @@ import {
   DocumentNode,
   getOperationAST,
   ExecutionArgs,
-  ExecutionResult,
   GraphQLError,
   GraphQLFormattedError,
 } from 'graphql';
@@ -29,13 +28,16 @@ import {
   ValidationError,
   PersistedQueryNotSupportedError,
   PersistedQueryNotFoundError,
+  formatApolloErrors,
 } from 'apollo-server-errors';
 import {
   GraphQLRequest,
   GraphQLResponse,
   GraphQLRequestContext,
   InvalidGraphQLRequestError,
   ValidationRule,
+  GraphQLExecutor,
+  GraphQLExecutionResult,
 } from '../dist/requestPipelineAPI';
 import {
   ApolloServerPlugin,
@@ -73,6 +75,7 @@ export interface GraphQLRequestPipelineConfig<TContext> {
 
   rootValue?: ((document: DocumentNode) => any) | any;
   validationRules?: ValidationRule[];
+  executor?: GraphQLExecutor;
   fieldResolver?: GraphQLFieldResolver<any, TContext>;
 
   dataSources?: () => DataSources<TContext>;
@@ -316,11 +319,20 @@ export async function processGraphQLRequest<TContext>(
       );
 
       try {
-        response = (await execute(
-          requestContext.document,
-          request.operationName,
-          request.variables,
-        )) as GraphQLResponse;
+        const result = await execute(requestContext as WithRequired<
+          typeof requestContext,
+          'document' | 'operation' | 'operationName'
+        >);
+
+        if (result.errors) {
+          extensionStack.didEncounterErrors(result.errors);
+        }
+
+        response = {
+          ...result,
+          errors: result.errors ? formatErrors(result.errors) : undefined,
+        };
+
         executionDidEnd();
       } catch (executionError) {
         executionDidEnd(executionError);
@@ -395,10 +407,13 @@ export async function processGraphQLRequest<TContext>(
   }
 
   async function execute(
-    document: DocumentNode,
-    operationName: GraphQLRequest['operationName'],
-    variables: GraphQLRequest['variables'],
-  ): Promise<ExecutionResult> {
+    requestContext: WithRequired<
+      GraphQLRequestContext<TContext>,
+      'document' | 'operationName' | 'operation'
+    >,
+  ): Promise<GraphQLExecutionResult> {
+    const { request, document } = requestContext;
+
     const executionArgs: ExecutionArgs = {
       schema: config.schema,
       document,
@@ -407,8 +422,8 @@ export async function processGraphQLRequest<TContext>(
           ? config.rootValue(document)
           : config.rootValue,
       contextValue: requestContext.context,
-      variableValues: variables,
-      operationName,
+      variableValues: request.variables,
+      operationName: request.operationName,
       fieldResolver: config.fieldResolver,
     };
 
@@ -417,7 +432,11 @@ export async function processGraphQLRequest<TContext>(
     });
 
     try {
-      return await graphql.execute(executionArgs);
+      if (config.executor) {
+        return await config.executor(requestContext);
+      } else {
+        return await graphql.execute(executionArgs);
+      }
     } finally {
       executionDidEnd();
     }
@@ -454,17 +473,28 @@ export async function processGraphQLRequest<TContext>(
       : [errorOrErrors];
 
     return sendResponse({
-      errors: errors.map(err =>
-        fromGraphQLError(
-          err,
-          errorClass && {
-            errorClass,
-          },
+      errors: formatErrors(
+        errors.map(err =>
+          fromGraphQLError(
+            err,
+            errorClass && {
+              errorClass,
+            },
+          ),
         ),
       ),
     });
   }
 
+  function formatErrors(
+    errors: ReadonlyArray<GraphQLError>,
+  ): ReadonlyArray<GraphQLFormattedError> {
+    return formatApolloErrors(errors, {
+      formatter: config.formatError,
+      debug: requestContext.debug,
+    });
+  }
+
   function initializeRequestListenerDispatcher(): Dispatcher<
     GraphQLRequestListener
   > {

packages/apollo-server-core/src/requestPipelineAPI.ts

@@ -2,14 +2,20 @@
 // circular dependency issues from the `apollo-server-plugin-base` package
 // depending on the types in it.
 
-import { Request, Response } from 'apollo-server-env';
+import {
+  Request,
+  Response,
+  ValueOrPromise,
+  WithRequired,
+} from 'apollo-server-env';
 import {
   GraphQLSchema,
   ValidationContext,
   ASTVisitor,
-  GraphQLError,
+  GraphQLFormattedError,
   OperationDefinitionNode,
   DocumentNode,
+  GraphQLError,
 } from 'graphql';
 import { KeyValueCache } from 'apollo-server-caching';
 
@@ -27,14 +33,16 @@ export interface GraphQLServiceContext {
 export interface GraphQLRequest {
   query?: string;
   operationName?: string;
-  variables?: { [name: string]: any };
+  variables?: VariableValues;
   extensions?: Record<string, any>;
   http?: Pick<Request, 'url' | 'method' | 'headers'>;
 }
 
+export type VariableValues = { [name: string]: any };
+
 export interface GraphQLResponse {
   data?: Record<string, any>;
-  errors?: GraphQLError[];
+  errors?: ReadonlyArray<GraphQLFormattedError>;
   extensions?: Record<string, any>;
   http?: Pick<Response, 'headers'>;
 }
@@ -72,3 +80,16 @@ export interface GraphQLRequestContext<TContext = Record<string, any>> {
 export type ValidationRule = (context: ValidationContext) => ASTVisitor;
 
 export class InvalidGraphQLRequestError extends Error {}
+
+export type GraphQLExecutor<TContext = Record<string, any>> = (
+  requestContext: WithRequired<
+    GraphQLRequestContext<TContext>,
+    'document' | 'operationName' | 'operation'
+  >,
+) => ValueOrPromise<GraphQLExecutionResult>;
+
+export type GraphQLExecutionResult = {
+  data?: Record<string, any>;
+  errors?: ReadonlyArray<GraphQLError>;
+  extensions?: Record<string, any>;
+};

packages/apollo-server-core/src/runHttpQuery.ts

@@ -155,6 +155,7 @@ export async function runHttpQuery(
     rootValue: options.rootValue,
     context: options.context || {},
     validationRules: options.validationRules,
+    executor: options.executor,
     fieldResolver: options.fieldResolver,
 
     // FIXME: Use proper option types to ensure this

packages/apollo-server-core/src/types.ts

@@ -56,6 +56,7 @@ type BaseConfig = Pick<
   | 'debug'
   | 'rootValue'
   | 'validationRules'
+  | 'executor'
   | 'formatResponse'
   | 'fieldResolver'
   | 'tracing'

packages/apollo-server-errors/src/index.ts

@@ -211,7 +211,7 @@ export class UserInputError extends ApolloError {
 }
 
 export function formatApolloErrors(
-  errors: Array<Error>,
+  errors: ReadonlyArray<Error>,
   options?: {
     formatter?: (error: GraphQLError) => GraphQLFormattedError;
     debug?: boolean;

packages/apollo-server-integration-testsuite/src/ApolloServer.ts

@@ -625,9 +625,9 @@ export function testApolloServer<AS extends ApolloServerBase>(
               context: TContext;
             }) {
               expect(o.graphqlResponse.errors.length).toEqual(1);
-              // formatError should be called after extensions
-              expect(formatError).not.toBeCalled();
-              // validationRules should be called before extensions
+              // formatError should be called before willSendResponse
+              expect(formatError).toHaveBeenCalledTimes(1);
+              // validationRule should be called before willSendResponse
               expect(validationRule).toHaveBeenCalledTimes(1);
               willSendResponseInExtension();
             }

packages/graphql-extensions/src/index.ts

@@ -10,10 +10,10 @@ import {
   DocumentNode,
   ResponsePath,
   FieldNode,
+  GraphQLError,
 } from 'graphql';
 
 import { Request } from 'apollo-server-env';
-export { Request } from 'apollo-server-env';
 
 import {
   GraphQLResponse,
@@ -52,6 +52,7 @@ export class GraphQLExtension<TContext = any> {
   public didResolveOperation?(o: {
     requestContext: GraphQLRequestContext<TContext>;
   }): void;
+  public didEncounterErrors?(errors: ReadonlyArray<GraphQLError>): void;
 
   public willSendResponse?(o: {
     graphqlResponse: GraphQLResponse;
@@ -121,6 +122,13 @@ export class GraphQLExtensionStack<TContext = any> {
       }
     });
   }
+  public didEncounterErrors(errors: ReadonlyArray<GraphQLError>) {
+    this.extensions.forEach(extension => {
+      if (extension.didEncounterErrors) {
+        extension.didEncounterErrors(errors);
+      }
+    });
+  }
 
   public willSendResponse(o: {
     graphqlResponse: GraphQLResponse;