Standardize error messages prior to introducing schema coordinates

Replicates graphql/graphql-js@3fdae36f

Author: Cito

src/graphql/execution/execute.py

@@ -790,7 +790,7 @@ def complete_value(
             if isinstance(completed, GraphQLWrappedResult) and completed.result is None:
                 msg = (
                     "Cannot return null for non-nullable field"
-                    f" {info.parent_type.name}.{info.field_name}."
+                    f" {info.parent_type}.{info.field_name}."
                 )
                 raise TypeError(msg)
             return completed
@@ -1087,7 +1087,7 @@ def complete_list_value(
         if not is_iterable(result):
             msg = (
                 "Expected Iterable, but did not find one for field"
-                f" '{info.parent_type.name}.{info.field_name}'."
+                f" '{info.parent_type}.{info.field_name}'."
             )
             raise GraphQLError(msg)
 
@@ -1392,10 +1392,10 @@ def ensure_valid_runtime_type(
         """Ensure that the given type is valid at runtime."""
         if runtime_type_name is None:
             msg = (
-                f"Abstract type '{return_type.name}' must resolve"
+                f"Abstract type '{return_type}' must resolve"
                 " to an Object type at runtime"
-                f" for field '{info.parent_type.name}.{info.field_name}'."
-                f" Either the '{return_type.name}' type should provide"
+                f" for field '{info.parent_type}.{info.field_name}'."
+                f" Either the '{return_type}' type should provide"
                 " a 'resolve_type' function or each possible type should provide"
                 " an 'is_type_of' function."
             )
@@ -1410,9 +1410,9 @@ def ensure_valid_runtime_type(
 
         if not isinstance(runtime_type_name, str):
             msg = (
-                f"Abstract type '{return_type.name}' must resolve"
+                f"Abstract type '{return_type}' must resolve"
                 " to an Object type at runtime"
-                f" for field '{info.parent_type.name}.{info.field_name}' with value"
+                f" for field '{info.parent_type}.{info.field_name}' with value"
                 f" {inspect(result)}, received '{inspect(runtime_type_name)}'."
             )
             raise GraphQLError(msg, to_nodes(field_group))
@@ -1421,22 +1421,22 @@ def ensure_valid_runtime_type(
 
         if runtime_type is None:
             msg = (
-                f"Abstract type '{return_type.name}' was resolved to a type"
+                f"Abstract type '{return_type}' was resolved to a type"
                 f" '{runtime_type_name}' that does not exist inside the schema."
             )
             raise GraphQLError(msg, to_nodes(field_group))
 
         if not is_object_type(runtime_type):
             msg = (
-                f"Abstract type '{return_type.name}' was resolved"
+                f"Abstract type '{return_type}' was resolved"
                 f" to a non-object type '{runtime_type_name}'."
             )
             raise GraphQLError(msg, to_nodes(field_group))
 
         if not self.schema.is_sub_type(return_type, runtime_type):
             msg = (
-                f"Runtime Object type '{runtime_type.name}' is not a possible"
-                f" type for '{return_type.name}'."
+                f"Runtime Object type '{runtime_type}' is not a possible"
+                f" type for '{return_type}'."
             )
             raise GraphQLError(msg, to_nodes(field_group))
 
@@ -2288,7 +2288,7 @@ def invalid_return_type_error(
 ) -> GraphQLError:
     """Create a GraphQLError for an invalid return type."""
     return GraphQLError(
-        f"Expected value of type '{return_type.name}' but got: {inspect(result)}.",
+        f"Expected value of type '{return_type}' but got: {inspect(result)}.",
         to_nodes(field_group),
     )
 

src/graphql/execution/values.py

@@ -215,7 +215,10 @@ def get_argument_values(
             # Note: `values_of_correct_type` validation should catch this before
             # execution. This is a runtime check to ensure execution does not
             # continue with an invalid argument value.
-            msg = f"Argument '{name}' has invalid value {print_ast(value_node)}."
+            msg = (
+                f"Argument '{name}' of type '{inspect(arg_type)}'"
+                f" has invalid value {print_ast(value_node)}."
+            )
             raise GraphQLError(msg, value_node)
         coerced_values[arg_def.out_name or name] = coerced_value
 

src/graphql/type/validate.py

@@ -136,7 +136,7 @@ def validate_root_types(self) -> None:
                 )
                 self.report_error(
                     "All root types must be different,"
-                    f" '{root_type.name}' type is used as {operation_list} root types.",
+                    f" '{root_type}' type is used as {operation_list} root types.",
                     [
                         get_operation_type_node(schema, operation_type)
                         for operation_type in operation_types
@@ -159,7 +159,7 @@ def validate_directives(self) -> None:
 
             if not directive.locations:
                 self.report_error(
-                    f"Directive @{directive.name} must include 1 or more locations.",
+                    f"Directive {directive} must include 1 or more locations.",
                     directive.ast_node,
                 )
 
@@ -171,14 +171,14 @@ def validate_directives(self) -> None:
                 # Ensure the type is an input type.
                 if not is_input_type(arg.type):
                     self.report_error(
-                        f"The type of @{directive.name}({arg_name}:)"
+                        f"The type of {directive}({arg_name}:)"
                         f" must be Input Type but got: {inspect(arg.type)}.",
                         arg.ast_node,
                     )
 
                 if is_required_argument(arg) and arg.deprecation_reason is not None:
                     self.report_error(
-                        f"Required argument @{directive.name}({arg_name}:)"
+                        f"Required argument {directive}({arg_name}:)"
                         " cannot be deprecated.",
                         [
                             get_deprecated_directive_node(arg.ast_node),
@@ -249,7 +249,7 @@ def validate_fields(self, type_: GraphQLObjectType | GraphQLInterfaceType) -> No
         # Objects and Interfaces both must define one or more fields.
         if not fields:
             self.report_error(
-                f"Type {type_.name} must define one or more fields.",
+                f"Type {type_} must define one or more fields.",
                 [type_.ast_node, *type_.extension_ast_nodes],
             )
 
@@ -260,7 +260,7 @@ def validate_fields(self, type_: GraphQLObjectType | GraphQLInterfaceType) -> No
             # Ensure the type is an output type
             if not is_output_type(field.type):
                 self.report_error(
-                    f"The type of {type_.name}.{field_name}"
+                    f"The type of {type_}.{field_name}"
                     f" must be Output Type but got: {inspect(field.type)}.",
                     field.ast_node and field.ast_node.type,
                 )
@@ -273,14 +273,14 @@ def validate_fields(self, type_: GraphQLObjectType | GraphQLInterfaceType) -> No
                 # Ensure the type is an input type.
                 if not is_input_type(arg.type):
                     self.report_error(
-                        f"The type of {type_.name}.{field_name}({arg_name}:)"
+                        f"The type of {type_}.{field_name}({arg_name}:)"
                         f" must be Input Type but got: {inspect(arg.type)}.",
                         arg.ast_node and arg.ast_node.type,
                     )
 
                 if is_required_argument(arg) and arg.deprecation_reason is not None:
                     self.report_error(
-                        f"Required argument {type_.name}.{field_name}({arg_name}:)"
+                        f"Required argument {type_}.{field_name}({arg_name}:)"
                         " cannot be deprecated.",
                         [
                             get_deprecated_directive_node(arg.ast_node),
@@ -303,14 +303,14 @@ def validate_interfaces(
 
             if type_ is iface:
                 self.report_error(
-                    f"Type {type_.name} cannot implement itself"
+                    f"Type {type_} cannot implement itself"
                     " because it would create a circular reference.",
                     get_all_implements_interface_nodes(type_, iface),
                 )
 
             if iface.name in iface_type_names:
                 self.report_error(
-                    f"Type {type_.name} can only implement {iface.name} once.",
+                    f"Type {type_} can only implement {iface.name} once.",
                     get_all_implements_interface_nodes(type_, iface),
                 )
                 continue
@@ -335,7 +335,7 @@ def validate_type_implements_interface(
             if not type_field:
                 self.report_error(
                     f"Interface field {iface.name}.{field_name}"
-                    f" expected but {type_.name} does not provide it.",
+                    f" expected but {type_} does not provide it.",
                     [
                         iface_field.ast_node,
                         type_.ast_node,
@@ -350,7 +350,7 @@ def validate_type_implements_interface(
                 self.report_error(
                     f"Interface field {iface.name}.{field_name}"
                     f" expects type {iface_field.type}"
-                    f" but {type_.name}.{field_name}"
+                    f" but {type_}.{field_name}"
                     f" is type {type_field.type}.",
                     [
                         iface_field.ast_node and iface_field.ast_node.type,
@@ -367,7 +367,7 @@ def validate_type_implements_interface(
                     self.report_error(
                         "Interface field argument"
                         f" {iface.name}.{field_name}({arg_name}:)"
-                        f" expected but {type_.name}.{field_name}"
+                        f" expected but {type_}.{field_name}"
                         " does not provide it.",
                         [iface_arg.ast_node, type_field.ast_node],
                     )
@@ -380,7 +380,7 @@ def validate_type_implements_interface(
                         "Interface field argument"
                         f" {iface.name}.{field_name}({arg_name}:)"
                         f" expects type {iface_arg.type}"
-                        f" but {type_.name}.{field_name}({arg_name}:)"
+                        f" but {type_}.{field_name}({arg_name}:)"
                         f" is type {type_arg.type}.",
                         [
                             iface_arg.ast_node and iface_arg.ast_node.type,
@@ -393,9 +393,9 @@ def validate_type_implements_interface(
                 iface_arg = iface_field.args.get(arg_name)
                 if not iface_arg and is_required_argument(type_arg):
                     self.report_error(
-                        f"Object field {type_.name}.{field_name} includes"
-                        f" required argument {arg_name} that is missing from"
-                        f" the Interface field {iface.name}.{field_name}.",
+                        f"Argument '{type_}.{field_name}({arg_name}:)' must not be"
+                        f" required type '{inspect(type_arg.type)}' if not provided"
+                        f" by the Interface field '{iface.name}.{field_name}'.",
                         [type_arg.ast_node, iface_field.ast_node],
                     )
 
@@ -408,10 +408,10 @@ def validate_type_implements_ancestors(
         for transitive in iface_interfaces:
             if transitive not in type_interfaces:
                 self.report_error(
-                    f"Type {type_.name} cannot implement {iface.name}"
+                    f"Type {type_} cannot implement {iface.name}"
                     " because it would create a circular reference."
                     if transitive is type_
-                    else f"Type {type_.name} must implement {transitive.name}"
+                    else f"Type {type_} must implement {transitive.name}"
                     f" because it is implemented by {iface.name}.",
                     get_all_implements_interface_nodes(iface, transitive)
                     + get_all_implements_interface_nodes(type_, iface),
@@ -432,7 +432,7 @@ def validate_union_members(self, union: GraphQLUnionType) -> None:
                 if member_type.name in included_type_names:
                     self.report_error(
                         f"Union type {union.name} can only include type"
-                        f" {member_type.name} once.",
+                        f" {member_type} once.",
                         get_union_member_type_nodes(union, member_type.name),
                     )
                 else:
@@ -449,7 +449,7 @@ def validate_enum_values(self, enum_type: GraphQLEnumType) -> None:
 
         if not enum_values:
             self.report_error(
-                f"Enum type {enum_type.name} must define one or more values.",
+                f"Enum type {enum_type} must define one or more values.",
                 [enum_type.ast_node, *enum_type.extension_ast_nodes],
             )
 
@@ -500,14 +500,13 @@ def validate_one_of_input_object_field(
     ) -> None:
         if is_non_null_type(field.type):
             self.report_error(
-                f"OneOf input field {type_.name}.{field_name} must be nullable.",
+                f"OneOf input field {type_}.{field_name} must be nullable.",
                 field.ast_node and field.ast_node.type,
             )
 
         if field.default_value is not Undefined:
             self.report_error(
-                f"OneOf input field {type_.name}.{field_name}"
-                " cannot have a default value.",
+                f"OneOf input field {type_}.{field_name} cannot have a default value.",
                 field.ast_node,
             )
 
@@ -565,7 +564,7 @@ def __call__(self, input_obj: GraphQLInputObjectType) -> None:
                     cycle_path = self.field_path[cycle_index:]
                     field_names = map(itemgetter(0), cycle_path)
                     self.context.report_error(
-                        f"Cannot reference Input Object '{field_type.name}'"
+                        f"Cannot reference Input Object '{field_type}'"
                         " within itself through a series of non-null fields:"
                         f" '{'.'.join(field_names)}'.",
                         cast(

src/graphql/utilities/coerce_input_value.py

@@ -83,7 +83,7 @@ def coerce_input_value(
             on_error(
                 path.as_list() if path else [],
                 input_value,
-                GraphQLError(f"Expected type '{type_.name}' to be a mapping."),
+                GraphQLError(f"Expected type '{type_}' to be a mapping."),
             )
             return Undefined
 
@@ -103,8 +103,8 @@ def coerce_input_value(
                         path.as_list() if path else [],
                         input_value,
                         GraphQLError(
-                            f"Field '{field_name}' of required type '{type_str}'"
-                            " was not provided."
+                            f"Field '{type_}.{field_name}' of required type"
+                            f" '{type_str}' was not provided."
                         ),
                     )
                 continue
@@ -121,7 +121,7 @@ def coerce_input_value(
                     path.as_list() if path else [],
                     input_value,
                     GraphQLError(
-                        f"Field '{field_name}' is not defined by type '{type_.name}'."
+                        f"Field '{field_name}' is not defined by type '{type_}'."
                         + did_you_mean(suggestions)
                     ),
                 )
@@ -133,8 +133,7 @@ def coerce_input_value(
                     path.as_list() if path else [],
                     input_value,
                     GraphQLError(
-                        "Exactly one key must be specified"
-                        f" for OneOf type '{type_.name}'.",
+                        f"Exactly one key must be specified for OneOf type '{type_}'.",
                     ),
                 )
             else:
@@ -165,16 +164,14 @@ def coerce_input_value(
             on_error(
                 path.as_list() if path else [],
                 input_value,
-                GraphQLError(
-                    f"Expected type '{type_.name}'. {error}", original_error=error
-                ),
+                GraphQLError(f"Expected type '{type_}'. {error}", original_error=error),
             )
             return Undefined
         if parse_result is Undefined:
             on_error(
                 path.as_list() if path else [],
                 input_value,
-                GraphQLError(f"Expected type '{type_.name}'."),
+                GraphQLError(f"Expected type '{type_}'."),
             )
         return parse_result