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

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

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

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

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

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

@@ -31,8 +31,10 @@ from graphql import (
     GraphQLInputObjectType,
     GraphQLInterfaceType,
     GraphQLList,
+    GraphQLNamedType,
     GraphQLNonNull,
     GraphQLObjectType,
+    GraphQLType,
     GraphQLUnionType,
     Undefined,
     ValueNode,
@@ -429,7 +431,7 @@ class GraphQLCoreConverter:
     ) -> GraphQLInterfaceType:
         interface_name = self.config.name_converter.from_type(interface)
 
-        # Don't reevaluate known types
+        # Don't re-evaluate known types
         cached_type = self.type_map.get(interface_name, None)
         if cached_type:
             self.validate_same_type_definition(interface_name, interface, cached_type)
@@ -450,7 +452,32 @@ class GraphQLCoreConverter:
                     # TODO: we should find the correct type here from the
                     # generic
                     if not type_definition.is_graphql_generic:
-                        return obj.__strawberry_definition__.name
+                        return type_definition.name
+
+                    # here we don't all the implementations of the generic
+                    # we need to find a way to find them, for now maybe
+                    # we can follow the union's approach and iterate over
+                    # all the types in the schema, but we should probably
+                    # optimize this
+
+                    return_type: Optional[GraphQLType] = None
+
+                    for possible_concrete_type in self.type_map.values():
+                        possible_type = possible_concrete_type.definition
+
+                        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
                 # of the interface is not returned (i.e. an ORM object)
@@ -794,7 +821,7 @@ class GraphQLCoreConverter:
             if not StrawberryUnion.is_valid_union_type(type_):
                 raise InvalidUnionTypeError(union_name, type_, union_definition=union)
 
-        # Don't reevaluate known types
+        # Don't re-evaluate known types
         if union_name in self.type_map:
             graphql_union = self.type_map[union_name].implementation
             assert isinstance(graphql_union, GraphQLUnionType)  # For mypy

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

@@ -17,6 +17,7 @@ from typing import (
 from typing_extensions import Self, deprecated
 
 from strawberry.type import (
+    StrawberryList,
     StrawberryType,
     StrawberryTypeVar,
     WithStrawberryObjectDefinition,
@@ -169,21 +170,43 @@ class StrawberryObjectDefinition(StrawberryType):
             return False
 
         # Check the mapping of all fields' TypeVars
-        for generic_field in type_definition.fields:
-            generic_field_type = generic_field.type
-            if not isinstance(generic_field_type, StrawberryTypeVar):
+        for field in type_definition.fields:
+            if not field.is_graphql_generic:
+                continue
+
+            value = getattr(root, field.name)
+            generic_field_type = field.type
+
+            while isinstance(generic_field_type, StrawberryList):
+                generic_field_type = generic_field_type.of_type
+
+                assert isinstance(value, (list, tuple))
+
+                if len(value) == 0:
+                    # We can't infer the type of an empty list, so we just
+                    # return the first one we find
+                    return True
+
+                value = value[0]
+
+            if isinstance(generic_field_type, StrawberryTypeVar):
+                type_var = generic_field_type.type_var
+            # TODO: I don't think we support nested types properly
+            # if there's a union that has two nested types that
+            # are have the same field with different types, we might
+            # not be able to differentiate them
+            else:
                 continue
 
             # For each TypeVar found, get the expected type from the copy's type map
-            expected_concrete_type = self.type_var_map.get(
-                generic_field_type.type_var.__name__
-            )
+            expected_concrete_type = self.type_var_map.get(type_var.__name__)
+
+            # this shouldn't happen, but we do a defensive check just in case
             if expected_concrete_type is None:
-                # TODO: Should this return False?
                 continue
 
             # Check if the expected type matches the type found on the type_map
-            real_concrete_type = type(getattr(root, generic_field.name))
+            real_concrete_type = type(value)
 
             # TODO: uniform type var map, at the moment we map object types
             # to their class (not to TypeDefinition) while we map enum to

{strawberry_graphql-0.228.0 → strawberry_graphql-0.229.0}/strawberry/union.py

@@ -194,7 +194,6 @@ class StrawberryUnion(StrawberryType):
             # Union in case a nested generic object matches against more than one type.
             concrete_types_for_union = (type_map[x.name] for x in type_.types)
 
-            # TODO: do we still need to iterate over all types in `type_map`?
             for possible_concrete_type in chain(
                 concrete_types_for_union, type_map.values()
             ):
@@ -213,13 +212,9 @@ class StrawberryUnion(StrawberryType):
                     info.field_name, str(type(root)), set(type_.types)
                 )
 
-            # Return the name of the type. Returning the actual type is now deprecated
-            if isinstance(return_type, GraphQLNamedType):
-                # TODO: Can return_type ever _not_ be a GraphQLNamedType?
-                return return_type.name
-            else:
-                # TODO: check if this is correct
-                return return_type.__name__  # type: ignore
+            assert isinstance(return_type, GraphQLNamedType)
+
+            return return_type.name
 
         return _resolve_union_type