strawberry-graphql 0.228.0.dev1713643365__tar.gz → 0.229.0__tar.gz

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.228.0.dev1713643365
+Version: 0.229.0
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.228.0.dev.1713643365"
+version = "0.229.0"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"
@@ -173,6 +173,8 @@ asyncio_mode = "auto"
 filterwarnings = [
     "ignore::DeprecationWarning:strawberry.*.resolver",
     "ignore:LazyType is deprecated:DeprecationWarning",
+    "ignore::DeprecationWarning:ddtrace.internal",
+    "ignore::DeprecationWarning:django.utils.encoding",
     # ignoring the text instead of the whole warning because we'd
     # get an error when django is not installed
     "ignore:The default value of USE_TZ",

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/experimental/pydantic/error_type.py

@@ -114,7 +114,7 @@ def error_type(
         ]
 
         wrapped = _wrap_dataclass(cls)
-        extra_fields = cast(List[dataclasses.Field], _get_fields(wrapped))
+        extra_fields = cast(List[dataclasses.Field], _get_fields(wrapped, {}))
         private_fields = get_private_fields(wrapped)
 
         all_model_fields.extend(

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/experimental/pydantic/object_type.py

@@ -177,7 +177,7 @@ def type(
         )
 
         wrapped = _wrap_dataclass(cls)
-        extra_strawberry_fields = _get_fields(wrapped)
+        extra_strawberry_fields = _get_fields(wrapped, {})
         extra_fields = cast(List[dataclasses.Field], extra_strawberry_fields)
         private_fields = get_private_fields(wrapped)
 

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/extensions/tracing/datadog.py

@@ -27,7 +27,8 @@ class DatadogTracingExtension(SchemaExtension):
 
     @cached_property
     def _resource_name(self) -> str:
-        assert self.execution_context.query
+        if self.execution_context.query is None:
+            return "query_missing"
 
         query_hash = self.hash_query(self.execution_context.query)
 
@@ -78,15 +79,23 @@ class DatadogTracingExtension(SchemaExtension):
         )
         self.request_span.set_tag("graphql.operation_name", self._operation_name)
 
-        assert self.execution_context.query
+        query = self.execution_context.query
+
+        if query is not None:
+            query = query.strip()
+            operation_type = "query"
+
+            if query.startswith("mutation"):
+                operation_type = "mutation"
+            elif query.startswith("subscription"):  # pragma: no cover
+                operation_type = "subscription"
+        else:
+            operation_type = "query_missing"
 
-        operation_type = "query"
-        if self.execution_context.query.strip().startswith("mutation"):
-            operation_type = "mutation"
-        elif self.execution_context.query.strip().startswith("subscription"):
-            operation_type = "subscription"
         self.request_span.set_tag("graphql.operation_type", operation_type)
+
         yield
+
         self.request_span.finish()
 
     def on_validate(self) -> Generator[None, None, None]:

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/federation/schema_directive.py

@@ -39,7 +39,7 @@ def schema_directive(
 ) -> Callable[..., T]:
     def _wrap(cls: T) -> T:
         cls = _wrap_dataclass(cls)
-        fields = _get_fields(cls)
+        fields = _get_fields(cls, {})
 
         cls.__strawberry_directive__ = StrawberryFederationSchemaDirective(
             python_name=cls.__name__,

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/object_type.py

@@ -67,7 +67,8 @@ def _check_field_annotations(cls: Type[Any]):
             # If the field has a type override then use that instead of using
             # the class annotations or resolver annotation
             if field_.type_annotation is not None:
-                cls_annotations[field_name] = field_.type_annotation.annotation
+                if field_name not in cls_annotations:
+                    cls_annotations[field_name] = field_.type_annotation.annotation
                 continue
 
             # Make sure the cls has an annotation
@@ -85,7 +86,8 @@ def _check_field_annotations(cls: Type[Any]):
                         field_name, resolver=field_.base_resolver
                     )
 
-                cls_annotations[field_name] = field_.base_resolver.type_annotation
+                if field_name not in cls_annotations:
+                    cls_annotations[field_name] = field_.base_resolver.type_annotation
 
             # TODO: Make sure the cls annotation agrees with the field's type
             # >>> if cls_annotations[field_name] != field.base_resolver.type:
@@ -133,11 +135,13 @@ def _process_type(
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
     extend: bool = False,
+    original_type_annotations: Optional[Dict[str, Any]] = None,
 ) -> T:
     name = name or to_camel_case(cls.__name__)
+    original_type_annotations = original_type_annotations or {}
 
     interfaces = _get_interfaces(cls)
-    fields = _get_fields(cls)
+    fields = _get_fields(cls, original_type_annotations)
     is_type_of = getattr(cls, "is_type_of", None)
     resolve_type = getattr(cls, "resolve_type", None)
 
@@ -245,7 +249,25 @@ def type(
                 exc = ObjectIsNotClassError.type
             raise exc(cls)
 
+        # when running `_wrap_dataclass` we lose some of the information about the
+        # the passed types, especially the type_annotation inside the StrawberryField
+        # this makes it impossible to customise the field type, like this:
+        # >>> @strawberry.type
+        # >>> class Query:
+        # >>>     a: int = strawberry.field(graphql_type=str)
+        # so we need to extract the information before running `_wrap_dataclass`
+        original_type_annotations: Dict[str, Any] = {}
+
+        annotations = getattr(cls, "__annotations__", {})
+
+        for field_name in annotations:
+            field = getattr(cls, field_name, None)
+
+            if field and isinstance(field, StrawberryField) and field.type_annotation:
+                original_type_annotations[field_name] = field.type_annotation.annotation
+
         wrapped = _wrap_dataclass(cls)
+
         return _process_type(
             wrapped,
             name=name,
@@ -254,6 +276,7 @@ def type(
             description=description,
             directives=directives,
             extend=extend,
+            original_type_annotations=original_type_annotations,
         )
 
     if cls is None:

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/relay/types.py

@@ -38,7 +38,7 @@ from strawberry.utils.aio import aenumerate, aislice, resolve_awaitable
 from strawberry.utils.inspect import in_async_context
 from strawberry.utils.typing import eval_type, is_classvar
 
-from .utils import from_base64, to_base64
+from .utils import from_base64, should_resolve_list_connection_edges, to_base64
 
 if TYPE_CHECKING:
     from strawberry.scalars import ID
@@ -933,6 +933,17 @@ class ListConnection(Connection[NodeType]):
                 overfetch,
             )
 
+        if not should_resolve_list_connection_edges(info):
+            return cls(
+                edges=[],
+                page_info=PageInfo(
+                    start_cursor=None,
+                    end_cursor=None,
+                    has_previous_page=False,
+                    has_next_page=False,
+                ),
+            )
+
         edges = [
             edge_class.resolve_edge(
                 cls.resolve_node(v, info=info, **kwargs),

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/relay/utils.py

@@ -2,6 +2,8 @@ import base64
 from typing import Any, Tuple, Union
 from typing_extensions import assert_never
 
+from strawberry.types.info import Info
+from strawberry.types.nodes import InlineFragment, Selection
 from strawberry.types.types import StrawberryObjectDefinition
 
 
@@ -41,7 +43,7 @@ def to_base64(type_: Union[str, type, StrawberryObjectDefinition], node_id: Any)
             The node id itself
 
     Returns:
-        A tuple of (TypeName, NodeID).
+        A GlobalID, which is a string resulting from base64 encoding <TypeName>:<NodeID>.
 
     Raises:
         ValueError:
@@ -61,3 +63,42 @@ def to_base64(type_: Union[str, type, StrawberryObjectDefinition], node_id: Any)
         raise ValueError(f"{type_} is not a valid GraphQL type or name") from e
 
     return base64.b64encode(f"{type_name}:{node_id}".encode()).decode()
+
+
+def should_resolve_list_connection_edges(info: Info) -> bool:
+    """Check if the user requested to resolve the `edges` field of a connection.
+
+    Args:
+        info:
+            The strawberry execution info resolve the type name from
+
+    Returns:
+        True if the user requested to resolve the `edges` field of a connection, False otherwise.
+
+    """
+    resolve_for_field_names = {"edges", "pageInfo"}
+
+    def _check_selection(selection: Selection) -> bool:
+        """Recursively inspect the selection to check if the user requested to resolve the `edges` field.
+        Args:
+            selection (Selection): The selection to check.
+
+        Returns:
+            bool: True if the user requested to resolve the `edges` field of a connection, False otherwise.
+        """
+        if (
+            not isinstance(selection, InlineFragment)
+            and selection.name in resolve_for_field_names
+        ):
+            return True
+        if selection.selections:
+            return any(
+                _check_selection(selection) for selection in selection.selections
+            )
+        return False
+
+    for selection_field in info.selected_fields:
+        for selection in selection_field.selections:
+            if _check_selection(selection):
+                return True
+    return False

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/scalars.py

@@ -16,10 +16,10 @@ JSON = scalar(
     description=(
         "The `JSON` scalar type represents JSON values as specified by "
         "[ECMA-404]"
-        "(http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf)."
+        "(https://ecma-international.org/wp-content/uploads/ECMA-404_2nd_edition_december_2017.pdf)."
     ),
     specified_by_url=(
-        "http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf"
+        "https://ecma-international.org/wp-content/uploads/ECMA-404_2nd_edition_december_2017.pdf"
     ),
     serialize=lambda v: v,
     parse_value=lambda v: v,

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/schema/schema_converter.py

@@ -31,6 +31,7 @@ from graphql import (
     GraphQLInputObjectType,
     GraphQLInterfaceType,
     GraphQLList,
+    GraphQLNamedType,
     GraphQLNonNull,
     GraphQLObjectType,
     GraphQLType,
@@ -464,13 +465,18 @@ class GraphQLCoreConverter:
                     for possible_concrete_type in self.type_map.values():
                         possible_type = possible_concrete_type.definition
 
-                        if not isinstance(possible_type, StrawberryObjectDefinition):
+                        if not isinstance(
+                            possible_type, StrawberryObjectDefinition
+                        ):  # pragma: no cover
                             continue
+
                         if possible_type.is_implemented_by(obj):
                             return_type = possible_concrete_type.implementation
                             break
 
                     if return_type:
+                        assert isinstance(return_type, GraphQLNamedType)
+
                         return return_type.name
 
                 # Revert to calling is_type_of for cases where a direct subclass

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/schema_directive.py

@@ -54,7 +54,7 @@ def schema_directive(
 ) -> Callable[..., T]:
     def _wrap(cls: T) -> T:
         cls = _wrap_dataclass(cls)
-        fields = _get_fields(cls)
+        fields = _get_fields(cls, {})
 
         cls.__strawberry_directive__ = StrawberrySchemaDirective(
             python_name=cls.__name__,

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/starlite/controller.py

@@ -6,6 +6,7 @@ import warnings
 from dataclasses import dataclass
 from datetime import timedelta
 from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Tuple, Union, cast
+from typing_extensions import deprecated
 
 from starlite import (
     BackgroundTasks,
@@ -118,6 +119,10 @@ class GraphQLTransportWSHandler(BaseGraphQLTransportWSHandler):
         return await self._get_root_value()
 
 
+@deprecated(
+    "The `starlite` integration is deprecated in favor of `litestar` integration",
+    stacklevel=2,
+)
 class StarliteRequestAdapter(AsyncHTTPRequestAdapter):
     def __init__(self, request: Request[Any, Any]) -> None:
         self.request = request
@@ -153,6 +158,10 @@ class BaseContext:
         self.response: Optional[Response] = None
 
 
+@deprecated(
+    "The `starlite` integration is deprecated in favor of `litestar` integration",
+    stacklevel=2,
+)
 def make_graphql_controller(
     schema: BaseSchema,
     path: str = "",

{strawberry_graphql-0.228.0.dev1713643365 → strawberry_graphql-0.229.0}/strawberry/types/type_resolver.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 import sys
-from typing import Dict, List, Type
+from typing import Any, Dict, List, Type
 
 from strawberry.annotation import StrawberryAnnotation
 from strawberry.exceptions import (
@@ -16,7 +16,9 @@ from strawberry.type import has_object_definition
 from strawberry.unset import UNSET
 
 
-def _get_fields(cls: Type) -> List[StrawberryField]:
+def _get_fields(
+    cls: Type[Any], original_type_annotations: Dict[str, Type[Any]]
+) -> 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
@@ -49,6 +51,7 @@ def _get_fields(cls: Type) -> List[StrawberryField]:
     passing a named function (i.e. not an anonymous lambda) to strawberry.field
     (typically as a decorator).
     """
+
     fields: Dict[str, StrawberryField] = {}
 
     # before trying to find any fields, let's first add the fields defined in
@@ -152,6 +155,10 @@ def _get_fields(cls: Type) -> List[StrawberryField]:
         assert_message = "Field must have a name by the time the schema is generated"
         assert field_name is not None, assert_message
 
+        if field.name in original_type_annotations:
+            field.type = original_type_annotations[field.name]
+            field.type_annotation = StrawberryAnnotation(annotation=field.type)
+
         # TODO: Raise exception if field_name already in fields
         fields[field_name] = field