Saving null value for nullable fields

[prokofiev]

I had a problem saving the null values in the mutations. Is it possible to implement functionality to get_argument_values function could distinguish passed null value and not passed value?
I think it can be implemented similar to the executor.ececute_fields using Undefined.

[syrusakbary]

Hi @prokofiev!

You can actually use the default_value in the Argument and set another default than None.

So currently you can do:

class Undefined(object): pass

class Query(graphene.ObjectType):
    field = graphene.String(
        input=graphene.String(default_value=Undefined)
    )

It might be interesting to set Undefined as default_value in a GraphQLArgument in graphql-core instead of None, but probably this is something that we should investigate a little bit further :)

[prokofiev]

Hi @syrusakbary !
Thanks for answer, but default_value will not be able to solve my problem.
I try to describe the problem in more detail:

class Foo(models.Model):
    ''' Example model with nullable field '''
    not_null = models.CharField(max_length=10)
    nullable = models.CharField(max_length=10, null=True)

Next my use cases:

1. Insert with default null value

mutation InsertFoo{
    saveFoo (input:{
        clientMutationId:"1"
        notNull:"value"
    }) {
      ...
    }
}

2. Update nullable field (set "value"), not_null ignored

mutation UpdateFoo{
    saveFoo (input:{
        clientMutationId:"1"
        id:"id"
        nullable: "value"
    }) {
      ...
    }
}

3. Update nullable field (set null), not_null ignored

mutation UpdateFoo{
    saveFoo (input:{
        clientMutationId:"1"
        id:"id"
        nullable: null
    }) {
      ...
    }
}

How can I use "default_value" to set the nullable field to null (case 3)?

[syrusakbary]

Hey @prokofiev, after thinking about this I realized this could be approached in a easier way. As input is a dict, you could check if not_null in exists in input.

Something like

@classmethod
def mutate_and_get_payload(cls, input, context, info):
    not_null = 'UNDEFINED'
    if 'not_null' in input:
        # ....
        not_null = input['not_null']
   # ....

Does that make sense?

[prokofiev]

Hi @syrusakbary !
It does not make sense because the fields with null values are removed from the argument list and not in the input dict.
Problem in graphql-core in this and this functions.
Function value_from_ast return None, and then function get_argument_values check if value is not None.

[syrusakbary]

After checking, I realized that this query:

mutation UpdateFoo{
    saveFoo (input:{
        clientMutationId:"1"
        id:"id"
        nullable: null
    }) {
      ...
    }
}

Is actually not valid as null is not a valid value in GraphQL.
https://github.com/graphql-python/graphql-core/blob/master/graphql/language/tests/test_parser.py#L80-L84

For this reason I guess that some client's check when the value is null and then skip it (Relay?).

As an extra exercise, I checked that arguments and input fields that are not provided don't fill the dictionary with None values:

def test_does_not_include_arguments_that_were_not_set():
    InputObject = GraphQLInputObjectType(
        name='InputObject',
        fields={
            'value': GraphQLInputObjectField(GraphQLString, default_value=None),
            'other': GraphQLInputObjectField(GraphQLString, default_value=None)
        }
    )
    def resolver(data, args, *_):
        print args
        return 'other' in args['c']

    schema = GraphQLSchema(GraphQLObjectType(
        'Type',
        {
            'field': GraphQLField(
                GraphQLInt,
                resolver=resolver,
                args={
                    'a': GraphQLArgument(GraphQLBoolean),
                    'b': GraphQLArgument(GraphQLBoolean),
                    'c': GraphQLArgument(InputObject),
                    'd': GraphQLArgument(GraphQLInt),
                    'e': GraphQLArgument(GraphQLInt),
                }
            )
        }
    ))

    ast = parse('{ field(c: {value: "3"}) }')
    result = execute(schema, ast)
    assert result.data == {
        'field': False
    }

If you can provide more insights that I might be missing please let me know.

[prokofiev]

null value may be passed like this:

mutation UpdateFoo($var1:String!){
    saveFoo (input:{
        clientMutationId:"1"
        id:"id"
        nullable: $var1
    }) {
      ...
    }
}

variables:

{"var1": null}

[nuschk]

Hey @prokofiev , did you find a workaround for this?

I'm struggling with exactly the same problem and am very interested in your approach. The least hack I could come up with, is to always require all arguments and then use 'input.get('myVar', None)' to retrieve them in 'mutate_and_get_payload()'.

Even setting the field to be required and having a default value will not make it appear in the input dict...

[prokofiev]

Hi @nuschk.
I found solution for my case. It's monkey patch but it works...
You can see my patch here
Call apply from any place when initialize your app.

[prokofiev]

If somebody knows how to fix it more correctly, please let me know.

[nuschk]

@prokofiev Hehe, thanks for the snippet. Will look into it.

[BossGrand]

@syrusakbary have you seen this pull request?
graphql/graphql-spec#83

graphql now supports nullable types. Can we get some support for this in graphene?