graphql-api 1.4.11__tar.gz → 1.4.13__tar.gz

{graphql_api-1.4.11/graphql_api.egg-info → graphql_api-1.4.13}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: graphql_api
-Version: 1.4.11
+Version: 1.4.13
 Summary: A framework for building Python GraphQL APIs.
 Home-page: https://gitlab.com/parob/graphql-api
-Download-URL: https://gitlab.com/parob/graphql/-/archive/v1.4.11/graphql_api-v1.4.11.tar.gz
+Download-URL: https://gitlab.com/parob/graphql/-/archive/v1.4.13/graphql_api-v1.4.13.tar.gz
 Author: Robert Parker
 Author-email: rob@parob.com
 License: MIT

graphql_api-1.4.13/VERSION

@@ -0,0 +1 @@
+1.4.13

{graphql_api-1.4.11 → graphql_api-1.4.13}/graphql_api/__init__.py

@@ -5,5 +5,5 @@ from graphql_api.api import GraphQLAPI, GraphQLRootTypeDelegate
 from graphql_api.decorators import field, type
 from graphql_api.error import GraphQLError
 from graphql_api.executor import GraphQLExecutor
-from graphql_api.reduce import GraphQLFilter, TagFilter
+from graphql_api.reduce import GraphQLFilter, TagFilter, FilterResponse
 from graphql_api.schema import AppliedDirective

{graphql_api-1.4.11 → graphql_api-1.4.13}/graphql_api/mapper.py

@@ -60,7 +60,6 @@ from graphql_api.utils import (
     has_single_type_union_return,
     to_camel_case,
     to_camel_case_text,
-    to_input_value,
     to_snake_case,
 )
 
@@ -406,11 +405,15 @@ class GraphQLTypeMapper:
 
         def serialize(_self, value) -> Union[str, None, UndefinedType]:
             if value and isinstance(value, collections.abc.Hashable):
+                # For both string and regular enums, we need to extract the .value attribute
                 if isinstance(value, enum.Enum):
-                    value = value.value
+                    lookup_key = value.value
+                else:
+                    # If it's not an enum instance, use the value directly
+                    lookup_key = value
 
                 # noinspection PyProtectedMember
-                lookup_value = _self._value_lookup.get(value)
+                lookup_value = _self._value_lookup.get(lookup_key)
                 if lookup_value:
                     return lookup_value
                 else:
@@ -566,16 +569,10 @@ class GraphQLTypeMapper:
                         # noinspection PyTypeChecker
                         input_arg_type = GraphQLNonNull(input_arg_type)  # type: ignore
 
+                    # Use the raw Python default for input coercion.
+                    # Do not convert to GraphQL query literals here.
                     default_value = local_default_args.get(key, None)
 
-                    if default_value is not None:
-                        try:
-                            default_value = to_input_value(default_value)
-                        except ValueError as _err:
-                            raise ValueError(
-                                f"Unable to map {local_name}.{key}, {_err}."
-                            )
-
                     arguments[to_camel_case(key)] = GraphQLInputField(
                         type_=input_arg_type, default_value=default_value  # type: ignore
                     )
@@ -751,12 +748,14 @@ class GraphQLTypeMapper:
                 if issubclass(type__, GraphQLType):
                     return type__()
 
-                if issubclass(type__, tuple(self.scalar_classes())):
-                    return self.map_to_scalar(type__)
-
+                # Check for enum.Enum before scalar types to handle string enums correctly
+                # String enums inherit from both str and Enum, so we need to check Enum first
                 if issubclass(type__, enum.Enum):
                     return self.map_to_enum(type__)
 
+                if issubclass(type__, tuple(self.scalar_classes())):
+                    return self.map_to_scalar(type__)
+
                 if is_interface(type__, self.schema):
                     return self.map_to_interface(type__)
 

{graphql_api-1.4.11 → graphql_api-1.4.13}/graphql_api/reduce.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List, Optional, Union
 from enum import Enum
 
 from graphql import GraphQLList, GraphQLNonNull, GraphQLObjectType
@@ -12,14 +12,15 @@ class FilterResponse(Enum):
     """
     Response from a GraphQL filter indicating how to handle a field and transitive types.
 
-    ALLOW - Keep the field, don't preserve transitive object types (should_filter=False, preserve_transitive=False)
-    ALLOW_TRANSITIVE - Keep the field and preserve transitive object types (should_filter=False, preserve_transitive=True)
-    REMOVE - Remove the field but preserve types referenced by unfiltered fields (should_filter=True, preserve_transitive=True)
-    REMOVE_STRICT - Remove the field and don't preserve unreferenced types (should_filter=True, preserve_transitive=False)
+    KEEP - Keep the field, don't preserve transitive object types
+    KEEP_TRANSITIVE - Keep the field and preserve transitive object types
+    REMOVE - Remove the field but preserve types referenced by unfiltered fields
+    REMOVE_STRICT - Always remove the field even if it is referenced by an unfiltered field that preserves transitive types.
+
     """
 
-    ALLOW = "allow"
-    ALLOW_TRANSITIVE = "allow_transitive"
+    KEEP = "keep"
+    KEEP_TRANSITIVE = "allow_transitive"
     REMOVE = "remove"
     REMOVE_STRICT = "remove_strict"
 
@@ -31,18 +32,32 @@ class FilterResponse(Enum):
     @property
     def preserve_transitive(self) -> bool:
         """True if types referenced by unfiltered fields should be preserved"""
-        return self in (FilterResponse.ALLOW_TRANSITIVE, FilterResponse.REMOVE)
+        return self in (FilterResponse.KEEP_TRANSITIVE, FilterResponse.REMOVE)
 
 
 class GraphQLFilter:
-    def filter_field(self, name, meta: dict) -> FilterResponse:
+
+    def filter_field(self, name: str, meta: dict) -> Union[bool, FilterResponse]:
         """
-        Return FilterResponse indicating how to handle the field
+        Return either FilterReponse or a bool value indicating how to handle the field.
+
+        There are two options for what is returned;
+
+        Basic usage:
+            True: This field should be removed.
+            False: This field should be kept.
+
+        Advanced usage:
+            FilterResponse.KEEP_TRANSITIVE: This field should be kept and any transitive types should be kept.
+            FilterResponse.KEEP: This field should be kept but any transitive types set to REMOVE or REMOVE_STRICT will be removed.
+            FilterResponse.REMOVE: This field should generally be removed, but will be kept if it is referenced by an unfiltered field that is set to KEEP_TRANSITIVE.
+            FilterResponse.REMOVE_STRICT: This field should always be removed, even if it is referenced by an unfiltered field that is set to KEEP_TRANSITIVE.
         """
         raise NotImplementedError()
 
 
 class TagFilter(GraphQLFilter):
+
     def __init__(
         self, tags: Optional[List[str]] = None, preserve_transitive: bool = True
     ):
@@ -62,9 +77,9 @@ class TagFilter(GraphQLFilter):
         if not should_filter:
             # Field is allowed - use ALLOW_TRANSITIVE only if preserve_transitive is enabled
             if self.preserve_transitive:
-                return FilterResponse.ALLOW_TRANSITIVE
+                return FilterResponse.KEEP_TRANSITIVE
             else:
-                return FilterResponse.ALLOW
+                return FilterResponse.KEEP
         elif self.preserve_transitive:
             # Field is filtered but preserve transitive dependencies
             return FilterResponse.REMOVE
@@ -448,8 +463,20 @@ class GraphQLSchemaReducer:
                             filter_response = field_filter.filter_field(
                                 field_name, field_meta
                             )
+
+                            # Handle backwards compatibility with boolean returns
+                            if isinstance(filter_response, bool):
+                                # Boolean True means filter the field (old API)
+                                # Convert to FilterResponse for consistent handling
+                                if filter_response:
+                                    # Field should be filtered - use REMOVE_STRICT as default
+                                    filter_response = FilterResponse.REMOVE_STRICT
+                                else:
+                                    # Field should be kept - use KEEP as default
+                                    filter_response = FilterResponse.KEEP
+
                             # If this field uses ALLOW_TRANSITIVE, preserve its referenced type
-                            if isinstance(filter_response, FilterResponse) and filter_response == FilterResponse.ALLOW_TRANSITIVE:
+                            if isinstance(filter_response, FilterResponse) and filter_response == FilterResponse.KEEP_TRANSITIVE:
                                 if isinstance(type_, (GraphQLInterfaceType, GraphQLObjectType)):
                                     allow_transitive_types.add(type_)
                             # If any filter response wants to preserve transitive,
@@ -559,7 +586,13 @@ class GraphQLSchemaReducer:
                         filter_response = field_filter.filter_field(
                             field_name, field_meta
                         )
-                        if isinstance(filter_response, FilterResponse) and filter_response.should_filter:
+
+                        # Handle backwards compatibility with boolean returns
+                        if isinstance(filter_response, bool):
+                            # Boolean True means filter the field (old API)
+                            if filter_response:
+                                invalid_fields.add((root_type, key))
+                        elif isinstance(filter_response, FilterResponse) and filter_response.should_filter:
                             invalid_fields.add((root_type, key))
 
                 if isinstance(type_, (GraphQLInterfaceType, GraphQLObjectType)):
@@ -667,7 +700,16 @@ class GraphQLSchemaReducer:
                             filter_response = field_filter.filter_field(
                                 field_name, field_meta
                             )
-                            if isinstance(filter_response, FilterResponse) and filter_response.should_filter:
+
+                            # Handle backwards compatibility with boolean returns
+                            should_filter_field = False
+                            if isinstance(filter_response, bool):
+                                # Boolean True means filter the field (old API)
+                                should_filter_field = filter_response
+                            elif isinstance(filter_response, FilterResponse):
+                                should_filter_field = filter_response.should_filter
+
+                            if should_filter_field:
                                 invalid_fields.add((current_type, key))
                                 field_is_filtered = True
                                 break

{graphql_api-1.4.11 → graphql_api-1.4.13}/graphql_api/types.py

@@ -4,7 +4,7 @@ import json
 import uuid
 import enum
 
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Dict, List, Optional, Type, Union, cast
 
 from graphql import (
     GraphQLEnumType,
@@ -24,8 +24,31 @@ class GraphQLMappedEnumType(GraphQLEnumType):
 
     def parse_literal(self, *args, **kwargs):
         result = super().parse_literal(*args, **kwargs)
-        if result and hasattr(self, "enum_type") and self.enum_type:
-            return self.enum_type(result)
+        if result is not Undefined and result is not None and getattr(self, "enum_type", None):
+            try:
+                enum_type: Optional[Type[enum.Enum]] = self.enum_type
+                if enum_type is None:
+                    return result
+                return cast(Type[enum.Enum], enum_type)(result)
+            except Exception:
+                return Undefined
+        return result
+
+    def parse_value(self, value):
+        """Coerce incoming variable values to the mapped Python Enum instance.
+
+        GraphQL variables use `parse_value`, while inline literals use
+        `parse_literal`. Ensure both paths produce the Python Enum.
+        """
+        result = super().parse_value(value)
+        if result is not Undefined and result is not None and getattr(self, "enum_type", None):
+            try:
+                enum_type: Optional[Type[enum.Enum]] = self.enum_type
+                if enum_type is None:
+                    return result
+                return cast(Type[enum.Enum], enum_type)(result)
+            except Exception:
+                return Undefined
         return result
 
 

{graphql_api-1.4.11 → graphql_api-1.4.13/graphql_api.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: graphql_api
-Version: 1.4.11
+Version: 1.4.13
 Summary: A framework for building Python GraphQL APIs.
 Home-page: https://gitlab.com/parob/graphql-api
-Download-URL: https://gitlab.com/parob/graphql/-/archive/v1.4.11/graphql_api-v1.4.11.tar.gz
+Download-URL: https://gitlab.com/parob/graphql/-/archive/v1.4.13/graphql_api-v1.4.13.tar.gz
 Author: Robert Parker
 Author-email: rob@parob.com
 License: MIT

{graphql_api-1.4.11 → graphql_api-1.4.13}/tests/test_dataclass.py

@@ -111,11 +111,11 @@ class TestDataclass:
                 if "admin" in tags:
                     if name == "get_stats":
                         # Use ALLOW_TRANSITIVE to preserve the Stats type
-                        return FilterResponse.ALLOW_TRANSITIVE
+                        return FilterResponse.KEEP_TRANSITIVE
                     else:
                         # Other admin fields should be removed
                         return FilterResponse.REMOVE_STRICT
-                return FilterResponse.ALLOW
+                return FilterResponse.KEEP
 
         # Build the API with the custom filter
         api = GraphQLAPI(root_type=Root, filters=[TestFilter()])

{graphql_api-1.4.11 → graphql_api-1.4.13}/tests/test_filtering.py

@@ -1,5 +1,6 @@
 from graphql_api.api import GraphQLAPI
 from graphql_api.mapper import GraphQLMetaKey
+from graphql_api.directives import print_schema
 
 
 class TestSchemaFiltering:
@@ -515,12 +516,12 @@ class TestSchemaFiltering:
         from graphql_api.reduce import FilterResponse
 
         # Test ALLOW - keep field, don't preserve transitive
-        assert not FilterResponse.ALLOW.should_filter
-        assert not FilterResponse.ALLOW.preserve_transitive
+        assert not FilterResponse.KEEP.should_filter
+        assert not FilterResponse.KEEP.preserve_transitive
 
         # Test ALLOW_TRANSITIVE - keep field, preserve transitive
-        assert not FilterResponse.ALLOW_TRANSITIVE.should_filter
-        assert FilterResponse.ALLOW_TRANSITIVE.preserve_transitive
+        assert not FilterResponse.KEEP_TRANSITIVE.should_filter
+        assert FilterResponse.KEEP_TRANSITIVE.preserve_transitive
 
         # Test REMOVE - remove field, preserve transitive
         assert FilterResponse.REMOVE.should_filter
@@ -545,10 +546,10 @@ class TestSchemaFiltering:
                 tags = meta.get("tags", [])
 
                 if "allow" in tags:
-                    return FilterResponse.ALLOW  # Keep field, don't preserve transitive
+                    return FilterResponse.KEEP  # Keep field, don't preserve transitive
                 elif "allow_transitive" in tags:
                     return (
-                        FilterResponse.ALLOW_TRANSITIVE
+                        FilterResponse.KEEP_TRANSITIVE
                     )  # Keep field, preserve transitive
                 elif "remove" in tags:
                     return FilterResponse.REMOVE  # Remove field, preserve transitive
@@ -557,7 +558,7 @@ class TestSchemaFiltering:
                         FilterResponse.REMOVE_STRICT
                     )  # Remove field, don't preserve transitive
                 else:
-                    return FilterResponse.ALLOW_TRANSITIVE  # Default behavior
+                    return FilterResponse.KEEP_TRANSITIVE  # Default behavior
 
         class ReferencedType:
             @field({"tags": ["allow"]})
@@ -673,7 +674,7 @@ class TestSchemaFiltering:
                 elif "admin" in tags:
                     return FilterResponse.REMOVE  # Remove with preservation
                 else:
-                    return FilterResponse.ALLOW_TRANSITIVE  # Keep with preservation
+                    return FilterResponse.KEEP_TRANSITIVE  # Keep with preservation
 
         class DataType:
             @field
@@ -975,11 +976,11 @@ class TestSchemaFiltering:
                 if "admin" in tags:
                     if name == "admin_user":
                         # Use ALLOW_TRANSITIVE to preserve the AdminUser type
-                        return FilterResponse.ALLOW_TRANSITIVE
+                        return FilterResponse.KEEP_TRANSITIVE
                     else:
                         # Other admin fields should be removed
                         return FilterResponse.REMOVE_STRICT
-                return FilterResponse.ALLOW
+                return FilterResponse.KEEP
 
         # Build the API with the custom filter
         api = GraphQLAPI(root_type=Root, filters=[TestFilter()])
@@ -1087,10 +1088,10 @@ class TestSchemaFiltering:
                 tags = meta.get("tags", [])
                 if "admin" in tags:
                     if name == "admin_user":
-                        return FilterResponse.ALLOW_TRANSITIVE
+                        return FilterResponse.KEEP_TRANSITIVE
                     else:
                         return FilterResponse.REMOVE_STRICT
-                return FilterResponse.ALLOW
+                return FilterResponse.KEEP
 
         api_strict = GraphQLAPI(root_type=Root, filters=[TestFilterStrict()])
         schema_strict, _ = api_strict.build_schema()
@@ -1101,10 +1102,10 @@ class TestSchemaFiltering:
                 tags = meta.get("tags", [])
                 if "admin" in tags:
                     if name == "admin_user":
-                        return FilterResponse.ALLOW_TRANSITIVE
+                        return FilterResponse.KEEP_TRANSITIVE
                     else:
                         return FilterResponse.REMOVE  # Use REMOVE instead of REMOVE_STRICT
-                return FilterResponse.ALLOW
+                return FilterResponse.KEEP
 
         api_remove = GraphQLAPI(root_type=Root, filters=[TestFilterRemove()])
         schema_remove, _ = api_remove.build_schema()
@@ -1198,7 +1199,7 @@ class TestSchemaFiltering:
 
                 if name == "secret_data" and "admin" in tags:
                     # Use ALLOW_TRANSITIVE to preserve SecretData type
-                    return FilterResponse.ALLOW_TRANSITIVE
+                    return FilterResponse.KEEP_TRANSITIVE
                 elif "secret" in tags or "classified" in tags:
                     # These fields should ALWAYS be removed, even if type is preserved
                     return FilterResponse.REMOVE_STRICT
@@ -1207,7 +1208,7 @@ class TestSchemaFiltering:
                     return FilterResponse.REMOVE
                 else:
                     # Allow all other fields
-                    return FilterResponse.ALLOW
+                    return FilterResponse.KEEP
 
         # Build the API with the test filter
         api = GraphQLAPI(root_type=Root, filters=[TestFilter()])
@@ -1524,11 +1525,11 @@ class TestSchemaFiltering:
         class Animal:
             @field
             def name(self) -> str:
-                pass
+                ...
 
             @field({"tags": ["vet"]})
             def medical_history(self) -> str:
-                pass
+                ...
 
         class Dog(Animal):
             def __init__(self):
@@ -1913,7 +1914,7 @@ class TestSchemaFiltering:
                         else FilterResponse.REMOVE_STRICT
                     )
                 else:
-                    return FilterResponse.ALLOW_TRANSITIVE
+                    return FilterResponse.KEEP_TRANSITIVE
 
         class Data:
             @field
@@ -2058,6 +2059,45 @@ class TestSchemaFiltering:
         assert result.errors
         # Should fail because updateName field is filtered out
 
+    def test_custom_public_filter(self):
+        """
+        Test that we can use a custom filter to keep public fields and remove non-public ones
+        """
+        from graphql_api.reduce import GraphQLFilter
+
+        class PublicFilter(GraphQLFilter):
+
+            def filter_field(self, name: str, meta: dict) -> bool:
+                # Return True to remove the field, False to keep it
+                # We want to keep public fields and remove non-public ones
+
+                is_public = meta.get("public")
+                should_filter = not is_public
+                if should_filter:
+                    print(f"Filtering field {name} with meta {meta}: {should_filter}")
+                else:
+                    print(f"Keeping field {name} with meta {meta}: {should_filter}")
+
+                return should_filter
+
+        api = GraphQLAPI(filters=[PublicFilter()])
+
+        @api.type(is_root_type=True)
+        class Root:
+
+            @api.field({"public": True})
+            def public_field(self) -> str:
+                return "public"
+
+            @api.field
+            def non_public_field(self) -> str:
+                return "non-public"
+
+        schema, _ = api.build_schema()
+        printed_schema = print_schema(schema)
+        assert "publicField" in printed_schema
+        assert "nonPublicField" not in printed_schema
+
     def test_recursive_object_type_preservation(self):
         """
         Test that object types on fields of unfiltered objects (recursive)
@@ -2195,7 +2235,7 @@ class TestSchemaFiltering:
                 elif self.return_type == "int":
                     return 42  # Should be FilterResponse
                 else:
-                    return FilterResponse.ALLOW  # Valid response
+                    return FilterResponse.KEEP  # Valid response
 
         api = GraphQLAPI()
 

{graphql_api-1.4.11 → graphql_api-1.4.13}/tests/test_graphql.py

@@ -900,6 +900,334 @@ class TestGraphQL:
 
         assert result.data == expected
 
+    def test_string_enum(self):
+        """Test string enum functionality"""
+        api = GraphQLAPI()
+
+        class Timeframe(str, enum.Enum):
+            """A timeframe."""
+            LAST_30_DAYS = "last_30_days"
+            ALL_TIME = "all_time"
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def get_timeframe(self) -> Timeframe:
+                return Timeframe.LAST_30_DAYS
+
+            @api.field
+            def echo_timeframe(self, timeframe: Timeframe) -> Timeframe:
+                return timeframe
+
+        executor = api.executor()
+
+        # Test return value
+        query1 = """
+            query {
+                getTimeframe
+            }
+        """
+        result1 = executor.execute(query1)
+        assert result1.data == {'getTimeframe': 'LAST_30_DAYS'}
+
+        # Test input argument
+        query2 = """
+            query {
+                echoTimeframe(timeframe: ALL_TIME)
+            }
+        """
+        result2 = executor.execute(query2)
+        assert result2.data == {'echoTimeframe': 'ALL_TIME'}
+
+    def test_string_enum_with_regular_enum(self):
+        """Test that both string enums and regular enums work together"""
+        api = GraphQLAPI()
+
+        class StringStatus(str, enum.Enum):
+            ACTIVE = "active"
+            INACTIVE = "inactive"
+
+        class RegularPriority(enum.Enum):
+            LOW = 1
+            MEDIUM = 2
+            HIGH = 3
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def get_status(self) -> StringStatus:
+                return StringStatus.ACTIVE
+
+            @api.field
+            def get_priority(self) -> RegularPriority:
+                return RegularPriority.HIGH
+
+            @api.field
+            def combine(self, status: StringStatus, priority: RegularPriority) -> str:
+                return f"{status.value}:{priority.value}"
+
+        executor = api.executor()
+
+        query = """
+            query {
+                getStatus
+                getPriority
+                combine(status: ACTIVE, priority: HIGH)
+            }
+        """
+
+        result = executor.execute(query)
+        assert result.data == {
+            'getStatus': 'ACTIVE',
+            'getPriority': 'HIGH',
+            'combine': 'active:3'
+        }
+
+    def test_string_enum_optional(self):
+        """Test optional string enum"""
+        api = GraphQLAPI()
+
+        class Color(str, enum.Enum):
+            RED = "red"
+            GREEN = "green"
+            BLUE = "blue"
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def get_color(self, color: Optional[Color] = None) -> str:
+                if color:
+                    return f"Color is {color.value}"
+                return "No color specified"
+
+        executor = api.executor()
+
+        # Test with value
+        query1 = """
+            query {
+                getColor(color: RED)
+            }
+        """
+        result1 = executor.execute(query1)
+        assert result1.data == {'getColor': 'Color is red'}
+
+        # Test without value
+        query2 = """
+            query {
+                getColor
+            }
+        """
+        result2 = executor.execute(query2)
+        assert result2.data == {'getColor': 'No color specified'}
+
+    def test_string_enum_list(self):
+        """Test list of string enums"""
+        api = GraphQLAPI()
+
+        class Tag(str, enum.Enum):
+            PYTHON = "python"
+            JAVASCRIPT = "javascript"
+            RUST = "rust"
+            GO = "go"
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def get_tags(self) -> List[Tag]:
+                return [Tag.PYTHON, Tag.RUST]
+
+            @api.field
+            def filter_tags(self, tags: List[Tag]) -> List[Tag]:
+                # Return only tags that start with 'P' or 'R'
+                return [t for t in tags if t.value[0] in ('p', 'r')]
+
+        executor = api.executor()
+
+        # Test returning list
+        query1 = """
+            query {
+                getTags
+            }
+        """
+        result1 = executor.execute(query1)
+        assert result1.data == {'getTags': ['PYTHON', 'RUST']}
+
+        # Test list as input
+        query2 = """
+            query {
+                filterTags(tags: [PYTHON, JAVASCRIPT, RUST, GO])
+            }
+        """
+        result2 = executor.execute(query2)
+        assert result2.data == {'filterTags': ['PYTHON', 'RUST']}
+
+    def test_string_enum_argument(self):
+        api = GraphQLAPI()
+
+        class Tag(str, enum.Enum):
+            PYTHON = "python"
+            JAVASCRIPT = "javascript"
+            RUST = "rust"
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def check_tag(self, tag: Tag) -> bool:
+                if isinstance(tag, Tag):
+                    return True
+                return False
+
+        executor = api.executor()
+
+        query = """
+            query CheckTag($tag: TagEnum!) {
+                checkTag(tag: $tag)
+            }
+            """
+        result = executor.execute(query, variables={'tag': Tag.PYTHON.name})
+        assert result.data == {'checkTag': True}
+
+    def test_string_enum_variable_rejects_value_literal(self):
+        api = GraphQLAPI()
+
+        class Tag(str, enum.Enum):
+            PYTHON = "python"
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def check(self, tag: Tag) -> bool:
+                return isinstance(tag, Tag)
+
+        executor = api.executor()
+        query = """
+            query($tag: TagEnum!){
+                check(tag: $tag)
+            }
+        """
+        # Variable must be the NAME ("PYTHON"), not the underlying value ("python")
+        result = executor.execute(query, variables={"tag": "python"})
+        assert result.errors and "does not exist in 'TagEnum'" in result.errors[0].message
+
+    def test_regular_enum_variable(self):
+        api = GraphQLAPI()
+
+        class Priority(enum.Enum):
+            LOW = 1
+            HIGH = 3
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def is_high(self, p: Priority) -> bool:
+                return p is Priority.HIGH
+
+        executor = api.executor()
+        q = "query($p: PriorityEnum!){ isHigh(p: $p) }"
+        result = executor.execute(q, variables={"p": "HIGH"})
+        assert result.data == {"isHigh": True}
+
+    def test_input_object_enum_default_and_override(self):
+        api = GraphQLAPI()
+
+        class Status(str, enum.Enum):
+            ACTIVE = "active"
+            INACTIVE = "inactive"
+
+        class Filter:
+            def __init__(self, status: Status = Status.ACTIVE):
+                self.status = status
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def get_status(self, flt: Filter) -> Status:
+                return flt.status
+
+        executor = api.executor()
+        # Uses default from InputObject field
+        r1 = executor.execute("query{ getStatus(flt: {}) }")
+        assert not r1.errors and r1.data == {"getStatus": "ACTIVE"}
+
+        # Override via variable with enum NAME
+        q = "query($s: StatusEnum!){ getStatus(flt: {status: $s}) }"
+        r2 = executor.execute(q, variables={"s": "INACTIVE"})
+        assert r2.data == {"getStatus": "INACTIVE"}
+
+    def test_string_enum_list_variable(self):
+        api = GraphQLAPI()
+
+        class Tag(str, enum.Enum):
+            PYTHON = "python"
+            RUST = "rust"
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def echo(self, tags: List[Tag]) -> List[Tag]:
+                assert all(isinstance(t, Tag) for t in tags)
+                return tags
+
+        executor = api.executor()
+        q = "query($tags: [TagEnum!]!){ echo(tags: $tags) }"
+        r = executor.execute(q, variables={"tags": ["PYTHON", "RUST"]})
+        assert r.data == {"echo": ["PYTHON", "RUST"]}
+
+    def test_optional_enum_undefined_vs_null(self):
+        api = GraphQLAPI()
+
+        class Color(str, enum.Enum):
+            RED = "red"
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def show(self, color: Optional[Color] = None) -> str:
+                return "none" if color is None else color.value
+
+        executor = api.executor()
+        q = "query($c: ColorEnum){ show(color: $c) }"
+        # Undefined variable
+        r1 = executor.execute(q, variables={})
+        assert r1.data == {"show": "none"}
+        # Explicit null
+        r2 = executor.execute(q, variables={"c": None})
+        assert r2.data == {"show": "none"}
+
+    def test_returning_underlying_value_maps_to_enum_name(self):
+        api = GraphQLAPI()
+
+        class Color(str, enum.Enum):
+            RED = "red"
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def color(self) -> Color:  # type: ignore[override]
+                # Returning the underlying value should still serialize to NAME
+                return "red"  # type: ignore[return-value]
+
+        executor = api.executor()
+        r = executor.execute("query{ color }")
+        assert r.data == {"color": "RED"}
+
+    def test_enum_variable_mixed_case_invalid(self):
+        api = GraphQLAPI()
+
+        class Tag(str, enum.Enum):
+            PYTHON = "python"
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def ok(self, tag: Tag) -> bool:
+                return True
+
+        executor = api.executor()
+        q = "query($t: TagEnum!){ ok(tag: $t) }"
+        res = executor.execute(q, variables={"t": "Python"})
+        assert res.errors and "does not exist in 'TagEnum'" in res.errors[0].message
+
     # noinspection PyUnusedLocal
     def test_literal(self):
         api = GraphQLAPI()

{graphql_api-1.4.11 → graphql_api-1.4.13}/tests/test_schema.py

@@ -10,44 +10,44 @@ class TestGraphQLSchema:
         class ObjectNoSchema:
             @field
             def test_query_no_schema(self, a: int) -> int:
-                pass
+                ...
 
             @field(mutable=True)
             def test_mutation_no_schema(self, a: int) -> int:
-                pass
+                ...
 
         @type(abstract=True)
         class AbstractNoSchema:
             @field
             def test_abstract_query_no_schema(self, a: int) -> int:
-                pass
+                ...
 
             @field(mutable=True)
             def test_abstract_mutation_no_schema(self, a: int) -> int:
-                pass
+                ...
 
         @type(interface=True)
         class InterfaceNoSchema:
             @field
             def test_interface_query_no_schema(self, a: int) -> int:
-                pass
+                ...
 
             @field(mutable=True)
             def test_interface_mutation_no_schema(self, a: int) -> int:
-                pass
+                ...
 
         # noinspection PyUnresolvedReferences
-        assert ObjectNoSchema._graphql
+        assert ObjectNoSchema._graphql  # type: ignore[reportAttributeAccess]
         assert ObjectNoSchema.test_query_no_schema._graphql
         assert ObjectNoSchema.test_mutation_no_schema._graphql
 
         # noinspection PyUnresolvedReferences
-        assert AbstractNoSchema._graphql
+        assert AbstractNoSchema._graphql  # type: ignore[reportAttributeAccess]
         assert AbstractNoSchema.test_abstract_query_no_schema._graphql
         assert AbstractNoSchema.test_abstract_mutation_no_schema._graphql
 
         # noinspection PyUnresolvedReferences
-        assert InterfaceNoSchema._graphql
+        assert InterfaceNoSchema._graphql  # type: ignore[reportAttributeAccess]
         assert InterfaceNoSchema.test_interface_query_no_schema._graphql
         assert InterfaceNoSchema.test_interface_mutation_no_schema._graphql
 
@@ -58,14 +58,14 @@ class TestGraphQLSchema:
         class ObjectSchema:
             @api_1.field
             def test_query_schema(self, a: int) -> int:
-                pass
+                ...
 
             @api_1.field(mutable=True)
             def test_mutation_schema(self, a: int) -> int:
-                pass
+                ...
 
         # noinspection PyUnresolvedReferences
-        assert ObjectSchema._graphql
+        assert ObjectSchema._graphql  # type: ignore[reportAttributeAccess]
         assert ObjectSchema.test_query_schema._graphql
         assert ObjectSchema.test_mutation_schema._graphql
 
@@ -74,14 +74,14 @@ class TestGraphQLSchema:
         class ObjectNoSchemaMeta:
             @field(meta={"test": "test"})
             def test_query_no_schema_meta(self, a: int) -> int:
-                pass
+                ...
 
             @field(meta={"test": "test"}, mutable=True)
             def test_mutation_no_schema_meta(self, a: int) -> int:
-                pass
+                ...
 
         # noinspection PyUnresolvedReferences
-        assert ObjectNoSchemaMeta._graphql
+        assert ObjectNoSchemaMeta._graphql  # type: ignore[reportAttributeAccess]
         assert ObjectNoSchemaMeta.test_query_no_schema_meta._graphql
         assert ObjectNoSchemaMeta.test_mutation_no_schema_meta._graphql
 
@@ -92,20 +92,21 @@ class TestGraphQLSchema:
         class ObjectSchemaMeta:
             @api_1.field(meta={"test3": "test4"})
             def test_query_schema_meta(self, a: int) -> int:
-                pass
+                ...
 
             @api_1.field(meta={"test5": "test6"}, mutable=True)
             def test_mutation_schema_meta(self, a: int) -> int:
-                pass
+                ...
 
         # noinspection PyUnresolvedReferences
-        assert ObjectSchemaMeta._graphql
+        assert ObjectSchemaMeta._graphql  # type: ignore[reportAttributeAccess]
         assert ObjectSchemaMeta.test_query_schema_meta._graphql
         assert ObjectSchemaMeta.test_mutation_schema_meta._graphql
 
-        schema = api_1.build_schema()
+        schema, _ = api_1.build_schema()
 
-        assert schema
+        assert schema is not None
+        assert schema.query_type is not None
 
     def test_schema_with_no_root_type(self):
         """
@@ -115,7 +116,8 @@ class TestGraphQLSchema:
         api = GraphQLAPI()
         schema, _ = api.build_schema()
 
-        assert schema
+        assert schema is not None
+        assert schema.query_type is not None
         assert schema.query_type.name == "PlaceholderQuery"
         assert "placeholder" in schema.query_type.fields
         assert schema.mutation_type is None

graphql_api-1.4.11/VERSION

@@ -1 +0,0 @@
-1.4.11