Use DjangoObjectType (or something like it) as an Input class?

We’re using Graphene with Relay for some boring CRUD style mutations. Now, since we have some rather large (i.e., many fields) models, it’s a bit tedious and also error-prone, to repeat typing in the model’s fields again for each mutation. Is it possible to use DjangoObjectType for this (from my 1st try it seems that, no)?

I’m mainly interested in the Meta class’ model and only_fields options.

And guys, thanks for the hard work on such a cool tool.

[charlesverdad]

I was able to dynamically generate an Input class from Model using a Django Rest Framework serializer and the convert_serializer_to_input_type tool in graphene_django.rest_framework.serializer_converter.

Sample Code:

from rest_framework import serializers
from graphene_django.rest_framework.serializer_converter import convert_serializer_to_input_type

class PersonSerializer(serializers.ModelSerializer):
    class Meta:
        model = Person
        exclude = ('profile',)

class PersonArgsInput(convert_serializer_to_input_type(PersonSerializer)):
    create = graphene.Boolean(required=True)

In the above code I [optionally] created a PersonArgsInput, which inherits from the generated Input class, so I can add additional fields. I can then use the the new class in my mutations however I want. like so:

class PersonsMutation(graphene.Mutation):
    person_set = graphene.List(PersonType)
    class Arguments:
        person_set = graphene.List(PersonArgsInput)
    def mutate():
    ...

[nuschk]

Here’s something I put together, which seem to work, but is certainly work in progress:

import collections
from graphene_django import converter, utils

from graphene.types.utils import merge
from graphene.utils.is_base_type import is_base_type


def convert_fields(model, only_fields):
    model_fields = utils.get_model_fields(model=model)
    fields = collections.OrderedDict()

    for field in model_fields:
        name = field.name

        # Must be in only_fields
        if name not in only_fields:
            continue

        converted = converter.convert_django_field(field, None)
        if not converted:
            continue

        fields[name] = converted

    return fields


class DjangoModelInputMeta(type):

    @staticmethod
    def __new__(cls, name, bases, attrs):
        # We'll get called also for non-user classes like DjangoModelInput. Only
        # kick in when called for a sub-class.
        if not is_base_type(bases, DjangoModelInputMeta):
            return type.__new__(cls, name, bases, attrs)

        # Pop Meta info. Must be removed from class, otherwise graphene will
        # complain.
        meta = attrs.pop('Meta')
        fields = convert_fields(model=meta.model, only_fields=meta.only_fields)
        attrs = merge(attrs, fields)

        return type.__new__(cls, name, bases, attrs)


class DjangoModelInput(metaclass=DjangoModelInputMeta):
    """
    Derive a mutation's Input class from this and define a meta class with 
    `model` and `only_fields` members. This will populate the input class
    with the converted django members.
    """
    pass