Feature request: deduplicating models for input types that match type types

[BatmanAoD]

This is related to #1223, but that doesn't quite capture my question, and I couldn't find anything more related. I didn't exactly follow the template because this is a feature request rather than a bug report.

GraphQL requires non-scalar parameter types to be defined with input, rather than type. This means that if you have an input value and an output value that structurally match, you nevertheless must write separate types for them.

But when mapping these types to Go structs, there's no reason to have them duplicated other than to ensure that the names match. So, for example:

type Foo {
    data: Int
    nested: Inner
}

type Inner {
    data: String
}

input FooInput {
    data: Int
    nested: InnerInput
}

input InnerInput {
    data: String
}

If it's important to have Go structs with ...Input in the names, then the existing model-generation works fine. But in some cases it may be more useful to de-duplicate these structs, producing:

type Foo struct {
    Data: *int `json:"data"`
    Inner: *Inner `json:"inner"`
}

type Inner struct {
    Data: *string `json:"data"`
}

The Foo struct can now be used to serialize or deserialize both the Foo and FooInput GraphQL types.

Ideally, I would like a way to globally detect instances where type <name> and input *<name>* exist in the schema, and the input type has the same structure (where inner fields with non-scalar types have the same property, recursively). But as an alternative, generation of the input types could be explicitly suppressed on a per-type basis.

Is this possible, or a feature you would consider adding?

[danvolchek]

I'm also curious about this!

I'm designing an API that looks like this:

type Foo {
 # fields
}

input FooInput {
 # exact same fields as foo
}

type Query {
  getFoos: [Foo]
}

type Mutation {
  newFoo(input: FooInput): Foo
}

Foo is backed by a type I've defined that is persisted by a datastore.

Using autobind, I can have Foo point to that type and it works well - I can pass types directly to the data store.

However, since I can't use Foo in place of FooInput in the GQL schema, I end up needing to convert the generated FooInput to Foo myself before I can pass it to the datastore to save.

It would be nice if I didn't need to do that.

Also, I agree with @BatmanAoD that it would also be nice for the schema to be simpler.