feat(interface): input type cannot inherit an interface type (#1254)

* feat(interface): input type cannot inherit an interface type

fix #1236

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Clean up rebase

* Let the exeption class take care of its message

* Test exception messages

* Move tests

* Turn into StrawberryException

* Add release file

* Apply suggestions from code review

Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Jonathan Ehwald <[email protected]>
Co-authored-by: Patrick Arminio <[email protected]>
Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>

Author: 5 people

RELEASE.md

@@ -0,0 +1,21 @@
+Release type: minor
+
+Starting with this release, Strawberry will throw an error if one of your input
+types tries to inherit from one or more interfaces. This new error enforces the
+GraphQL specification that input types cannot implement interfaces.
+
+The following code, for example, will now throw an error:
+
+```python
+import strawberry
+
+
+@strawberry.interface
+class SomeInterface:
+    some_field: str
+
+
+@strawberry.input
+class SomeInput(SomeInterface):
+    another_field: int
+```

docs/errors/invalid-superclass-interface.md

@@ -0,0 +1,27 @@
+---
+title: Invalid Superclass Interface Error
+---
+
+# Invalid Superclass Interface Error
+
+## Description
+
+This error is thrown when you define a class that has the `strawberry.input`
+decorator but also inherits from one or more classes with the
+`strawberry.interface` decorator. The underlying reason for this is that in
+GraphQL, input types cannot implement interfaces. For example, the following
+code will throw this error:
+
+```python
+import strawberry
+
+
+@strawberry.interface
+class SomeInterface:
+    some_field: str
+
+
+@strawberry.input
+class SomeInput(SomeInterface):
+    another_field: int
+```

strawberry/exceptions/__init__.py

@@ -10,6 +10,7 @@
 from .exception import StrawberryException, UnableToFindExceptionSource
 from .handler import setup_exception_handler
 from .invalid_argument_type import InvalidArgumentTypeError
+from .invalid_superclass_interface import InvalidSuperclassInterfaceError
 from .invalid_union_type import InvalidTypeForUnionMergeError, InvalidUnionTypeError
 from .missing_arguments_annotations import MissingArgumentsAnnotationsError
 from .missing_dependencies import MissingOptionalDependenciesError
@@ -174,6 +175,7 @@ def __init__(self, payload: dict[str, object] | None = None) -> None:
     "InvalidArgumentTypeError",
     "InvalidCustomContext",
     "InvalidDefaultFactoryError",
+    "InvalidSuperclassInterfaceError",
     "InvalidTypeForUnionMergeError",
     "InvalidUnionTypeError",
     "MissingArgumentsAnnotationsError",

strawberry/exceptions/invalid_superclass_interface.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from functools import cached_property
+from typing import TYPE_CHECKING, Optional
+
+from .exception import StrawberryException
+from .utils.source_finder import SourceFinder
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from strawberry.types.base import StrawberryObjectDefinition
+
+    from .exception_source import ExceptionSource
+
+
+class InvalidSuperclassInterfaceError(StrawberryException):
+    def __init__(
+        self,
+        cls: type[type],
+        input_name: str,
+        interfaces: Iterable[StrawberryObjectDefinition],
+    ) -> None:
+        self.cls = cls
+        pretty_interface_names = ", ".join(interface.name for interface in interfaces)
+
+        self.message = self.rich_message = (
+            f"Input class {input_name!r} cannot inherit "
+            f"from interface(s): {pretty_interface_names}"
+        )
+
+        self.annotation_message = "input type class defined here"
+
+        self.suggestion = "To fix this error, make sure your input type class does not inherit from any interfaces."
+
+        super().__init__(self.message)
+
+    @cached_property
+    def exception_source(self) -> Optional[ExceptionSource]:
+        source_finder = SourceFinder()
+        return source_finder.find_class_from_object(self.cls)

strawberry/types/object_type.py

@@ -15,6 +15,7 @@
 from typing_extensions import dataclass_transform
 
 from strawberry.exceptions import (
+    InvalidSuperclassInterfaceError,
     MissingFieldAnnotationError,
     MissingReturnAnnotationError,
     ObjectIsNotClassError,
@@ -151,6 +152,11 @@ def _process_type(
     is_type_of = getattr(cls, "is_type_of", None)
     resolve_type = getattr(cls, "resolve_type", None)
 
+    if is_input and interfaces:
+        raise InvalidSuperclassInterfaceError(
+            cls=cls, input_name=name, interfaces=interfaces
+        )
+
     cls.__strawberry_definition__ = StrawberryObjectDefinition(  # type: ignore[attr-defined]
         name=name,
         is_input=is_input,

tests/schema/test_input.py

@@ -1,7 +1,11 @@
+import re
 import textwrap
 from typing import Optional
 
+import pytest
+
 import strawberry
+from strawberry.exceptions import InvalidSuperclassInterfaceError
 from strawberry.printer import print_schema
 from tests.conftest import skip_if_gql_32
 
@@ -102,3 +106,39 @@ def example(self, data: Input) -> ExampleOutput:
     assert not result.errors
     expected_result = {"inputId": 10, "nonScalarId": 10, "nonScalarNullableField": None}
     assert result.data["example"] == expected_result
+
+
+@pytest.mark.raises_strawberry_exception(
+    InvalidSuperclassInterfaceError,
+    match=re.escape(
+        "Input class 'SomeInput' cannot inherit from interface(s): SomeInterface"
+    ),
+)
+def test_input_cannot_inherit_from_interface():
+    @strawberry.interface
+    class SomeInterface:
+        some_arg: str
+
+    @strawberry.input
+    class SomeInput(SomeInterface):
+        another_arg: str
+
+
+@pytest.mark.raises_strawberry_exception(
+    InvalidSuperclassInterfaceError,
+    match=re.escape(
+        "Input class 'SomeOtherInput' cannot inherit from interface(s): SomeInterface, SomeOtherInterface"
+    ),
+)
+def test_input_cannot_inherit_from_interfaces():
+    @strawberry.interface
+    class SomeInterface:
+        some_arg: str
+
+    @strawberry.interface
+    class SomeOtherInterface:
+        some_other_arg: str
+
+    @strawberry.input
+    class SomeOtherInput(SomeInterface, SomeOtherInterface):
+        another_arg: str