Using the same type for querying and mutation

Today I learned that to allow a custom type as mutation argument, it needs to inherit from InputObjectType and it’s fields need to be of InputField type.

I think this requirement is forcing duplicating of types. What I mean is, say I have a Person type as:

class Person(ObjectType):
    id = Int()
    first_name = String()
    last_name = String()
    address = Field(SomeOtherType)

I expose it as a query-able object as well as return it as a result.

Now, If I want to allow it as a mutation argument to update a Person’s details, I will have to redefine it as something else:

class Person_1(InputObjectType):
    id = Int()
    first_name = String()
    last_name = String()
    address = InputField(SomeOtherType)

If this is the only way to do this, I think it is forcing me to define near duplicate types. Is there a way to work around this?

Can something be done about this in the code so that we can use the same type definition for querying as well as a mutation argument?

[j-robin-hunter]

Can you re-open this!! I agree that an AbstractType or similar needs to be able to be used to define both an Object and an InputObject. Noting that the AbstractType is now deprectaed at the least this should be possible from an Interface

[rsalmei]

Hello @syrusakbary, this really works for single level fields. Please, how do I nest one inside another?

Let’s say I have:

class PersonFields(graphene.AbstractType):
    name = graphene.String()
    age = graphene.Int()

class PersonContactFields(graphene.AbstractType):
    phone = graphene.Int()

How do I fit they together?

class PersonFields(graphene.AbstractType):
    name = graphene.String()
    age = graphene.Int()
    contact = graphene.??????(PersonContactFields)