Perf: interfaces on non-node types produce huge queries

[vladar]

Take this schema:

interface Foo {
  foo: String
  bar: Int
}

type Foo1 implements Foo {
  foo: String
  bar: Int
  baz1: String
}

#...

type Foo99 implements Foo {
  foo: String
  bar: Int
  baz99: String
}

type Problem {
  foo: Foo
  foo2: Foo
}

Now if we try to generate a fragment for the type Problem it will inline every single FooX type (assuming they are non-node types):

fragment Problem on Problem {
  foo {
    ... on Foo1 {
      foo
      bar
      baz1
    }
    # ...
    ... on Foo99 {
      foo
      bar
      baz99
    }
  }

  foo2 {
    ... on Foo1 {
      foo
      bar
      baz1
    }
    # ...
    ... on Foo99 {
      foo
      bar
      baz99
    }
  }
}

If there are many fields of this type - things can get pretty wild. One idea of how to fix this - create a separate fragment for each non-node interface type:

fragment Foo on Foo {
  foo
  bar
    ... on Foo1 {
     baz1
    }
    # ...
    ... on Foo99 {
      baz99
    }
}
fragment Problem on Problem {
  foo {
    ...Foo
  }
  foo2 {
    ...Foo
  }
}

[andris-sevcenko]

This can also happen on a schema where the interfaces are defined in a more granular manner.

interface Identifiable {
	id: Int
	uid: String
}

interface ContentEntry {
	title: String!
	body: String
}

type Entry implements Identifiable & ContentEntry{
	id: Int
	uid: String
	title: String!
	body: String
	authorId: Int
}

type Author implements Identifiable {
	id: Int
	uid: String
	name: String
}

type SearchResultSet {
	resultNodes: [Identifiable]
	pageNumber: Int
	pageCount: Int
}

When trying to generate a fragment for the type SearchResultSet, it will also inline every type that implements the Identifiable interface. As more identifiable types are added, the fragment grows.