Object Extension Draft

strawberry/object_type.py

@@ -23,10 +23,9 @@
 )
 from .field import StrawberryField, field
 from .type import get_object_definition
+from .types.type_extension import TypeExtension
 from .types.type_resolver import _get_fields
-from .types.types import (
- StrawberryObjectDefinition,
-)
+from .types.types import StrawberryObjectDefinition
 from .utils.dataclasses import add_custom_init_fn
 from .utils.deprecations import DEPRECATION_MESSAGES, DeprecatedDescriptor
 from .utils.str_converters import to_camel_case
@@ -133,15 +132,20 @@ def _process_type(
  description: Optional[str] = None,
  directives: Optional[Sequence[object]] = (),
  extend: bool = False,
+ extension: Optional[TypeExtension] = None,
 ):
- name = name or to_camel_case(cls.__name__)
+ # TODO: Can _process_type be changes so builder is required?
+ # breaks peoples code, but IS internal function
+ if extension is None:
+ extension = TypeExtension()
 
- interfaces = _get_interfaces(cls)
- fields = _get_fields(cls)
+ name = name or to_camel_case(cls.__name__)
  is_type_of = getattr(cls, "is_type_of", None)
  resolve_type = getattr(cls, "resolve_type", None)
+ interfaces = _get_interfaces(cls)
+ fields = _get_fields(cls, extension)
 
- cls.__strawberry_definition__ = StrawberryObjectDefinition(
+ cls.__strawberry_definition__ = extension.create_object_definition(
  name=name,
  is_input=is_input,
  is_interface=is_interface,
@@ -182,6 +186,7 @@ def _process_type(
 
  setattr(cls, field_.python_name, wrapped_func)
 
+ extension.after_process(cls)
  return cls
 
 
@@ -198,6 +203,7 @@ def type(
  description: Optional[str] = None,
  directives: Optional[Sequence[object]] = (),
  extend: bool = False,
+ extension: Optional[TypeExtension] = None,
 ) -> T:
  ...
 
@@ -214,6 +220,7 @@ def type(
  description: Optional[str] = None,
  directives: Optional[Sequence[object]] = (),
  extend: bool = False,
+ extension: Optional[TypeExtension] = None,
 ) -> Callable[[T], T]:
  ...
 
@@ -227,6 +234,7 @@ def type(
  description: Optional[str] = None,
  directives: Optional[Sequence[object]] = (),
  extend: bool = False,
+ extension: Optional[TypeExtension] = None,
 ) -> Union[T, Callable[[T], T]]:
  """Annotates a class as a GraphQL type.
 
@@ -236,6 +244,8 @@ def type(
  >>> class X:
  >>> field_abc: str = "ABC"
  """
+ if extension is None:
+ extension = TypeExtension()
 
  def wrap(cls: Type):
  if not inspect.isclass(cls):
@@ -247,6 +257,7 @@ def wrap(cls: Type):
  exc = ObjectIsNotClassError.type
  raise exc(cls)
 
+ extension.before_wrap_dataclass(cls)
  wrapped = _wrap_dataclass(cls)
  return _process_type(
  wrapped,
@@ -256,6 +267,7 @@ def wrap(cls: Type):
  description=description,
  directives=directives,
  extend=extend,
+ extension=extension,
  )
 
  if cls is None:
@@ -274,6 +286,7 @@ def input(
  name: Optional[str] = None,
  description: Optional[str] = None,
  directives: Optional[Sequence[object]] = (),
+ extension: Optional[TypeExtension] = None,
 ) -> T:
  ...
 
@@ -287,6 +300,7 @@ def input(
  name: Optional[str] = None,
  description: Optional[str] = None,
  directives: Optional[Sequence[object]] = (),
+ extension: Optional[TypeExtension] = None,
 ) -> Callable[[T], T]:
  ...
 
@@ -297,6 +311,7 @@ def input(
  name: Optional[str] = None,
  description: Optional[str] = None,
  directives: Optional[Sequence[object]] = (),
+ extension: Optional[TypeExtension] = None,
 ):
  """Annotates a class as a GraphQL Input type.
  Example usage:
@@ -311,6 +326,7 @@ def input(
  description=description,
  directives=directives,
  is_input=True,
+ extension=extension,
  )
 
 
@@ -324,6 +340,7 @@ def interface(
  name: Optional[str] = None,
  description: Optional[str] = None,
  directives: Optional[Sequence[object]] = (),
+ extension: Optional[TypeExtension] = None,
 ) -> T:
  ...
 
@@ -337,6 +354,7 @@ def interface(
  name: Optional[str] = None,
  description: Optional[str] = None,
  directives: Optional[Sequence[object]] = (),
+ extension: Optional[TypeExtension] = None,
 ) -> Callable[[T], T]:
  ...
 
@@ -350,6 +368,7 @@ def interface(
  name: Optional[str] = None,
  description: Optional[str] = None,
  directives: Optional[Sequence[object]] = (),
+ extension: Optional[TypeExtension] = None,
 ):
  """Annotates a class as a GraphQL Interface.
  Example usage:
@@ -364,6 +383,7 @@ def interface(
  description=description,
  directives=directives,
  is_interface=True,
+ extension=extension,
  )
 
 

strawberry/types/type_extension.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Sequence, Type
+
+from strawberry.types.types import StrawberryObjectDefinition
+
+if TYPE_CHECKING:
+ from dataclasses import Field
+
+ from graphql import GraphQLAbstractType, GraphQLResolveInfo
+
+ from strawberry.field import StrawberryField
+ from strawberry.type import WithStrawberryObjectDefinition
+
+
+class TypeExtension:
+ def before_wrap_dataclass(self, cls: Type) -> None:
+ pass
+
+ def on_field(self, field: Field | StrawberryField) -> Any:
+ return field
+
+ def create_object_definition(
+ self,
+ origin: Type[Any],
+ name: str,
+ is_input: bool,
+ is_interface: bool,
+ interfaces: List[StrawberryObjectDefinition],
+ description: Optional[str],
+ directives: Optional[Sequence[object]],
+ extend: bool,
+ fields: List[StrawberryField],
+ is_type_of: Optional[Callable[[Any, GraphQLResolveInfo], bool]],
+ resolve_type: Optional[
+ Callable[[Any, GraphQLResolveInfo, GraphQLAbstractType], str]
+ ],
+ ) -> StrawberryObjectDefinition:
+ """Posibility to use custom StrawberryObjectDefinition"""
+
+ return StrawberryObjectDefinition(
+ name=name,
+ is_input=is_input,
+ is_interface=is_interface,
+ interfaces=interfaces,
+ description=description,
+ directives=directives,
+ origin=origin,
+ extend=extend,
+ fields=fields,
+ is_type_of=is_type_of,
+ resolve_type=resolve_type,
+ )
+
+ def after_process(self, cls: Type[WithStrawberryObjectDefinition]) -> None:
+ pass

strawberry/types/type_resolver.py

@@ -2,7 +2,7 @@
 
 import dataclasses
 import sys
-from typing import Dict, List, Type
+from typing import TYPE_CHECKING, Dict, List, Optional, Type
 
 from strawberry.annotation import StrawberryAnnotation
 from strawberry.exceptions import (
@@ -15,8 +15,13 @@
 from strawberry.type import has_object_definition
 from strawberry.unset import UNSET
 
+if TYPE_CHECKING:
+ from strawberry.types.type_extension import TypeExtension
 
-def _get_fields(cls: Type) -> List[StrawberryField]:
+
+def _get_fields(
+ cls: Type, extension: Optional[TypeExtension] = None
+) -> List[StrawberryField]:
  """Get all the strawberry fields off a strawberry.type cls
 
  This function returns a list of StrawberryFields (one for each field item), while
@@ -74,8 +79,13 @@ class if one is not set by either using an explicit strawberry.field(name=...) o
  if field.python_name in base.__annotations__:
  origins.setdefault(field.name, base)
 
+ extension_hook = extension.on_field if extension else lambda field: field
+
  # then we can proceed with finding the fields for the current class
  for field in dataclasses.fields(cls): # type: ignore
+ # Extension field hook
+ field = extension_hook(field=field) # noqa: PLW2901 type: ignore
+
  if isinstance(field, StrawberryField):
  # Check that the field type is not Private
  if is_private(field.type):