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,10 @@ export function validateExecutionArgs(
     schema,
     variableDefinitions,
     rawVariableValues ?? {},
-    { maxErrors: 50 },
+    {
+      maxErrors: 50,
+      shouldProvideSuggestions: shouldProvideSuggestions ?? true,
+    },
   );
 
   if (variableValuesOrErrors.errors) {
@@ -545,6 +551,7 @@ export function validateExecutionArgs(
     typeResolver: typeResolver ?? defaultTypeResolver,
     subscribeFieldResolver: subscribeFieldResolver ?? defaultFieldResolver,
     enableEarlyExecution: enableEarlyExecution === true,
+    shouldProvideSuggestions: shouldProvideSuggestions ?? true,
   };
 }
 
@@ -728,7 +735,8 @@ 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 +763,7 @@ function executeField(
       fieldGroup[0].node,
       fieldDef.args,
       variableValues,
+      shouldProvideSuggestions,
       fieldGroup[0].fragmentVariableValues,
     );
 
@@ -1058,12 +1067,14 @@ 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 +2083,12 @@ 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,10 +55,11 @@ 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;
+  const shouldProvideSuggestions = options?.shouldProvideSuggestions ?? true;
   try {
     const variableValues = coerceVariableValues(
       schema,
@@ -72,6 +73,7 @@ export function getVariableValues(
         }
         errors.push(error);
       },
+      shouldProvideSuggestions,
     );
 
     if (errors.length === 0) {
@@ -89,6 +91,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 +108,11 @@ 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(
@@ -136,6 +143,7 @@ function coerceVariableValues(
     coerced[varName] = coerceInputValue(
       value,
       varType,
+      shouldProvideSuggestions,
       (path, invalidValue, error) => {
         let prefix =
           `Variable "$${varName}" got invalid value ` + inspect(invalidValue);
@@ -159,6 +167,7 @@ export function getFragmentVariableValues(
   fragmentSpreadNode: FragmentSpreadNode,
   fragmentSignatures: ReadOnlyObjMap<GraphQLVariableSignature>,
   variableValues: VariableValues,
+  shouldProvideSuggestions: boolean,
   fragmentVariableValues?: Maybe<VariableValues>,
 ): VariableValues {
   const varSignatures: Array<GraphQLVariableSignature> = [];
@@ -177,6 +186,7 @@ export function getFragmentVariableValues(
     fragmentSpreadNode,
     varSignatures,
     variableValues,
+    shouldProvideSuggestions,
     fragmentVariableValues,
   );
 
@@ -194,15 +204,22 @@ 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);
+  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 +239,7 @@ export function experimentalGetArgumentValues(
         coercedValues[name] = coerceDefaultValue(
           argDef.defaultValue,
           argDef.type,
+          shouldProvideSuggestions,
         );
       } else if (isNonNullType(argType)) {
         throw new GraphQLError(
@@ -251,6 +269,7 @@ export function experimentalGetArgumentValues(
           coercedValues[name] = coerceDefaultValue(
             argDef.defaultValue,
             argDef.type,
+            shouldProvideSuggestions,
           );
         } else if (isNonNullType(argType)) {
           throw new GraphQLError(
@@ -275,6 +294,7 @@ export function experimentalGetArgumentValues(
     const coercedValue = coerceInputLiteral(
       valueNode,
       argType,
+      shouldProvideSuggestions,
       variableValues,
       fragmentVariablesValues,
     );
@@ -308,6 +328,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 +341,7 @@ export function getDirectiveValues(
       directiveNode,
       directiveDef.args,
       variableValues,
+      shouldProvideSuggestions,
       fragmentVariableValues,
     );
   }

src/type/definition.ts

@@ -1422,20 +1422,27 @@ 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
+          ? 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
+          ? didYouMeanEnumValue(this, inputValue)
+          : ''),
       );
     }
     return enumValue.value;
@@ -1445,17 +1452,24 @@ 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 +1479,9 @@ 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

@@ -55,6 +55,7 @@ function coerceValue(
   const value = coerceInputValue(
     inputValue,
     type,
+    true,
     (path, invalidValue, error) => {
       errors.push({ path, value: invalidValue, error: error.message });
     },
@@ -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), true),
       ).to.throw(
         'Invalid value null: Expected non-nullable type "Int!" not to be null.',
       );
@@ -549,6 +550,7 @@ describe('coerceInputValue', () => {
         coerceInputValue(
           [null],
           new GraphQLList(new GraphQLNonNull(GraphQLInt)),
+          true,
         ),
       ).to.throw(
         'Invalid value null at "value[0]": Expected non-nullable type "Int!" not to be null.',
@@ -565,7 +567,7 @@ describe('coerceInputLiteral', () => {
     variableValues?: VariableValues,
   ) {
     const ast = parseValue(valueText);
-    const value = coerceInputLiteral(ast, type, variableValues);
+    const value = coerceInputLiteral(ast, type, true, variableValues);
     expect(value).to.deep.equal(expected);
   }
 
@@ -892,10 +894,14 @@ 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']);
   });
 });