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

Author: Cris Naranjo

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,69 @@ 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 executionOptions = {
+      maxCoercionErrors: 1,
+    };
+
+    const result = executeSync({
+      schema,
+      document,
+      variableValues: {
+        data: {
+          email: '',
+          wrongArg: 'wrong',
+          wrongArg2: 'wrong',
+          wrongArg3: 'wrong',
+        },
+      },
+      executionOptions,
+    });
+
+    // Returns at least 2 errors, one for the first 'wrongArg', and one for coercion limit
+    expect(result.errors).to.have.lengthOf(
+      executionOptions.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,9 @@ export interface ExecutionArgs {
   fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
   typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
   subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+  executionOptions?: {
+    maxCoercionErrors?: number;
+  };
 }
 
 /**
@@ -286,6 +289,7 @@ export function buildExecutionContext(
     fieldResolver,
     typeResolver,
     subscribeFieldResolver,
+    executionOptions,
   } = args;
 
   let operation: OperationDefinitionNode | undefined;
@@ -329,7 +333,7 @@ export function buildExecutionContext(
     schema,
     variableDefinitions,
     rawVariableValues ?? {},
-    { maxErrors: 50 },
+    { maxErrors: executionOptions?.maxCoercionErrors ?? 50 },
   );
 
   if (coercedVariableValues.errors) {