Allow skipping suggestions

Author: JoviDeCroock

src/execution/execute.ts

@@ -148,6 +148,7 @@ export interface ValidatedExecutionArgs {
   typeResolver: GraphQLTypeResolver<any, any>;
   subscribeFieldResolver: GraphQLFieldResolver<any, any>;
   enableEarlyExecution: boolean;
+  shouldProvideSuggestions: boolean
 }
 
 export interface ExecutionContext {
@@ -172,6 +173,7 @@ export interface ExecutionArgs {
   typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
   subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
   enableEarlyExecution?: Maybe<boolean>;
+  shouldProvideSuggestions?: Maybe<boolean>
 }
 
 export interface StreamUsage {
@@ -472,6 +474,7 @@ export function validateExecutionArgs(
     typeResolver,
     subscribeFieldResolver,
     enableEarlyExecution,
+    shouldProvideSuggestions
   } = args;
 
   // If the schema used for execution is invalid, throw an error.
@@ -527,7 +530,7 @@ export function validateExecutionArgs(
     schema,
     variableDefinitions,
     rawVariableValues ?? {},
-    { maxErrors: 50 },
+    { maxErrors: 50, shouldProvideSuggestions: shouldProvideSuggestions??true },
   );
 
   if (variableValuesOrErrors.errors) {
@@ -545,6 +548,7 @@ export function validateExecutionArgs(
     typeResolver: typeResolver ?? defaultTypeResolver,
     subscribeFieldResolver: subscribeFieldResolver ?? defaultFieldResolver,
     enableEarlyExecution: enableEarlyExecution === true,
+    shouldProvideSuggestions: shouldProvideSuggestions??true
   };
 }
 
@@ -728,7 +732,7 @@ function executeField(
   deferMap: ReadonlyMap<DeferUsage, DeferredFragmentRecord> | undefined,
 ): PromiseOrValue<GraphQLWrappedResult<unknown>> | undefined {
   const validatedExecutionArgs = exeContext.validatedExecutionArgs;
-  const { schema, contextValue, variableValues } = validatedExecutionArgs;
+  const { schema, contextValue, variableValues,shouldProvideSuggestions  } = validatedExecutionArgs;
   const fieldName = fieldGroup[0].node.name.value;
   const fieldDef = schema.getField(parentType, fieldName);
   if (!fieldDef) {
@@ -755,6 +759,7 @@ function executeField(
       fieldGroup[0].node,
       fieldDef.args,
       variableValues,
+      shouldProvideSuggestions,
       fieldGroup[0].fragmentVariableValues,
     );
 
@@ -1058,12 +1063,13 @@ function getStreamUsage(
       ._streamUsage;
   }
 
-  const { operation, variableValues } = validatedExecutionArgs;
+  const { operation, variableValues, shouldProvideSuggestions } = validatedExecutionArgs;
   // validation only allows equivalent streams on multiple fields, so it is
   // safe to only check the first fieldNode for the stream directive
   const stream = getDirectiveValues(
     GraphQLStreamDirective,
     fieldGroup[0].node,
+    shouldProvideSuggestions,
     variableValues,
     fieldGroup[0].fragmentVariableValues,
   );
@@ -2072,7 +2078,7 @@ function executeSubscription(
 
     // Build a JS object of arguments from the field.arguments AST, using the
     // variables scope to fulfill any variable references.
-    const args = getArgumentValues(fieldDef, fieldNodes[0], variableValues);
+    const args = getArgumentValues(fieldDef, fieldNodes[0], validatedExecutionArgs.shouldProvideSuggestions, variableValues);
 
     // Call the `subscribe()` resolver or the default resolver to produce an
     // AsyncIterable yielding raw payloads.

src/execution/values.ts

@@ -55,7 +55,7 @@ export function getVariableValues(
   schema: GraphQLSchema,
   varDefNodes: ReadonlyArray<VariableDefinitionNode>,
   inputs: { readonly [variable: string]: unknown },
-  options?: { maxErrors?: number },
+  options?: { maxErrors?: number, shouldProvideSuggestions?: boolean },
 ): VariableValuesOrErrors {
   const errors: Array<GraphQLError> = [];
   const maxErrors = options?.maxErrors;
@@ -72,6 +72,7 @@ export function getVariableValues(
         }
         errors.push(error);
       },
+      options?.shouldProvideSuggestions?? true
     );
 
     if (errors.length === 0) {
@@ -89,6 +90,7 @@ function coerceVariableValues(
   varDefNodes: ReadonlyArray<VariableDefinitionNode>,
   inputs: { readonly [variable: string]: unknown },
   onError: (error: GraphQLError) => void,
+  shouldProvideSuggestions: boolean
 ): VariableValues {
   const sources: ObjMap<VariableValueSource> = Object.create(null);
   const coerced: ObjMap<unknown> = Object.create(null);
@@ -105,7 +107,7 @@ function coerceVariableValues(
       const defaultValue = varSignature.defaultValue;
       if (defaultValue) {
         sources[varName] = { signature: varSignature };
-        coerced[varName] = coerceDefaultValue(defaultValue, varType);
+        coerced[varName] = coerceDefaultValue(defaultValue, varType, shouldProvideSuggestions);
       } else if (isNonNullType(varType)) {
         const varTypeStr = inspect(varType);
         onError(
@@ -149,6 +151,7 @@ function coerceVariableValues(
           }),
         );
       },
+      shouldProvideSuggestions
     );
   }
 
@@ -159,6 +162,7 @@ export function getFragmentVariableValues(
   fragmentSpreadNode: FragmentSpreadNode,
   fragmentSignatures: ReadOnlyObjMap<GraphQLVariableSignature>,
   variableValues: VariableValues,
+  shouldProvideSuggestions: boolean,
   fragmentVariableValues?: Maybe<VariableValues>,
 ): VariableValues {
   const varSignatures: Array<GraphQLVariableSignature> = [];
@@ -177,8 +181,9 @@ export function getFragmentVariableValues(
     fragmentSpreadNode,
     varSignatures,
     variableValues,
+    shouldProvideSuggestions,
     fragmentVariableValues,
-  );
+  )
 
   return { sources, coerced };
 }
@@ -194,15 +199,17 @@ export function getFragmentVariableValues(
 export function getArgumentValues(
   def: GraphQLField<unknown, unknown> | GraphQLDirective,
   node: FieldNode | DirectiveNode,
+  shouldProvideSuggestions: boolean,
   variableValues?: Maybe<VariableValues>,
-): { [argument: string]: unknown } {
-  return experimentalGetArgumentValues(node, def.args, variableValues);
+  ): { [argument: string]: unknown } {
+  return experimentalGetArgumentValues(node, def.args, variableValues, shouldProvideSuggestions);
 }
 
 export function experimentalGetArgumentValues(
   node: FieldNode | DirectiveNode | FragmentSpreadNode,
   argDefs: ReadonlyArray<GraphQLArgument | GraphQLVariableSignature>,
   variableValues: Maybe<VariableValues>,
+  shouldProvideSuggestions: boolean,
   fragmentVariablesValues?: Maybe<VariableValues>,
 ): { [argument: string]: unknown } {
   const coercedValues: { [argument: string]: unknown } = {};
@@ -222,6 +229,7 @@ export function experimentalGetArgumentValues(
         coercedValues[name] = coerceDefaultValue(
           argDef.defaultValue,
           argDef.type,
+          shouldProvideSuggestions
         );
       } else if (isNonNullType(argType)) {
         throw new GraphQLError(
@@ -251,6 +259,7 @@ export function experimentalGetArgumentValues(
           coercedValues[name] = coerceDefaultValue(
             argDef.defaultValue,
             argDef.type,
+            shouldProvideSuggestions
           );
         } else if (isNonNullType(argType)) {
           throw new GraphQLError(
@@ -275,6 +284,7 @@ export function experimentalGetArgumentValues(
     const coercedValue = coerceInputLiteral(
       valueNode,
       argType,
+      shouldProvideSuggestions,
       variableValues,
       fragmentVariablesValues,
     );
@@ -308,6 +318,7 @@ export function experimentalGetArgumentValues(
 export function getDirectiveValues(
   directiveDef: GraphQLDirective,
   node: { readonly directives?: ReadonlyArray<DirectiveNode> | undefined },
+  shouldProvideSuggestions: boolean,
   variableValues?: Maybe<VariableValues>,
   fragmentVariableValues?: Maybe<VariableValues>,
 ): undefined | { [argument: string]: unknown } {
@@ -320,6 +331,7 @@ export function getDirectiveValues(
       directiveNode,
       directiveDef.args,
       variableValues,
+      shouldProvideSuggestions,
       fragmentVariableValues,
     );
   }

src/type/definition.ts

@@ -1422,20 +1422,20 @@ export class GraphQLEnumType /* <T> */ {
     return enumValue.name;
   }
 
-  parseValue(inputValue: unknown): Maybe<any> /* T */ {
+  parseValue(inputValue: unknown, shouldProvideSuggestions: boolean): Maybe<any> /* T */ {
     if (typeof inputValue !== 'string') {
       const valueStr = inspect(inputValue);
       throw new GraphQLError(
         `Enum "${this.name}" cannot represent non-string value: ${valueStr}.` +
-          didYouMeanEnumValue(this, valueStr),
+        shouldProvideSuggestions??true ? didYouMeanEnumValue(this, valueStr) : "",
       );
     }
 
     const enumValue = this.getValue(inputValue);
     if (enumValue == null) {
       throw new GraphQLError(
         `Value "${inputValue}" does not exist in "${this.name}" enum.` +
-          didYouMeanEnumValue(this, inputValue),
+        shouldProvideSuggestions??true ? didYouMeanEnumValue(this, inputValue) : "",
       );
     }
     return enumValue.value;
@@ -1445,17 +1445,18 @@ export class GraphQLEnumType /* <T> */ {
   parseLiteral(
     valueNode: ValueNode,
     _variables: Maybe<ObjMap<unknown>>,
+    shouldProvideSuggestions: boolean
   ): Maybe<any> /* T */ {
     // Note: variables will be resolved to a value before calling this function.
-    return this.parseConstLiteral(valueNode as ConstValueNode);
+    return this.parseConstLiteral(valueNode as ConstValueNode, shouldProvideSuggestions);
   }
 
-  parseConstLiteral(valueNode: ConstValueNode): Maybe<any> /* T */ {
+  parseConstLiteral(valueNode: ConstValueNode, shouldProvideSuggestions: boolean): Maybe<any> /* T */ {
     if (valueNode.kind !== Kind.ENUM) {
       const valueStr = print(valueNode);
       throw new GraphQLError(
         `Enum "${this.name}" cannot represent non-enum value: ${valueStr}.` +
-          didYouMeanEnumValue(this, valueStr),
+        shouldProvideSuggestions ?didYouMeanEnumValue(this, valueStr) : "",
         { nodes: valueNode },
       );
     }
@@ -1465,7 +1466,7 @@ export class GraphQLEnumType /* <T> */ {
       const valueStr = print(valueNode);
       throw new GraphQLError(
         `Value "${valueStr}" does not exist in "${this.name}" enum.` +
-          didYouMeanEnumValue(this, valueStr),
+        shouldProvideSuggestions ?didYouMeanEnumValue(this, valueStr) : "",
         { nodes: valueNode },
       );
     }

src/utilities/__tests__/coerceInputValue-test.ts

@@ -58,6 +58,7 @@ function coerceValue(
     (path, invalidValue, error) => {
       errors.push({ path, value: invalidValue, error: error.message });
     },
+    true
   );
 
   return { errors, value };
@@ -538,7 +539,7 @@ describe('coerceInputValue', () => {
   describe('with default onError', () => {
     it('throw error without path', () => {
       expect(() =>
-        coerceInputValue(null, new GraphQLNonNull(GraphQLInt)),
+        coerceInputValue(null, new GraphQLNonNull(GraphQLInt), undefined, true),
       ).to.throw(
         'Invalid value null: Expected non-nullable type "Int!" not to be null.',
       );
@@ -549,6 +550,8 @@ describe('coerceInputValue', () => {
         coerceInputValue(
           [null],
           new GraphQLList(new GraphQLNonNull(GraphQLInt)),
+          undefined,
+          true
         ),
       ).to.throw(
         'Invalid value null at "value[0]": Expected non-nullable type "Int!" not to be null.',
@@ -565,7 +568,7 @@ describe('coerceInputLiteral', () => {
     variableValues?: VariableValues,
   ) {
     const ast = parseValue(valueText);
-    const value = coerceInputLiteral(ast, type, variableValues);
+    const value = coerceInputLiteral(ast, type, variableValues, true);
     expect(value).to.deep.equal(expected);
   }
 
@@ -892,10 +895,10 @@ describe('coerceDefaultValue', () => {
     const defaultValueUsage = {
       literal: { kind: Kind.STRING, value: 'hello' },
     } as const;
-    expect(coerceDefaultValue(defaultValueUsage, spyScalar)).to.equal('hello');
+    expect(coerceDefaultValue(defaultValueUsage, spyScalar, true)).to.equal('hello');
 
     // Call a second time
-    expect(coerceDefaultValue(defaultValueUsage, spyScalar)).to.equal('hello');
+    expect(coerceDefaultValue(defaultValueUsage, spyScalar, true)).to.equal('hello');
     expect(parseValueCalls).to.deep.equal(['hello']);
   });
 });