strawberry-graphql 0.190.0.dev1687447182__py3-none-any.whl → 0.192.1__py3-none-any.whl

strawberry/exceptions/utils/source_finder.py

@@ -100,7 +100,7 @@ class LibCSTSourceFinder:
         return None
 
     def _find_function_definition(
-        self, source: SourcePath, function: Callable
+        self, source: SourcePath, function: Callable[..., Any]
     ) -> Optional[FunctionDef]:
         import libcst.matchers as m
 
@@ -114,7 +114,7 @@ class LibCSTSourceFinder:
         )
 
     def _find_class_definition(
-        self, source: SourcePath, cls: Type
+        self, source: SourcePath, cls: Type[Any]
     ) -> Optional[CSTNode]:
         import libcst.matchers as m
 
@@ -123,7 +123,7 @@ class LibCSTSourceFinder:
         class_defs = self._find(source.code, matcher)
         return self._find_definition_by_qualname(cls.__qualname__, class_defs)
 
-    def find_class(self, cls: Type) -> Optional[ExceptionSource]:
+    def find_class(self, cls: Type[Any]) -> Optional[ExceptionSource]:
         source = self.find_source(cls.__module__)
 
         if source is None:
@@ -148,7 +148,7 @@ class LibCSTSourceFinder:
         )
 
     def find_class_attribute(
-        self, cls: Type, attribute_name: str
+        self, cls: Type[Any], attribute_name: str
     ) -> Optional[ExceptionSource]:
         source = self.find_source(cls.__module__)
 
@@ -190,7 +190,7 @@ class LibCSTSourceFinder:
             error_column_end=attribute_position.end.column,
         )
 
-    def find_function(self, function: Callable) -> Optional[ExceptionSource]:
+    def find_function(self, function: Callable[..., Any]) -> Optional[ExceptionSource]:
         source = self.find_source(function.__module__)
 
         if source is None:
@@ -223,7 +223,7 @@ class LibCSTSourceFinder:
         )
 
     def find_argument(
-        self, function: Callable, argument_name: str
+        self, function: Callable[..., Any], argument_name: str
     ) -> Optional[ExceptionSource]:
         source = self.find_source(function.__module__)
 
@@ -372,6 +372,134 @@ class LibCSTSourceFinder:
             error_column_end=invalid_type_node_position.end.column,
         )
 
+    def find_annotated_union(
+        self, union_definition: StrawberryUnion, invalid_type: object
+    ) -> Optional[ExceptionSource]:
+        if union_definition._source_file is None:
+            return None
+
+        # find things like Annotated[Union[...], strawberry.union(name="aaa")]
+
+        import libcst.matchers as m
+
+        path = Path(union_definition._source_file)
+        source = path.read_text()
+
+        matcher = m.Subscript(
+            value=m.Name(value="Annotated"),
+            slice=(
+                m.SubscriptElement(
+                    slice=m.Index(
+                        value=m.Subscript(
+                            value=m.Name(value="Union"),
+                        )
+                    )
+                ),
+                m.SubscriptElement(
+                    slice=m.Index(
+                        value=m.Call(
+                            func=m.Attribute(
+                                value=m.Name(value="strawberry"),
+                                attr=m.Name(value="union"),
+                            ),
+                            args=[
+                                m.Arg(
+                                    value=m.SimpleString(
+                                        value=f"'{union_definition.graphql_name}'"
+                                    )
+                                    | m.SimpleString(
+                                        value=f'"{union_definition.graphql_name}"'
+                                    )
+                                )
+                            ],
+                        )
+                    )
+                ),
+            ),
+        )
+
+        annotated_calls = self._find(source, matcher)
+        invalid_type_name = getattr(invalid_type, "__name__", None)
+
+        if hasattr(invalid_type, "_scalar_definition"):
+            invalid_type_name = invalid_type._scalar_definition.name
+
+        if annotated_calls:
+            annotated_call_node = annotated_calls[0]
+
+            if invalid_type_name:
+                invalid_type_nodes = m.findall(
+                    annotated_call_node,
+                    m.SubscriptElement(slice=m.Index(m.Name(invalid_type_name))),
+                )
+
+                if not invalid_type_nodes:
+                    return None  # pragma: no cover
+
+                invalid_type_node = invalid_type_nodes[0]
+            else:
+                invalid_type_node = annotated_call_node
+        else:
+            matcher = m.Subscript(
+                value=m.Name(value="Annotated"),
+                slice=(
+                    m.SubscriptElement(slice=m.Index(value=m.BinaryOperation())),
+                    m.SubscriptElement(
+                        slice=m.Index(
+                            value=m.Call(
+                                func=m.Attribute(
+                                    value=m.Name(value="strawberry"),
+                                    attr=m.Name(value="union"),
+                                ),
+                                args=[
+                                    m.Arg(
+                                        value=m.SimpleString(
+                                            value=f"'{union_definition.graphql_name}'"
+                                        )
+                                        | m.SimpleString(
+                                            value=f'"{union_definition.graphql_name}"'
+                                        )
+                                    )
+                                ],
+                            )
+                        )
+                    ),
+                ),
+            )
+
+            annotated_calls = self._find(source, matcher)
+
+            if not annotated_calls:
+                return None
+
+            annotated_call_node = annotated_calls[0]
+
+            if invalid_type_name:
+                invalid_type_nodes = m.findall(
+                    annotated_call_node,
+                    m.BinaryOperation(left=m.Name(invalid_type_name)),
+                )
+
+                if not invalid_type_nodes:
+                    return None  # pragma: no cover
+
+                invalid_type_node = invalid_type_nodes[0].left  # type: ignore
+            else:
+                invalid_type_node = annotated_call_node
+
+        position = self._position_metadata[annotated_call_node]
+        invalid_type_node_position = self._position_metadata[invalid_type_node]
+
+        return ExceptionSource(
+            path=path,
+            code=source,
+            start_line=position.start.line,
+            end_line=position.end.line,
+            error_line=invalid_type_node_position.start.line,
+            error_column=invalid_type_node_position.start.column,
+            error_column_end=invalid_type_node_position.end.column,
+        )
+
     def find_scalar_call(
         self, scalar_definition: ScalarDefinition
     ) -> Optional[ExceptionSource]:
@@ -426,7 +554,6 @@ class LibCSTSourceFinder:
 
 
 class SourceFinder:
-    # TODO: this might need to become a getter
     @cached_property
     def cst(self) -> Optional[LibCSTSourceFinder]:
         try:
@@ -434,21 +561,21 @@ class SourceFinder:
         except ImportError:
             return None  # pragma: no cover
 
-    def find_class_from_object(self, cls: Type) -> Optional[ExceptionSource]:
+    def find_class_from_object(self, cls: Type[Any]) -> Optional[ExceptionSource]:
         return self.cst.find_class(cls) if self.cst else None
 
     def find_class_attribute_from_object(
-        self, cls: Type, attribute_name: str
+        self, cls: Type[Any], attribute_name: str
     ) -> Optional[ExceptionSource]:
         return self.cst.find_class_attribute(cls, attribute_name) if self.cst else None
 
     def find_function_from_object(
-        self, function: Callable
+        self, function: Callable[..., Any]
     ) -> Optional[ExceptionSource]:
         return self.cst.find_function(function) if self.cst else None
 
     def find_argument_from_object(
-        self, function: Callable, argument_name: str
+        self, function: Callable[..., Any], argument_name: str
     ) -> Optional[ExceptionSource]:
         return self.cst.find_argument(function, argument_name) if self.cst else None
 
@@ -470,3 +597,12 @@ class SourceFinder:
         self, scalar_definition: ScalarDefinition
     ) -> Optional[ExceptionSource]:
         return self.cst.find_scalar_call(scalar_definition) if self.cst else None
+
+    def find_annotated_union(
+        self, union_definition: StrawberryUnion, invalid_type: object
+    ) -> Optional[ExceptionSource]:
+        return (
+            self.cst.find_annotated_union(union_definition, invalid_type)
+            if self.cst
+            else None
+        )

strawberry/extensions/field_extension.py

@@ -6,14 +6,11 @@ from typing import TYPE_CHECKING, Any, Awaitable, Callable, Union
 from strawberry.utils.cached_property import cached_property
 
 if TYPE_CHECKING:
-    from typing_extensions import TypeAlias
-
     from strawberry.field import StrawberryField
     from strawberry.types import Info
 
-
-SyncExtensionResolver: TypeAlias = Callable[..., Any]
-AsyncExtensionResolver: TypeAlias = Callable[..., Awaitable[Any]]
+SyncExtensionResolver = Callable[..., Any]
+AsyncExtensionResolver = Callable[..., Awaitable[Any]]
 
 
 class FieldExtension:

strawberry/fastapi/router.py

@@ -188,10 +188,12 @@ class GraphQLRouter(
                     "description": "The GraphiQL integrated development environment.",
                 },
                 404: {
-                    "description": "Not found if GraphiQL is not enabled.",
+                    "description": (
+                        "Not found if GraphiQL or query via GET are not enabled."
+                    )
                 },
             },
-            include_in_schema=graphiql,
+            include_in_schema=graphiql or allow_queries_via_get,
         )
         async def handle_http_get(  # pyright: ignore
             request: Request,
@@ -277,8 +279,7 @@ class GraphQLRouter(
         )
 
     def render_graphiql(self, request: Request) -> HTMLResponse:
-        html = get_graphiql_html()
-        return HTMLResponse(html)
+        return HTMLResponse(get_graphiql_html())
 
     @staticmethod
     def _merge_responses(response: Response, actual_response: Response) -> Response:

strawberry/federation/union.py

@@ -1,19 +1,18 @@
-from typing import Iterable, Optional, Tuple, Type, TypeVar, Union
+from typing import Any, Collection, Iterable, Optional, Type
 
+from strawberry.union import StrawberryUnion
 from strawberry.union import union as base_union
 
-Types = TypeVar("Types", bound=Type)
-
 
 def union(
     name: str,
-    types: Tuple[Types, ...],
+    types: Optional[Collection[Type[Any]]] = None,
     *,
     description: Optional[str] = None,
     directives: Iterable[object] = (),
     inaccessible: bool = False,
     tags: Optional[Iterable[str]] = (),
-) -> Union[Types]:
+) -> StrawberryUnion:
     """Creates a new named Union type.
 
     Example usages:

strawberry/field.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+import contextlib
+import copy
 import dataclasses
+import inspect
 import sys
 from typing import (
     TYPE_CHECKING,
@@ -15,6 +18,7 @@ from typing import (
     Type,
     TypeVar,
     Union,
+    cast,
     overload,
 )
 
@@ -37,6 +41,7 @@ if TYPE_CHECKING:
     from strawberry.arguments import StrawberryArgument
     from strawberry.extensions.field_extension import FieldExtension
     from strawberry.types.info import Info
+    from strawberry.types.types import StrawberryObjectDefinition
 
     from .permission import BasePermission
 
@@ -138,21 +143,34 @@ class StrawberryField(dataclasses.Field):
         self.directives = list(directives)
         self.extensions: List[FieldExtension] = list(extensions)
 
-        # Automatically add the permissions extension
-        if len(self.permission_classes):
-            from .permission import PermissionExtension
-
-            if not self.extensions:
-                self.extensions = []
-            permission_instances = [
-                permission_class() for permission_class in permission_classes
-            ]
-            # Append to make it run first (last is outermost)
-            self.extensions.append(
-                PermissionExtension(permission_instances, use_directives=False)
-            )
         self.deprecation_reason = deprecation_reason
 
+    def __copy__(self) -> Self:
+        new_field = type(self)(
+            python_name=self.python_name,
+            graphql_name=self.graphql_name,
+            type_annotation=self.type_annotation,
+            origin=self.origin,
+            is_subscription=self.is_subscription,
+            description=self.description,
+            base_resolver=self.base_resolver,
+            permission_classes=(
+                self.permission_classes[:]
+                if self.permission_classes is not None
+                else []
+            ),
+            default=self.default_value,
+            default_factory=self.default_factory,
+            metadata=self.metadata.copy() if self.metadata is not None else None,
+            deprecation_reason=self.deprecation_reason,
+            directives=self.directives[:] if self.directives is not None else [],
+            extensions=self.extensions[:] if self.extensions is not None else [],
+        )
+        new_field._arguments = (
+            self._arguments[:] if self._arguments is not None else None
+        )
+        return new_field
+
     def __call__(self, resolver: _RESOLVER_TYPE) -> Self:
         """Add a resolver to the field"""
 
@@ -202,7 +220,11 @@ class StrawberryField(dataclasses.Field):
         an `Info` object and running any permission checks in the resolver
         which improves performance.
         """
-        return not self.base_resolver and not self.extensions
+        return (
+            not self.base_resolver
+            and not self.permission_classes
+            and not self.extensions
+        )
 
     @property
     def arguments(self) -> List[StrawberryArgument]:
@@ -261,35 +283,7 @@ class StrawberryField(dataclasses.Field):
         Type[WithStrawberryObjectDefinition],
         Literal[UNRESOLVED],
     ]:
-        # We are catching NameError because dataclasses tries to fetch the type
-        # of the field from the class before the class is fully defined.
-        # This triggers a NameError error when using forward references because
-        # our `type` property tries to find the field type from the global namespace
-        # but it is not yet defined.
-        try:
-            # Prioritise the field type over the resolver return type
-            if self.type_annotation is not None:
-                return self.type_annotation.resolve()
-
-            if self.base_resolver is not None:
-                # Handle unannotated functions (such as lambdas)
-                if self.base_resolver.type is not None:
-                    # Generics will raise MissingTypesForGenericError later
-                    # on if we let it be returned. So use `type_annotation` instead
-                    # which is the same behaviour as having no type information.
-                    if not _is_generic(self.base_resolver.type):
-                        return self.base_resolver.type
-
-            # If we get this far it means that we don't have a field type and
-            # the resolver doesn't have a return type so all we can do is return
-            # UNRESOLVED here.
-            # This case will raise a MissingReturnAnnotationError exception in the
-            # _check_field_annotations function:
-            # https://github.com/strawberry-graphql/strawberry/blob/846f060a63cb568b3cdc0deb26c308a8d0718190/strawberry/object_type.py#L76-L80
-            return UNRESOLVED
-
-        except NameError:
-            return UNRESOLVED
+        return self.resolve_type()
 
     @type.setter
     def type(self, type_: Any) -> None:
@@ -315,54 +309,101 @@ class StrawberryField(dataclasses.Field):
             return self.type.type_params
         return []
 
+    def resolve_type(
+        self,
+        *,
+        type_definition: Optional[StrawberryObjectDefinition] = None,
+    ) -> Union[  # type: ignore [valid-type]
+        StrawberryType,
+        Type[WithStrawberryObjectDefinition],
+        Literal[UNRESOLVED],
+    ]:
+        # We return UNRESOLVED by default, which means this case will raise a
+        # MissingReturnAnnotationError exception in _check_field_annotations
+        resolved = UNRESOLVED
+
+        # We are catching NameError because dataclasses tries to fetch the type
+        # of the field from the class before the class is fully defined.
+        # This triggers a NameError error when using forward references because
+        # our `type` property tries to find the field type from the global namespace
+        # but it is not yet defined.
+        with contextlib.suppress(NameError):
+            # Prioritise the field type over the resolver return type
+            if self.type_annotation is not None:
+                resolved = self.type_annotation.resolve()
+            elif self.base_resolver is not None and self.base_resolver.type is not None:
+                # Handle unannotated functions (such as lambdas)
+                # Generics will raise MissingTypesForGenericError later
+                # on if we let it be returned. So use `type_annotation` instead
+                # which is the same behaviour as having no type information.
+                resolved = self.base_resolver.type
+
+        # If this is a generic field, try to resolve it using its origin's
+        # specialized type_var_map
+        if _is_generic(resolved):  # type: ignore
+            specialized_type_var_map = (
+                type_definition and type_definition.specialized_type_var_map
+            )
+            if specialized_type_var_map and isinstance(resolved, StrawberryType):
+                resolved = resolved.copy_with(specialized_type_var_map)
+
+            # If the field is still generic, try to resolve it from the type_definition
+            # that is asking for it.
+            if (
+                _is_generic(cast(Union[StrawberryType, type], resolved))
+                and type_definition is not None
+                and type_definition.type_var_map
+                and isinstance(resolved, StrawberryType)
+            ):
+                resolved = resolved.copy_with(type_definition.type_var_map)
+
+        return resolved
+
     def copy_with(
         self, type_var_map: Mapping[TypeVar, Union[StrawberryType, builtins.type]]
     ) -> Self:
-        new_type: Union[StrawberryType, type] = self.type
+        new_field = copy.copy(self)
 
-        if has_object_definition(self.type):
-            type_definition = self.type.__strawberry_definition__
+        override_type: Optional[
+            Union[StrawberryType, Type[WithStrawberryObjectDefinition]]
+        ] = None
+        type_ = self.resolve_type()
+        if has_object_definition(type_):
+            type_definition = type_.__strawberry_definition__
 
             if type_definition.is_generic:
                 type_ = type_definition
-                new_type = type_.copy_with(type_var_map)
-        elif isinstance(self.type, StrawberryType):
-            new_type = self.type.copy_with(type_var_map)
-
-        new_resolver = (
-            self.base_resolver.copy_with(type_var_map)
-            if self.base_resolver is not None
-            else None
-        )
+                override_type = type_.copy_with(type_var_map)
+        elif isinstance(type_, StrawberryType):
+            override_type = type_.copy_with(type_var_map)
+
+        if override_type is not None:
+            new_field.type_annotation = StrawberryAnnotation(
+                override_type,
+                namespace=(
+                    self.type_annotation.namespace if self.type_annotation else None
+                ),
+            )
+
+        if self.base_resolver is not None:
+            new_field.base_resolver = self.base_resolver.copy_with(type_var_map)
 
-        new_field = type(self)(
-            python_name=self.python_name,
-            graphql_name=self.graphql_name,
-            # TODO: do we need to wrap this in `StrawberryAnnotation`?
-            # see comment related to dataclasses above
-            type_annotation=StrawberryAnnotation(new_type),
-            origin=self.origin,
-            is_subscription=self.is_subscription,
-            description=self.description,
-            base_resolver=new_resolver,
-            permission_classes=self.permission_classes and self.permission_classes[:],
-            default=self.default_value,
-            # ignored because of https://github.com/python/mypy/issues/6910
-            default_factory=self.default_factory,
-            deprecation_reason=self.deprecation_reason,
-            directives=self.directives and self.directives[:],
-            extensions=self.extensions and self.extensions[:],
-        )
-        new_field._arguments = self._arguments and self._arguments[:]
         return new_field
 
+    @property
+    def _has_async_permission_classes(self) -> bool:
+        for permission_class in self.permission_classes:
+            if inspect.iscoroutinefunction(permission_class.has_permission):
+                return True
+        return False
+
     @property
     def _has_async_base_resolver(self) -> bool:
         return self.base_resolver is not None and self.base_resolver.is_async
 
     @cached_property
     def is_async(self) -> bool:
-        return self._has_async_base_resolver
+        return self._has_async_permission_classes or self._has_async_base_resolver
 
 
 @overload

strawberry/http/__init__.py

@@ -5,8 +5,6 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional
 from typing_extensions import TypedDict
 
-from graphql.error.graphql_error import format_error as format_graphql_error
-
 if TYPE_CHECKING:
     from strawberry.types import ExecutionResult
 
@@ -21,7 +19,7 @@ def process_result(result: ExecutionResult) -> GraphQLHTTPResponse:
     data: GraphQLHTTPResponse = {"data": result.data}
 
     if result.errors:
-        data["errors"] = [format_graphql_error(err) for err in result.errors]
+        data["errors"] = [err.formatted for err in result.errors]
     if result.extensions:
         data["extensions"] = result.extensions