Merge pull request #29 from excessdenied/master

Added support for InputObjectTypes.

Author: necaris

README.md

@@ -15,13 +15,13 @@ pip install "graphene-pydantic"
 Here is a simple Pydantic model:
 
 ```python
+import uuid
 import pydantic
 
 class PersonModel(pydantic.BaseModel):
     id: uuid.UUID
     first_name: str
     last_name: str
-
 ```
 
 To create a GraphQL schema for it you simply have to write the following:
@@ -33,32 +33,81 @@ from graphene_pydantic import PydanticObjectType
 class Person(PydanticObjectType):
     class Meta:
         model = PersonModel
-        # only return specified fields
-        only_fields = ("name",)
         # exclude specified fields
         exclude_fields = ("id",)
 
 class Query(graphene.ObjectType):
     people = graphene.List(Person)
 
-    def resolve_people(self, info):
-        return get_people()  # function returning `PersonModel`s
+    @staticmethod
+    def resolve_people(parent, info):
+        # fetch actual PersonModels here
+        return [PersonModel(id=uuid.uuid4(), first_name="Beth", last_name="Smith")]
 
 schema = graphene.Schema(query=Query)
 ```
 
 Then you can simply query the schema:
 
 ```python
-query = '''
+query = """
     query {
       people {
         firstName,
         lastName
       }
     }
-'''
+"""
 result = schema.execute(query)
+print(result.data['people'][0])
+```
+
+### Input Object Types
+
+You can also create input object types from Pydantic models for mutations and queries:
+
+```python
+from graphene_pydantic import PydanticInputObjectType
+
+class PersonInput(PydanticInputObjectType):
+    class Meta:
+        model = PersonModel
+        # exclude specified fields
+        exclude_fields = ("id",)
+
+class CreatePerson(graphene.Mutation):
+    class Arguments:
+        person = PersonInput()
+
+    Output = Person
+
+    @staticmethod
+    def mutate(parent, info, person):
+        personModel = PersonModel(id=uuid.uuid4(), first_name=person.first_name, last_name=person.last_name)
+        # save PersonModel here
+        return person
+
+class Mutation(graphene.ObjectType):
+    createPerson = CreatePerson.Field()
+
+schema = graphene.Schema(mutation=Mutation)
+```
+
+Then execute with the input:
+
+```python
+mutation = '''
+mutation {
+    createPerson(person: {
+        firstName: "Jerry",
+        lastName: "Smith"
+    }) {
+        firstName
+    }
+}
+'''
+result = schema.execute(mutation)
+print(result.data['createPerson']['firstName'])
 ```
 
 ### Forward declarations and circular references
@@ -210,3 +259,7 @@ If a field on a model is a Union between a class and a subclass (as in our examp
 Python 3.6's typing will not preserve the Union and throws away the annotation for the subclass.
 See [this issue](https://github.com/upsidetravel/graphene-pydantic/issues/11) for more details.
 The solution at present is to use Python 3.7.
+
+##### Input Object Types don't support unions as fields
+
+This is a GraphQL limitation. See [this RFC](https://github.com/graphql/graphql-spec/blob/master/rfcs/InputUnion.md) for the progress on supporting input unions. If you see an error like '{union-type} may only contain Object types', you are most likely encountering this limitation.

graphene_pydantic/__init__.py

@@ -1,3 +1,4 @@
-from .types import PydanticObjectType
+from .inputobjecttype import PydanticInputObjectType
+from .objecttype import PydanticObjectType
 
-__all__ = ["PydanticObjectType"]
+__all__ = ["PydanticObjectType", "PydanticInputObjectType"]

graphene_pydantic/converters.py

@@ -1,14 +1,31 @@
-import sys
 import collections
 import collections.abc
-import typing as T
-import uuid
 import datetime
 import decimal
 import enum
+import sys
+import typing as T
+import uuid
 
+from graphene import (
+    UUID,
+    Boolean,
+    Enum,
+    Field,
+    Float,
+    InputField,
+    Int,
+    List,
+    String,
+    Union,
+)
+from graphene.types.base import BaseType
+from graphene.types.datetime import Date, DateTime, Time
 from pydantic import BaseModel
-from pydantic.fields import Field as PydanticField
+from pydantic.fields import ModelField
+
+from .registry import Registry
+from .util import construct_union_class_name
 
 try:
     # Pydantic pre-1.0
@@ -38,10 +55,6 @@
     SHAPE_MAPPING = (fields.SHAPE_MAPPING,)
 
 
-from graphene import Field, Boolean, Enum, Float, Int, List, String, UUID, Union
-from graphene.types.base import BaseType
-from graphene.types.datetime import Date, Time, DateTime
-
 try:
     from graphene.types.decimal import Decimal as GrapheneDecimal
 
@@ -50,9 +63,6 @@
     # graphene 2.1.5+ is required for Decimals
     DECIMAL_SUPPORTED = False
 
-from .registry import Registry
-from .util import construct_union_class_name
-
 
 NONE_TYPE = None.__class__  # need to do this because mypy complains about type(None)
 
@@ -73,8 +83,37 @@ def _get_field(root, _info):
     return _get_field
 
 
+def convert_pydantic_input_field(
+    field: ModelField,
+    registry: Registry,
+    parent_type: T.Type = None,
+    model: T.Type[BaseModel] = None,
+    **field_kwargs,
+) -> InputField:
+    """
+    Convert a Pydantic model field into a Graphene type field that we can add
+    to the generated Graphene data model type.
+    """
+    declared_type = getattr(field, "type_", None)
+    field_kwargs.setdefault(
+        "type",
+        convert_pydantic_type(
+            declared_type, field, registry, parent_type=parent_type, model=model
+        ),
+    )
+    field_kwargs.setdefault("required", field.required)
+    field_kwargs.setdefault("default_value", field.default)
+    # TODO: find a better way to get a field's description. Some ideas include:
+    # - hunt down the description from the field's schema, or the schema
+    #   from the field's base model
+    # - maybe even (Sphinx-style) parse attribute documentation
+    field_kwargs.setdefault("description", field.__doc__)
+
+    return InputField(**field_kwargs)
+
+
 def convert_pydantic_field(
-    field: PydanticField,
+    field: ModelField,
     registry: Registry,
     parent_type: T.Type = None,
     model: T.Type[BaseModel] = None,
@@ -104,8 +143,8 @@ def convert_pydantic_field(
 
 def convert_pydantic_type(
     type_: T.Type,
-    field: PydanticField,
-    registry: Registry = None,
+    field: ModelField,
+    registry: Registry,
     parent_type: T.Type = None,
     model: T.Type[BaseModel] = None,
 ) -> BaseType:  # noqa: C901
@@ -128,8 +167,8 @@ def convert_pydantic_type(
 
 def find_graphene_type(
     type_: T.Type,
-    field: PydanticField,
-    registry: Registry = None,
+    field: ModelField,
+    registry: Registry,
     parent_type: T.Type = None,
     model: T.Type[BaseModel] = None,
 ) -> BaseType:  # noqa: C901
@@ -203,8 +242,8 @@ def find_graphene_type(
 
 def convert_generic_python_type(
     type_: T.Type,
-    field: PydanticField,
-    registry: Registry = None,
+    field: ModelField,
+    registry: Registry,
     parent_type: T.Type = None,
     model: T.Type[BaseModel] = None,
 ) -> BaseType:  # noqa: C901
@@ -256,8 +295,8 @@ def convert_generic_python_type(
 
 def convert_union_type(
     type_: T.Type,
-    field: PydanticField,
-    registry: Registry = None,
+    field: ModelField,
+    registry: Registry,
     parent_type: T.Type = None,
     model: T.Type[BaseModel] = None,
 ):