Allow skipping suggestions

Author: JoviDeCroock

src/validation/ValidationContext.ts

@@ -154,6 +154,10 @@ export class SDLValidationContext extends ASTValidationContext {
     this._schema = schema;
   }
 
+  get shouldProvideSuggestions() {
+    return true;
+  }
+
   get [Symbol.toStringTag]() {
     return 'SDLValidationContext';
   }
@@ -177,24 +181,31 @@ export class ValidationContext extends ASTValidationContext {
     OperationDefinitionNode,
     ReadonlyArray<VariableUsage>
   >;
+  private _shouldProvideSuggestions: boolean;
 
   constructor(
     schema: GraphQLSchema,
     ast: DocumentNode,
     typeInfo: TypeInfo,
     onError: (error: GraphQLError) => void,
+    shouldProvideSuggestions?: boolean,
   ) {
     super(ast, onError);
     this._schema = schema;
     this._typeInfo = typeInfo;
     this._variableUsages = new Map();
     this._recursiveVariableUsages = new Map();
+    this._shouldProvideSuggestions = shouldProvideSuggestions ?? true;
   }
 
   get [Symbol.toStringTag]() {
     return 'ValidationContext';
   }
 
+  get shouldProvideSuggestions() {
+    return this._shouldProvideSuggestions;
+  }
+
   getSchema(): GraphQLSchema {
     return this._schema;
   }

src/validation/rules/FieldsOnCorrectTypeRule.ts

@@ -45,12 +45,18 @@ export function FieldsOnCorrectTypeRule(
           // First determine if there are any suggested types to condition on.
           let suggestion = didYouMean(
             'to use an inline fragment on',
-            getSuggestedTypeNames(schema, type, fieldName),
+            context.shouldProvideSuggestions
+              ? getSuggestedTypeNames(schema, type, fieldName)
+              : [],
           );
 
           // If there are no suggested types, then perhaps this was a typo?
           if (suggestion === '') {
-            suggestion = didYouMean(getSuggestedFieldNames(type, fieldName));
+            suggestion = didYouMean(
+              context.shouldProvideSuggestions
+                ? getSuggestedFieldNames(type, fieldName)
+                : [],
+            );
           }
 
           // Report an error, including helpful suggestions.

src/validation/rules/KnownArgumentNamesRule.ts

@@ -34,12 +34,14 @@ export function KnownArgumentNamesRule(context: ValidationContext): ASTVisitor {
         );
         if (!varDef) {
           const argName = argNode.name.value;
-          const suggestions = suggestionList(
-            argName,
-            Array.from(fragmentSignature.variableDefinitions.values()).map(
-              (varSignature) => varSignature.variable.name.value,
-            ),
-          );
+          const suggestions = context.shouldProvideSuggestions
+            ? suggestionList(
+                argName,
+                Array.from(fragmentSignature.variableDefinitions.values()).map(
+                  (varSignature) => varSignature.variable.name.value,
+                ),
+              )
+            : [];
           context.reportError(
             new GraphQLError(
               `Unknown argument "${argName}" on fragment "${fragmentSignature.definition.name.value}".` +
@@ -57,10 +59,12 @@ export function KnownArgumentNamesRule(context: ValidationContext): ASTVisitor {
 
       if (!argDef && fieldDef && parentType) {
         const argName = argNode.name.value;
-        const suggestions = suggestionList(
-          argName,
-          fieldDef.args.map((arg) => arg.name),
-        );
+        const suggestions = context.shouldProvideSuggestions
+          ? suggestionList(
+              argName,
+              fieldDef.args.map((arg) => arg.name),
+            )
+          : [];
         context.reportError(
           new GraphQLError(
             `Unknown argument "${argName}" on field "${parentType}.${fieldDef.name}".` +

src/validation/rules/KnownTypeNamesRule.ts

@@ -48,10 +48,12 @@ export function KnownTypeNamesRule(
           return;
         }
 
-        const suggestedTypes = suggestionList(
-          typeName,
-          isSDL ? [...standardTypeNames, ...typeNames] : [...typeNames],
-        );
+        const suggestedTypes = context.shouldProvideSuggestions
+          ? suggestionList(
+              typeName,
+              isSDL ? [...standardTypeNames, ...typeNames] : [...typeNames],
+            )
+          : [];
         context.reportError(
           new GraphQLError(
             `Unknown type "${typeName}".` + didYouMean(suggestedTypes),

src/validation/rules/PossibleTypeExtensionsRule.ts

@@ -78,7 +78,9 @@ export function PossibleTypeExtensionsRule(
         ...Object.keys(schema?.getTypeMap() ?? {}),
       ];
 
-      const suggestedTypes = suggestionList(typeName, allTypeNames);
+      const suggestedTypes = context.shouldProvideSuggestions
+        ? suggestionList(typeName, allTypeNames)
+        : [];
       context.reportError(
         new GraphQLError(
           `Cannot extend type "${typeName}" because it is not defined.` +

src/validation/rules/ValuesOfCorrectTypeRule.ts

@@ -97,10 +97,9 @@ export function ValuesOfCorrectTypeRule(
       const parentType = getNamedType(context.getParentInputType());
       const fieldType = context.getInputType();
       if (!fieldType && isInputObjectType(parentType)) {
-        const suggestions = suggestionList(
-          node.name.value,
-          Object.keys(parentType.getFields()),
-        );
+        const suggestions = context.shouldProvideSuggestions
+          ? suggestionList(node.name.value, Object.keys(parentType.getFields()))
+          : [];
         context.reportError(
           new GraphQLError(
             `Field "${node.name.value}" is not defined by type "${parentType}".` +

src/validation/validate.ts

@@ -41,9 +41,10 @@ export function validate(
   schema: GraphQLSchema,
   documentAST: DocumentNode,
   rules: ReadonlyArray<ValidationRule> = specifiedRules,
-  options?: { maxErrors?: number },
+  options?: { maxErrors?: number; shouldProvideSuggestions?: boolean },
 ): ReadonlyArray<GraphQLError> {
   const maxErrors = options?.maxErrors ?? 100;
+  const shouldProvideSuggestions = options?.shouldProvideSuggestions ?? true;
 
   // If the schema used for validation is invalid, throw an error.
   assertValidSchema(schema);
@@ -63,6 +64,7 @@ export function validate(
       }
       errors.push(error);
     },
+    shouldProvideSuggestions,
   );
 
   // This uses a specialized visitor which runs multiple visitors in parallel,