Validation: Remove internal functions for error messages

Replicates graphql/graphql-js@5d28d35
and graphql/graphql-js@58e2f5f

Author: Cito

docs/usage/validator.rst

@@ -31,7 +31,7 @@ In this case, we will get::
          " Did you mean 'homePlanet'?",
          locations=[SourceLocation(line=5, column=9)]),
      GraphQLError(
-        "Field 'friends' of type '[Character]' must have a sub selection of subfields."
+        "Field 'friends' of type '[Character]' must have a selection of subfields."
          "  Did you mean 'friends { ... }'?",
          locations=[SourceLocation(line=6, column=9)])]
 

src/graphql/validation/rules/executable_definitions.py

@@ -11,11 +11,7 @@
 )
 from . import ASTValidationRule
 
-__all__ = ["ExecutableDefinitionsRule", "non_executable_definitions_message"]
-
-
-def non_executable_definitions_message(def_name: str) -> str:
-    return f"The {def_name} definition is not executable."
+__all__ = ["ExecutableDefinitionsRule"]
 
 
 class ExecutableDefinitionsRule(ASTValidationRule):
@@ -28,19 +24,18 @@ class ExecutableDefinitionsRule(ASTValidationRule):
     def enter_document(self, node: DocumentNode, *_args):
         for definition in node.definitions:
             if not isinstance(definition, ExecutableDefinitionNode):
+                def_name = (
+                    "schema"
+                    if isinstance(
+                        definition, (SchemaDefinitionNode, SchemaExtensionNode)
+                    )
+                    else cast(
+                        Union[DirectiveDefinitionNode, TypeDefinitionNode], definition,
+                    ).name.value
+                )
                 self.report_error(
                     GraphQLError(
-                        non_executable_definitions_message(
-                            "schema"
-                            if isinstance(
-                                definition, (SchemaDefinitionNode, SchemaExtensionNode)
-                            )
-                            else cast(
-                                Union[DirectiveDefinitionNode, TypeDefinitionNode],
-                                definition,
-                            ).name.value
-                        ),
-                        definition,
+                        f"The {def_name} definition is not executable.", definition,
                     )
                 )
         return self.SKIP

src/graphql/validation/rules/fields_on_correct_type.py

@@ -14,19 +14,7 @@
 from ...pyutils import did_you_mean, suggestion_list
 from . import ValidationRule
 
-__all__ = ["FieldsOnCorrectTypeRule", "undefined_field_message"]
-
-
-def undefined_field_message(
-    field_name: str,
-    type_: str,
-    suggested_type_names: List[str],
-    suggested_field_names: List[str],
-) -> str:
-    hint = did_you_mean(
-        [f"'{s}'" for s in suggested_type_names], "to use an inline fragment on"
-    ) or did_you_mean([f"'{s}'" for s in suggested_field_names])
-    return f"Cannot query field '{field_name}' on type '{type_}'.{hint}"
+__all__ = ["FieldsOnCorrectTypeRule"]
 
 
 class FieldsOnCorrectTypeRule(ValidationRule):
@@ -54,10 +42,14 @@ def enter_field(self, node: FieldNode, *_args):
         )
 
         # Report an error, including helpful suggestions.
+        quoted_type_names = [f"'{s}'" for s in suggested_type_names]
+        quoted_field_names = [f"'{s}'" for s in suggested_field_names]
         self.report_error(
             GraphQLError(
-                undefined_field_message(
-                    field_name, type_.name, suggested_type_names, suggested_field_names
+                f"Cannot query field '{field_name}' on type '{type_}'."
+                + (
+                    did_you_mean(quoted_type_names, "to use an inline fragment on")
+                    or did_you_mean(quoted_field_names)
                 ),
                 node,
             )

src/graphql/validation/rules/fragments_on_composite_types.py

@@ -4,19 +4,7 @@
 from ...utilities import type_from_ast
 from . import ValidationRule
 
-__all__ = [
-    "FragmentsOnCompositeTypesRule",
-    "inline_fragment_on_non_composite_error_message",
-    "fragment_on_non_composite_error_message",
-]
-
-
-def inline_fragment_on_non_composite_error_message(type_: str) -> str:
-    return f"Fragment cannot condition on non composite type '{type_}'."
-
-
-def fragment_on_non_composite_error_message(frag_name: str, type_: str) -> str:
-    return f"Fragment '{frag_name}' cannot condition on non composite type '{type_}'."
+__all__ = ["FragmentsOnCompositeTypesRule"]
 
 
 class FragmentsOnCompositeTypesRule(ValidationRule):
@@ -32,11 +20,11 @@ def enter_inline_fragment(self, node: InlineFragmentNode, *_args):
         if type_condition:
             type_ = type_from_ast(self.context.schema, type_condition)
             if type_ and not is_composite_type(type_):
+                type_str = print_ast(type_condition)
                 self.report_error(
                     GraphQLError(
-                        inline_fragment_on_non_composite_error_message(
-                            print_ast(type_condition)
-                        ),
+                        "Fragment cannot condition"
+                        f" on non composite type '{type_str}'.",
                         type_condition,
                     )
                 )
@@ -45,11 +33,11 @@ def enter_fragment_definition(self, node: FragmentDefinitionNode, *_args):
         type_condition = node.type_condition
         type_ = type_from_ast(self.context.schema, type_condition)
         if type_ and not is_composite_type(type_):
+            type_str = print_ast(type_condition)
             self.report_error(
                 GraphQLError(
-                    fragment_on_non_composite_error_message(
-                        node.name.value, print_ast(type_condition)
-                    ),
+                    f"Fragment '{node.name.value}' cannot condition"
+                    f" on non composite type '{type_str}'.",
                     type_condition,
                 )
             )

src/graphql/validation/rules/known_argument_names.py

@@ -6,29 +6,7 @@
 from ...type import specified_directives
 from . import ASTValidationRule, SDLValidationContext, ValidationContext
 
-__all__ = [
-    "KnownArgumentNamesRule",
-    "KnownArgumentNamesOnDirectivesRule",
-    "unknown_arg_message",
-    "unknown_directive_arg_message",
-]
-
-
-def unknown_arg_message(
-    arg_name: str, field_name: str, type_name: str, suggested_args: List[str]
-) -> str:
-    hint = did_you_mean([f"'{s}'" for s in suggested_args])
-    return (
-        f"Unknown argument '{arg_name}' on field '{field_name}'"
-        f" of type '{type_name}'.{hint}"
-    )
-
-
-def unknown_directive_arg_message(
-    arg_name: str, directive_name: str, suggested_args: List[str]
-) -> str:
-    hint = did_you_mean([f"'{s}'" for s in suggested_args])
-    return f"Unknown argument '{arg_name}' on directive '@{directive_name}'. {hint}"
+__all__ = ["KnownArgumentNamesRule", "KnownArgumentNamesOnDirectivesRule"]
 
 
 class KnownArgumentNamesOnDirectivesRule(ASTValidationRule):
@@ -67,9 +45,9 @@ def enter_directive(self, directive_node: DirectiveNode, *_args):
                     suggestions = suggestion_list(arg_name, known_args)
                     self.report_error(
                         GraphQLError(
-                            unknown_directive_arg_message(
-                                arg_name, directive_name, suggestions
-                            ),
+                            f"Unknown argument '{arg_name}'"
+                            f" on directive '@{directive_name}'."
+                            + did_you_mean([f"'{s}'" for s in suggestions]),
                             arg_node,
                         )
                     )
@@ -96,14 +74,12 @@ def enter_argument(self, arg_node: ArgumentNode, *args):
             arg_name = arg_node.name.value
             field_name = args[3][-1].name.value
             known_args_names = list(field_def.args)
+            suggestions = suggestion_list(arg_name, known_args_names)
             context.report_error(
                 GraphQLError(
-                    unknown_arg_message(
-                        arg_name,
-                        field_name,
-                        parent_type.name,
-                        suggestion_list(arg_name, known_args_names),
-                    ),
+                    f"Unknown argument '{arg_name}' on field '{field_name}'"
+                    f" of type '{parent_type.name}'."
+                    + did_you_mean([f"'{s}'" for s in suggestions]),
                     arg_node,
                 )
             )

src/graphql/validation/rules/known_directives.py

@@ -11,19 +11,7 @@
 from ...type import specified_directives
 from . import ASTValidationRule, SDLValidationContext, ValidationContext
 
-__all__ = [
-    "KnownDirectivesRule",
-    "unknown_directive_message",
-    "misplaced_directive_message",
-]
-
-
-def unknown_directive_message(directive_name: str) -> str:
-    return f"Unknown directive '{directive_name}'."
-
-
-def misplaced_directive_message(directive_name: str, location: str) -> str:
-    return f"Directive '{directive_name}' may not be used on {location}."
+__all__ = ["KnownDirectivesRule"]
 
 
 class KnownDirectivesRule(ASTValidationRule):
@@ -61,16 +49,13 @@ def enter_directive(self, node: DirectiveNode, _key, _parent, _path, ancestors):
             if candidate_location and candidate_location not in locations:
                 self.report_error(
                     GraphQLError(
-                        misplaced_directive_message(
-                            node.name.value, candidate_location.value
-                        ),
+                        f"Directive '{name}'"
+                        f" may not be used on {candidate_location.value}.",
                         node,
                     )
                 )
         else:
-            self.report_error(
-                GraphQLError(unknown_directive_message(node.name.value), node)
-            )
+            self.report_error(GraphQLError(f"Unknown directive '{name}'.", node))
 
 
 _operation_location = {

src/graphql/validation/rules/known_fragment_names.py

@@ -2,11 +2,7 @@
 from ...language import FragmentSpreadNode
 from . import ValidationRule
 
-__all__ = ["KnownFragmentNamesRule", "unknown_fragment_message"]
-
-
-def unknown_fragment_message(fragment_name: str) -> str:
-    return f"Unknown fragment '{fragment_name}'."
+__all__ = ["KnownFragmentNamesRule"]
 
 
 class KnownFragmentNamesRule(ValidationRule):
@@ -21,5 +17,5 @@ def enter_fragment_spread(self, node: FragmentSpreadNode, *_args):
         fragment = self.context.get_fragment(fragment_name)
         if not fragment:
             self.report_error(
-                GraphQLError(unknown_fragment_message(fragment_name), node.name)
+                GraphQLError(f"Unknown fragment '{fragment_name}'.", node.name)
             )

src/graphql/validation/rules/known_type_names.py

@@ -13,12 +13,7 @@
 from ...pyutils import did_you_mean, suggestion_list
 from . import ASTValidationRule, ValidationContext, SDLValidationContext
 
-__all__ = ["KnownTypeNamesRule", "unknown_type_message"]
-
-
-def unknown_type_message(type_name: str, suggested_types: List[str]) -> str:
-    hint = did_you_mean([f"'{s}'" for s in suggested_types])
-    return f"Unknown type '{type_name}'.{hint}"
+__all__ = ["KnownTypeNamesRule"]
 
 
 class KnownTypeNamesRule(ASTValidationRule):
@@ -65,7 +60,11 @@ def enter_named_type(
                 else self.type_names,
             )
             self.report_error(
-                GraphQLError(unknown_type_message(type_name, suggested_types), node)
+                GraphQLError(
+                    f"Unknown type '{type_name}'."
+                    + did_you_mean([f"'{s}'" for s in suggested_types]),
+                    node,
+                )
             )
 
 

src/graphql/validation/rules/lone_anonymous_operation.py

@@ -2,11 +2,7 @@
 from ...language import DocumentNode, OperationDefinitionNode
 from . import ASTValidationContext, ASTValidationRule
 
-__all__ = ["LoneAnonymousOperationRule", "anonymous_operation_not_alone_message"]
-
-
-def anonymous_operation_not_alone_message() -> str:
-    return "This anonymous operation must be the only defined operation."
+__all__ = ["LoneAnonymousOperationRule"]
 
 
 class LoneAnonymousOperationRule(ASTValidationRule):
@@ -30,5 +26,7 @@ def enter_document(self, node: DocumentNode, *_args):
     def enter_operation_definition(self, node: OperationDefinitionNode, *_args):
         if not node.name and self.operation_count > 1:
             self.report_error(
-                GraphQLError(anonymous_operation_not_alone_message(), node)
+                GraphQLError(
+                    "This anonymous operation must be the only defined operation.", node
+                )
             )

src/graphql/validation/rules/lone_schema_definition.py

@@ -2,19 +2,7 @@
 from ...language import SchemaDefinitionNode
 from . import SDLValidationRule, SDLValidationContext
 
-__all__ = [
-    "LoneSchemaDefinitionRule",
-    "schema_definition_not_alone_message",
-    "cannot_define_schema_within_extension_message",
-]
-
-
-def schema_definition_not_alone_message():
-    return "Must provide only one schema definition."
-
-
-def cannot_define_schema_within_extension_message():
-    return "Cannot define a new schema within a schema extension."
+__all__ = ["LoneSchemaDefinitionRule"]
 
 
 class LoneSchemaDefinitionRule(SDLValidationRule):
@@ -37,11 +25,13 @@ def __init__(self, context: SDLValidationContext) -> None:
     def enter_schema_definition(self, node: SchemaDefinitionNode, *_args):
         if self.already_defined:
             self.report_error(
-                GraphQLError(cannot_define_schema_within_extension_message(), node)
+                GraphQLError(
+                    "Cannot define a new schema within a schema extension.", node
+                )
             )
         else:
             if self.schema_definitions_count:
                 self.report_error(
-                    GraphQLError(schema_definition_not_alone_message(), node)
+                    GraphQLError("Must provide only one schema definition.", node)
                 )
             self.schema_definitions_count += 1

src/graphql/validation/rules/no_fragment_cycles.py

@@ -4,12 +4,7 @@
 from ...language import FragmentDefinitionNode, FragmentSpreadNode
 from . import ASTValidationContext, ASTValidationRule
 
-__all__ = ["NoFragmentCyclesRule", "cycle_error_message"]
-
-
-def cycle_error_message(frag_name: str, spread_names: List[str]) -> str:
-    via = f" via {', '.join(spread_names)}" if spread_names else ""
-    return f"Cannot spread fragment '{frag_name}' within itself{via}."
+__all__ = ["NoFragmentCyclesRule"]
 
 
 class NoFragmentCyclesRule(ASTValidationRule):
@@ -63,10 +58,12 @@ def detect_cycle_recursive(self, fragment: FragmentDefinitionNode):
                     self.detect_cycle_recursive(spread_fragment)
             else:
                 cycle_path = spread_path[cycle_index:]
-                fragment_names = [s.name.value for s in cycle_path[:-1]]
+                via_names = [s.name.value for s in cycle_path[:-1]]
                 self.report_error(
                     GraphQLError(
-                        cycle_error_message(spread_name, fragment_names), cycle_path
+                        f"Cannot spread fragment '{spread_name}' within itself"
+                        + (f" via {', '.join(via_names)}." if via_names else "."),
+                        cycle_path,
                     )
                 )
             spread_path.pop()