strawberry-graphql 0.232.2__tar.gz → 0.233.1__tar.gz

{strawberry_graphql-0.232.2 → strawberry_graphql-0.233.1}/PKG-INFO

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

{strawberry_graphql-0.232.2 → strawberry_graphql-0.233.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.232.2"
+version = "0.233.1"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"

{strawberry_graphql-0.232.2 → strawberry_graphql-0.233.1}/strawberry/federation/schema.py

@@ -1,5 +1,4 @@
 from collections import defaultdict
-from copy import copy
 from functools import cached_property, partial
 from itertools import chain
 from typing import (
@@ -10,6 +9,7 @@ from typing import (
     Iterable,
     List,
     Mapping,
+    NewType,
     Optional,
     Set,
     Type,
@@ -17,36 +17,36 @@ from typing import (
     cast,
 )
 
-from graphql import (
-    GraphQLError,
-    GraphQLField,
-    GraphQLInterfaceType,
-    GraphQLList,
-    GraphQLNonNull,
-    GraphQLScalarType,
-    GraphQLUnionType,
-)
-from graphql.type.definition import GraphQLArgument
+from graphql import GraphQLError
 
+from strawberry.annotation import StrawberryAnnotation
+from strawberry.custom_scalar import scalar
 from strawberry.printer import print_schema
 from strawberry.schema import Schema as BaseSchema
+from strawberry.type import (
+    StrawberryContainer,
+    WithStrawberryObjectDefinition,
+    get_object_definition,
+)
+from strawberry.types.info import Info
 from strawberry.types.types import StrawberryObjectDefinition
+from strawberry.union import StrawberryUnion
 from strawberry.utils.inspect import get_func_args
 
 from .schema_directive import StrawberryFederationSchemaDirective
 
 if TYPE_CHECKING:
     from graphql import ExecutionContext as GraphQLExecutionContext
-    from graphql import GraphQLObjectType
 
     from strawberry.custom_scalar import ScalarDefinition, ScalarWrapper
     from strawberry.enum import EnumDefinition
     from strawberry.extensions import SchemaExtension
     from strawberry.federation.schema_directives import ComposeDirective
     from strawberry.schema.config import StrawberryConfig
-    from strawberry.schema.types.concrete_type import TypeMap
     from strawberry.schema_directive import StrawberrySchemaDirective
-    from strawberry.union import StrawberryUnion
+
+
+FederationAny = scalar(NewType("_Any", object), name="_Any")  # type: ignore
 
 
 class Schema(BaseSchema):
@@ -67,7 +67,8 @@ class Schema(BaseSchema):
         schema_directives: Iterable[object] = (),
         enable_federation_2: bool = False,
     ) -> None:
-        query = self._get_federation_query_type(query)
+        query = self._get_federation_query_type(query, mutation, subscription, types)
+        types = [*types, FederationAny]
 
         super().__init__(
             query=query,
@@ -84,16 +85,19 @@ class Schema(BaseSchema):
 
         self.schema_directives = list(schema_directives)
 
-        self._add_scalars()
-        self._add_entities_to_query()
-
         if enable_federation_2:
             composed_directives = self._add_compose_directives()
             self._add_link_directives(composed_directives)  # type: ignore
         else:
             self._remove_resolvable_field()
 
-    def _get_federation_query_type(self, query: Optional[Type]) -> Type:
+    def _get_federation_query_type(
+        self,
+        query: Optional[Type[WithStrawberryObjectDefinition]],
+        mutation: Optional[Type[WithStrawberryObjectDefinition]],
+        subscription: Optional[Type[WithStrawberryObjectDefinition]],
+        additional_types: Iterable[Type[WithStrawberryObjectDefinition]],
+    ) -> Type:
         """Returns a new query type that includes the _service field.
 
         If the query type is provided, it will be used as the base for the new
@@ -109,13 +113,6 @@ class Schema(BaseSchema):
         added if the schema contains an entity type.
         """
 
-        # note we don't add the _entities field here, as we need to know if the
-        # schema contains an entity type first and we do that by leveraging
-        # the schema converter type map, so we don't have to do that twice
-        # TODO: ideally we should be able to do this without using the schema
-        # converter, but for now this is the easiest way to do it
-        # see `_add_entities_to_query`
-
         import strawberry
         from strawberry.tools.create_type import create_type
         from strawberry.tools.merge_types import merge_types
@@ -132,6 +129,19 @@ class Schema(BaseSchema):
 
         fields = [service]
 
+        entity_type = _get_entity_type(query, mutation, subscription, additional_types)
+
+        if entity_type:
+            self.entities_resolver.__annotations__["return"] = List[
+                Optional[entity_type]  # type: ignore
+            ]
+
+            entities_field = strawberry.field(
+                name="_entities", resolver=self.entities_resolver
+            )
+
+            fields.insert(0, entities_field)
+
         FederationQuery = create_type(name="Query", fields=fields)
 
         if query is None:
@@ -139,10 +149,7 @@ class Schema(BaseSchema):
 
         query_type = merge_types(
             "Query",
-            (
-                FederationQuery,
-                query,
-            ),
+            (FederationQuery, query),
         )
 
         # TODO: this should be probably done in merge_types
@@ -151,31 +158,9 @@ class Schema(BaseSchema):
 
         return query_type
 
-    def _add_entities_to_query(self) -> None:
-        entity_type = _get_entity_type(self.schema_converter.type_map)
-
-        if not entity_type:
-            return
-
-        self._schema.type_map[entity_type.name] = entity_type
-        fields = {"_entities": self._get_entities_field(entity_type)}
-
-        # Copy the query type, update it to use the modified fields
-        query_type = cast("GraphQLObjectType", self._schema.query_type)
-        fields.update(query_type.fields)
-
-        query_type = copy(query_type)
-        query_type.fields = fields
-
-        self._schema.query_type = query_type
-        self._schema.type_map[query_type.name] = query_type
-
     def entities_resolver(
-        self,
-        root,  # noqa: ANN001
-        info,  # noqa: ANN001
-        representations,  # noqa: ANN001
-    ) -> List[object]:
+        self, info: Info, representations: List[FederationAny]
+    ) -> List[FederationAny]:
         results = []
 
         for representation in representations:
@@ -198,9 +183,8 @@ class Schema(BaseSchema):
             else:
                 from strawberry.arguments import convert_argument
 
-                strawberry_schema = info.schema.extensions["strawberry-definition"]
-                config = strawberry_schema.config
-                scalar_registry = strawberry_schema.schema_converter.scalar_registry
+                config = info.schema.config
+                scalar_registry = info.schema.schema_converter.scalar_registry
 
                 get_result = partial(
                     convert_argument,
@@ -222,11 +206,6 @@ class Schema(BaseSchema):
 
         return results
 
-    def _add_scalars(self) -> None:
-        self.Any = GraphQLScalarType("_Any")
-
-        self._schema.type_map["_Any"] = self.Any
-
     def _remove_resolvable_field(self) -> None:
         # this might be removed when we remove support for federation 1
         # or when we improve how we print the directives
@@ -335,17 +314,6 @@ class Schema(BaseSchema):
 
         return compose_directives
 
-    def _get_entities_field(self, entity_type: GraphQLUnionType) -> GraphQLField:
-        return GraphQLField(
-            GraphQLNonNull(GraphQLList(entity_type)),
-            args={
-                "representations": GraphQLArgument(
-                    GraphQLNonNull(GraphQLList(GraphQLNonNull(self.Any)))
-                )
-            },
-            resolve=self.entities_resolver,
-        )
-
     def _warn_for_federation_directives(self) -> None:
         # this is used in the main schema to raise if there's a directive
         # that's for federation, but in this class we don't want to warn,
@@ -354,33 +322,56 @@ class Schema(BaseSchema):
         pass
 
 
-def _get_entity_type(type_map: "TypeMap") -> Optional[GraphQLUnionType]:
-    # https://www.apollographql.com/docs/apollo-server/federation/federation-spec/#resolve-requests-for-entities
+def _get_entity_type(
+    query: Optional[Type[WithStrawberryObjectDefinition]],
+    mutation: Optional[Type[WithStrawberryObjectDefinition]],
+    subscription: Optional[Type[WithStrawberryObjectDefinition]],
+    additional_types: Iterable[Type[WithStrawberryObjectDefinition]],
+) -> Optional[StrawberryUnion]:
+    # recursively iterate over the schema to find all types annotated with @key
+    # if no types are annotated with @key, then the _Entity union and Query._entities
+    # field should not be added to the schema
 
-    # To implement the _Entity union, each type annotated with @key
-    # should be added to the _Entity union.
+    entity_types = set()
 
-    federation_key_types = [
-        type.implementation
-        for type in type_map.values()
-        if _has_federation_keys(type.definition)
-        # TODO: check this
-        and not isinstance(type.implementation, GraphQLInterfaceType)
-    ]
+    # need a stack to keep track of the types we need to visit
+    stack: List[Any] = [query, mutation, subscription, *additional_types]
 
-    # If no types are annotated with the key directive, then the _Entity
-    # union and Query._entities field should be removed from the schema.
-    if not federation_key_types:
-        return None
+    seen = set()
+
+    while stack:
+        type_ = stack.pop()
 
-    entity_type = GraphQLUnionType("_Entity", federation_key_types)  # type: ignore
+        if type_ is None:
+            continue
 
-    def _resolve_type(self: Any, value: Any, info: Any) -> str:
-        return self.__strawberry_definition__.name
+        while isinstance(type_, StrawberryContainer):
+            type_ = type_.of_type
+
+        type_definition = get_object_definition(type_, strict=False)
+
+        if type_definition is None:
+            continue
+
+        if type_definition.is_object_type and _has_federation_keys(type_definition):
+            entity_types.add(type_)
+
+        for field in type_definition.fields:
+            if field.type and field.type in seen:
+                continue
+
+            seen.add(field.type)
+            stack.append(field.type)
+
+    if not entity_types:
+        return None
 
-    entity_type.resolve_type = _resolve_type
+    sorted_types = sorted(entity_types, key=lambda t: t.__strawberry_definition__.name)
 
-    return entity_type
+    return StrawberryUnion(
+        "_Entity",
+        type_annotations=tuple(StrawberryAnnotation(type_) for type_ in sorted_types),
+    )
 
 
 def _is_key(directive: Any) -> bool:

{strawberry_graphql-0.232.2 → strawberry_graphql-0.233.1}/strawberry/schema/schema_converter.py

@@ -178,6 +178,61 @@ class CustomGraphQLEnumType(GraphQLEnumType):
         return self.wrapped_cls(super().parse_literal(value_node, _variables))
 
 
+def get_arguments(
+    *,
+    field: StrawberryField,
+    source: Any,
+    info: Info,
+    kwargs: Any,
+    config: StrawberryConfig,
+    scalar_registry: Dict[object, Union[ScalarWrapper, ScalarDefinition]],
+) -> Tuple[List[Any], Dict[str, Any]]:
+    # TODO: An extension might have changed the resolver arguments,
+    # but we need them here since we are calling it.
+    # This is a bit of a hack, but it's the easiest way to get the arguments
+    # This happens in mutation.InputMutationExtension
+    field_arguments = field.arguments[:]
+    if field.base_resolver:
+        existing = {arg.python_name for arg in field_arguments}
+        field_arguments.extend(
+            [
+                arg
+                for arg in field.base_resolver.arguments
+                if arg.python_name not in existing
+            ]
+        )
+
+    kwargs = convert_arguments(
+        kwargs,
+        field_arguments,
+        scalar_registry=scalar_registry,
+        config=config,
+    )
+
+    # the following code allows to omit info and root arguments
+    # by inspecting the original resolver arguments,
+    # if it asks for self, the source will be passed as first argument
+    # if it asks for root or parent, the source will be passed as kwarg
+    # if it asks for info, the info will be passed as kwarg
+
+    args = []
+
+    if field.base_resolver:
+        if field.base_resolver.self_parameter:
+            args.append(source)
+
+        if parent_parameter := field.base_resolver.parent_parameter:
+            kwargs[parent_parameter.name] = source
+
+        if root_parameter := field.base_resolver.root_parameter:
+            kwargs[root_parameter.name] = source
+
+        if info_parameter := field.base_resolver.info_parameter:
+            kwargs[info_parameter.name] = info
+
+    return args, kwargs
+
+
 class GraphQLCoreConverter:
     # TODO: Make abstract
 
@@ -608,56 +663,6 @@ class GraphQLCoreConverter:
 
             return _get_basic_result
 
-        def _get_arguments(
-            source: Any,
-            info: Info,
-            kwargs: Any,
-        ) -> Tuple[List[Any], Dict[str, Any]]:
-            # TODO: An extension might have changed the resolver arguments,
-            # but we need them here since we are calling it.
-            # This is a bit of a hack, but it's the easiest way to get the arguments
-            # This happens in mutation.InputMutationExtension
-            field_arguments = field.arguments[:]
-            if field.base_resolver:
-                existing = {arg.python_name for arg in field_arguments}
-                field_arguments.extend(
-                    [
-                        arg
-                        for arg in field.base_resolver.arguments
-                        if arg.python_name not in existing
-                    ]
-                )
-
-            kwargs = convert_arguments(
-                kwargs,
-                field_arguments,
-                scalar_registry=self.scalar_registry,
-                config=self.config,
-            )
-
-            # the following code allows to omit info and root arguments
-            # by inspecting the original resolver arguments,
-            # if it asks for self, the source will be passed as first argument
-            # if it asks for root or parent, the source will be passed as kwarg
-            # if it asks for info, the info will be passed as kwarg
-
-            args = []
-
-            if field.base_resolver:
-                if field.base_resolver.self_parameter:
-                    args.append(source)
-
-                if parent_parameter := field.base_resolver.parent_parameter:
-                    kwargs[parent_parameter.name] = source
-
-                if root_parameter := field.base_resolver.root_parameter:
-                    kwargs[root_parameter.name] = source
-
-                if info_parameter := field.base_resolver.info_parameter:
-                    kwargs[info_parameter.name] = info
-
-            return args, kwargs
-
         def _strawberry_info_from_graphql(info: GraphQLResolveInfo) -> Info:
             return Info(
                 _raw_info=info,
@@ -689,8 +694,13 @@ class GraphQLCoreConverter:
             ) -> Any:
                 # parse field arguments into Strawberry input types and convert
                 # field names to Python equivalents
-                field_args, field_kwargs = _get_arguments(
-                    source=_source, info=info, kwargs=kwargs
+                field_args, field_kwargs = get_arguments(
+                    field=field,
+                    source=_source,
+                    info=info,
+                    kwargs=kwargs,
+                    config=self.config,
+                    scalar_registry=self.scalar_registry,
                 )
 
                 resolver_requested_info = False

{strawberry_graphql-0.232.2 → strawberry_graphql-0.233.1}/strawberry/types/types.py

@@ -146,6 +146,10 @@ class StrawberryObjectDefinition(StrawberryType):
     def specialized_type_var_map(self) -> Optional[Dict[str, type]]:
         return get_specialized_type_var_map(self.origin)
 
+    @property
+    def is_object_type(self) -> bool:
+        return not self.is_input and not self.is_interface
+
     @property
     def type_params(self) -> List[TypeVar]:
         type_params: List[TypeVar] = []