Allow skipping suggestions

graphql · Oct 4, 2024 · 43b2f4e · 43b2f4e
1 parent a1d22a2
commit 43b2f4e
Show file tree

Hide file tree

Showing 7 changed files with 25 additions and 12 deletions.
diff --git a/src/validation/ValidationContext.ts b/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
   }
 
   get [Symbol.toStringTag]() {
     return 'ValidationContext';
   }
 
+  get shouldProvideSuggestions() {
+    return this._shouldProvideSuggestions
+  }
+
   getSchema(): GraphQLSchema {
     return this._schema;
   }

diff --git a/src/validation/rules/FieldsOnCorrectTypeRule.ts b/src/validation/rules/FieldsOnCorrectTypeRule.ts
@@ -45,12 +45,12 @@ 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.

diff --git a/src/validation/rules/KnownArgumentNamesRule.ts b/src/validation/rules/KnownArgumentNamesRule.ts
@@ -34,12 +34,12 @@ export function KnownArgumentNamesRule(context: ValidationContext): ASTVisitor {
         );
         if (!varDef) {
           const argName = argNode.name.value;
-          const suggestions = suggestionList(
+          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 +57,10 @@ export function KnownArgumentNamesRule(context: ValidationContext): ASTVisitor {
 
       if (!argDef && fieldDef && parentType) {
         const argName = argNode.name.value;
-        const suggestions = suggestionList(
+        const suggestions = context.shouldProvideSuggestions ? suggestionList(
           argName,
           fieldDef.args.map((arg) => arg.name),
-        );
+        ) : [];
         context.reportError(
           new GraphQLError(
             `Unknown argument "${argName}" on field "${parentType}.${fieldDef.name}".` +

diff --git a/src/validation/rules/KnownTypeNamesRule.ts b/src/validation/rules/KnownTypeNamesRule.ts
@@ -48,10 +48,10 @@ export function KnownTypeNamesRule(
           return;
         }
 
-        const suggestedTypes = suggestionList(
+        const suggestedTypes = context.shouldProvideSuggestions ? suggestionList(
           typeName,
           isSDL ? [...standardTypeNames, ...typeNames] : [...typeNames],
-        );
+        ) : [];
         context.reportError(
           new GraphQLError(
             `Unknown type "${typeName}".` + didYouMean(suggestedTypes),

diff --git a/src/validation/rules/PossibleTypeExtensionsRule.ts b/src/validation/rules/PossibleTypeExtensionsRule.ts
@@ -78,7 +78,7 @@ 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.` +

diff --git a/src/validation/rules/ValuesOfCorrectTypeRule.ts b/src/validation/rules/ValuesOfCorrectTypeRule.ts
@@ -97,10 +97,10 @@ export function ValuesOfCorrectTypeRule(
       const parentType = getNamedType(context.getParentInputType());
       const fieldType = context.getInputType();
       if (!fieldType && isInputObjectType(parentType)) {
-        const suggestions = suggestionList(
+        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}".` +

diff --git a/src/validation/validate.ts b/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,