feat(execution): add max coercion errors option to execution context

src/execution/__tests__/executor-test.ts

@@ -11,6 +11,7 @@ import { Kind } from '../../language/kinds';
 import { parse } from '../../language/parser';
 
 import {
+  GraphQLInputObjectType,
   GraphQLInterfaceType,
   GraphQLList,
   GraphQLNonNull,
@@ -1320,4 +1321,67 @@ describe('Execute: Handles basic execution tasks', () => {
     expect(result).to.deep.equal({ data: { foo: { bar: 'bar' } } });
     expect(possibleTypes).to.deep.equal([fooObject]);
   });
+
+  it('uses a different number of max coercion errors', () => {
+    const schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          dummy: { type: GraphQLString },
+        },
+      }),
+      mutation: new GraphQLObjectType({
+        name: 'Mutation',
+        fields: {
+          updateUser: {
+            type: GraphQLString,
+            args: {
+              data: {
+                type: new GraphQLInputObjectType({
+                  name: 'User',
+                  fields: {
+                    email: { type: new GraphQLNonNull(GraphQLString) },
+                  },
+                }),
+              },
+            },
+          },
+        },
+      }),
+    });
+
+    const document = parse(`
+      mutation ($data: User) {
+        updateUser(data: $data)
+      }
+    `);
+
+    const options = {
+      maxCoercionErrors: 1,
+    };
+
+    const result = executeSync({
+      schema,
+      document,
+      variableValues: {
+        data: {
+          email: '',
+          wrongArg: 'wrong',
+          wrongArg2: 'wrong',
+          wrongArg3: 'wrong',
+        },
+      },
+      options,
+    });
+
+    // Returns at least 2 errors, one for the first 'wrongArg', and one for coercion limit
+    expect(result.errors).to.have.lengthOf(options.maxCoercionErrors + 1);
+    expect(
+      result.errors && result.errors.length > 0
+        ? result.errors[result.errors.length - 1].message
+        : undefined,
+    ).to.equal(
+      'Too many errors processing variables, error limit reached. Execution aborted.',
+    );
+  });
 });

src/execution/execute.ts

@@ -152,6 +152,11 @@ export interface ExecutionArgs {
   fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
   typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
   subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+  /** Additional execution options. */
+  options?: {
+    /** Set the maximum number of errors allowed for coercing (defaults to 50). */
+    maxCoercionErrors?: number;
+  };
 }
 
 /**
@@ -286,6 +291,7 @@ export function buildExecutionContext(
     fieldResolver,
     typeResolver,
     subscribeFieldResolver,
+    options,
   } = args;
 
   let operation: OperationDefinitionNode | undefined;
@@ -329,7 +335,7 @@ export function buildExecutionContext(
     schema,
     variableDefinitions,
     rawVariableValues ?? {},
-    { maxErrors: 50 },
+    { maxErrors: options?.maxCoercionErrors ?? 50 },
   );
 
   if (coercedVariableValues.errors) {

website/pages/api-v16/execution.mdx

@@ -29,16 +29,20 @@ const { execute } = require('graphql'); // CommonJS
 ### execute
 
 ```ts
-export function execute(
+export function execute({
   schema: GraphQLSchema,
-  documentAST: Document,
-  rootValue?: mixed,
-  contextValue?: mixed,
+  document: DocumentNode,
+  rootValue?: unknown,
+  contextValue?: unknown,
   variableValues?: { [key: string]: mixed },
   operationName?: string,
-): MaybePromise<ExecutionResult>;
+  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
+  subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+  options?: { maxCoercionErrors?: number };
+}): PromiseOrValue<ExecutionResult>;
 
-type MaybePromise<T> = Promise<T> | T;
+type PromiseOrValue<T> = Promise<T> | T;
 
 interface ExecutionResult<
   TData = ObjMap<unknown>,
@@ -61,21 +65,32 @@ a GraphQLError will be thrown immediately explaining the invalid input.
 executing the query, `errors` is null if no errors occurred, and is a
 non-empty array if an error occurred.
 
+#### options
+
+##### maxCoercionErrors
+
+Set the maximum number of errors allowed for coercing (defaults to 50).
+
 ### executeSync
 
 ```ts
-export function executeSync(
+export function executeSync({
   schema: GraphQLSchema,
-  documentAST: Document,
-  rootValue?: mixed,
-  contextValue?: mixed,
+  document: DocumentNode,
+  rootValue?: unknown,
+  contextValue?: unknown,
   variableValues?: { [key: string]: mixed },
   operationName?: string,
-): ExecutionResult;
+  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
+  subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+  options?: { maxCoercionErrors?: number };
+}): ExecutionResult;
 
 type ExecutionResult = {
-  data: Object;
-  errors?: GraphQLError[];
+  errors?: ReadonlyArray<GraphQLError>;
+  data?: TData | null;
+  extensions?: TExtensions;
 };
 ```