graphql-api 1.6.4__tar.gz → 1.6.6__tar.gz

{graphql_api-1.6.4 → graphql_api-1.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphql-api
-Version: 1.6.4
+Version: 1.6.6
 Summary: A framework for building Python GraphQL APIs.
 Author-email: Robert Parker <rob@parob.com>
 License: MIT

graphql_api-1.6.6/VERSION

@@ -0,0 +1 @@
+1.6.6

{graphql_api-1.6.4 → graphql_api-1.6.6}/graphql_api/pydantic.py

@@ -7,7 +7,7 @@ from graphql import GraphQLField, GraphQLObjectType, GraphQLOutputType, GraphQLI
 from graphql.type.definition import is_output_type, is_input_type
 from pydantic import BaseModel
 
-from graphql_api.utils import to_camel_case
+from graphql_api.utils import to_camel_case, to_snake_case
 
 if typing.TYPE_CHECKING:
     from graphql_api.mapper import GraphQLTypeMapper
@@ -77,9 +77,31 @@ def type_from_pydantic_model(
                 )
             return fields
 
+        def _make_out_type(model_cls: Type[BaseModel]):
+            """Create an out_type that converts GraphQL input dicts to Pydantic models.
+
+            Mirrors the pattern in mapper.py's map_to_input for dataclass types.
+            """
+            def out_type(data):
+                # Convert camelCase GraphQL keys to snake_case Python keys
+                converted = {to_snake_case(key): value for key, value in data.items()}
+                # Strip None values so Pydantic uses its field defaults
+                # (graphql-core sets None for nullable fields not provided in input)
+                fields_with_defaults = {
+                    name for name, info in model_cls.model_fields.items()
+                    if info.default is not None or info.default_factory is not None
+                }
+                converted = {
+                    k: v for k, v in converted.items()
+                    if v is not None or k not in fields_with_defaults
+                }
+                return model_cls(**converted)
+            return out_type
+
         return GraphQLInputObjectType(
             name=f"{pydantic_model.__name__}Input",
             fields=get_input_fields,
+            out_type=_make_out_type(pydantic_model),
             description=_get_pydantic_model_description(
                 pydantic_model, mapper.max_docstring_length),
         )

{graphql_api-1.6.4 → graphql_api-1.6.6}/graphql_api/utils.py

@@ -20,6 +20,15 @@ from graphql.type.definition import GraphQLInterfaceType, GraphQLType
 
 # From this response in Stackoverflow
 # http://stackoverflow.com/a/19053800/1072990
+def _capitalize_first(s):
+    """Capitalize only the first character, preserving the rest.
+
+    Unlike str.title(), this doesn't capitalize letters after digits.
+    e.g. "30d" stays "30d" instead of becoming "30D".
+    """
+    return s[0].upper() + s[1:] if s else s
+
+
 def to_camel_case(snake_str, title=False):
     underscore_prefix = False
     if snake_str.startswith("_"):
@@ -27,12 +36,10 @@ def to_camel_case(snake_str, title=False):
         snake_str = snake_str[1:]
 
     components = snake_str.split("_")
-    # We capitalize the first letter of each component except the first one
-    # with the 'title' method and join them together.
     if not snake_str:
         return ""
-    prefix = components[0].title() if title else components[0]
-    value = prefix + "".join(x.title() if x else "_" for x in components[1:])
+    prefix = _capitalize_first(components[0]) if title else components[0]
+    value = prefix + "".join(_capitalize_first(x) if x else "_" for x in components[1:])
     return ("_" if underscore_prefix else "") + value
 
 

{graphql_api-1.6.4 → graphql_api-1.6.6}/graphql_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphql-api
-Version: 1.6.4
+Version: 1.6.6
 Summary: A framework for building Python GraphQL APIs.
 Author-email: Robert Parker <rob@parob.com>
 License: MIT

{graphql_api-1.6.4 → graphql_api-1.6.6}/tests/test_pydantic.py

@@ -1170,3 +1170,95 @@ class TestPydantic:
                 "tagCount": 0
             }
         }
+
+    def test_pydantic_input_with_variables_and_enum_defaults(self) -> None:
+        """Test that List[PydanticModel] with enum defaults works via GraphQL variables.
+
+        When using variables (as graphql-mcp does), graphql-core coerces input
+        objects via out_type. Without out_type, dicts pass through uncoerced.
+        With out_type, Pydantic models should be properly constructed with
+        defaults applied for omitted fields.
+        """
+        class Role(str, Enum):
+            USER = "user"
+            ADMIN = "admin"
+
+        class Message(BaseModel):
+            text: str
+            role: Role = Role.USER
+
+        class Result(BaseModel):
+            count: int
+            roles: List[str]
+
+        class VariableAPI:
+            @field(mutable=True)
+            def send(self, messages: List[Message]) -> Result:
+                """Send messages."""
+                roles = []
+                for msg in messages:
+                    assert isinstance(
+                        msg, Message), f"Expected Message, got {type(msg)}"
+                    roles.append(msg.role.value)
+                return Result(count=len(messages), roles=roles)
+
+        api = GraphQLAPI(root_type=VariableAPI)
+
+        # Test with variables (the path graphql-mcp uses)
+        mutation = """
+            mutation ($messages: [MessageInput!]!) {
+                send(messages: $messages) {
+                    count
+                    roles
+                }
+            }
+        """
+        # Omit 'role' — should default to "user"
+        variables = {
+            "messages": [
+                {"text": "hello"},
+                {"text": "world", "role": "ADMIN"},
+            ]
+        }
+        result = api.execute(mutation, variables=variables)
+        assert result.errors is None
+        assert result.data == {
+            "send": {
+                "count": 2,
+                "roles": ["user", "admin"]
+            }
+        }
+
+    def test_pydantic_input_out_type_converts_to_model(self) -> None:
+        """Test that Pydantic input types have out_type that produces model instances."""
+        class Item(BaseModel):
+            name: str
+            active: bool = True
+
+        class ItemResult(BaseModel):
+            is_model: bool
+
+        class OutTypeAPI:
+            @field(mutable=True)
+            def check_item(self, item: Item) -> ItemResult:
+                """Check if item is a Pydantic model instance."""
+                return ItemResult(is_model=isinstance(item, Item))
+
+        api = GraphQLAPI(root_type=OutTypeAPI)
+
+        # With inline args
+        result = api.execute("""
+            mutation {
+                checkItem(item: {name: "test"}) { isModel }
+            }
+        """)
+        assert result.errors is None
+        assert result.data["checkItem"]["isModel"] is True
+
+        # With variables
+        result = api.execute(
+            'mutation ($item: ItemInput!) { checkItem(item: $item) { isModel } }',
+            variables={"item": {"name": "test"}}
+        )
+        assert result.errors is None
+        assert result.data["checkItem"]["isModel"] is True

graphql_api-1.6.4/VERSION

@@ -1 +0,0 @@
-1.6.4