Django: Map Form to Mutation

Currently it’s possible to map Django models to ObjectTypes using DjangoNode. I think it would be nice to have a similar feature that allows mapping forms to Mutation with a DjangoMutation class.

This would provide several great improvements:

• No need to duplicate form fields in Input classes anymore.
• There would be a simple and obvious way to handle validation.
• The code could map form.errors to info.context.errors (It took a while until I figured out how to do that) on it’s own.

In the simple case you’d only have to define the outputs and a method that takes the validated data and returns an instance of the mutation class. I believe that even that would be unnecessary, if you’re working with ModelForms. In that case a default method could just save the form and return the model instance wrapped in the corresponding DjangoNode.

Code that gets us some of the way to such a class already appears to exist, which was written for the django-filter integration.

I’m not that familiar with the code base itself but I have read quite a bit of it and I’ think it might be able to implement this. I’m interested to know what you think of it and whether this has a chance to be accepted.

[johandc]

Hi what is the status on this?

I need something like a UserInputType for a IntroduceUser mutation and i don’t want to manually map all the fields of the Django User model.

I would like if there would be a DjangoInputObjectType that could be created similar to the DjangoObjectType. Passing it through Django Forms is a brilliant solution to handling field validation, but being able to bypass validation would be appreciated for bulk data imports from a trusted system.

[gcheshkov]

@stefanfoulis ErrorType is simple graphene object type for representing errors:

class ErrorType(graphene.ObjectType):
    field = graphene.String()
    message = graphene.String()

However now I took different approach to error handling. Just raising ValidationError in mutation handler and adding error messages to errors object in overridden GraphQLView.format_error method:

def format_error(error):
    data = {
        'message': str(error),
    }

    if isinstance(error, GraphQLLocatedError):
        data.update(format_graphql_error(error))
        if isinstance(error.original_error, Exception):
            error = error.original_error
        else:
            return data

    if isinstance(error, APIException):
        if isinstance(error, ValidationError):
            data.update({
                'message': _('Validation error'),
                'code': 'validation_error',
                'fields': error.detail
            })
        else:
            if getattr(error, 'error_code', None):
                data['code'] = error.error_code

            if getattr(error, 'extra', None):
                data.update(error.extra)

    elif isinstance(error, DjangoPermissionDenied):
        data.update({
            'message': _('Permission denied'),
            'code': 'permission_denied'
        })

    elif isinstance(error, GraphQLError):
        pass

    elif isinstance(error, HttpError):
        pass

    else:
        data['code'] = 'unhandled_exception'
        if not settings.DEBUG:
            data['message'] = _('Server error')
        else:
            data['message'] = '{}: {}'.format(error.__class__.__name__, error)
            data['traceback'] = itertools.chain(
                *[[l for l in ll.split('\n') if l.strip() != '']
                  for ll in traceback.format_exception(
                        error.__class__, error, error.__traceback__)])

    return data