Union Resolvers feature idea

I had an idea for another possible feature.
Union Resolvers. Adding /// @TypeGraphql.Union = result to two models will generate an additional set of findOne/findMany revolvers of a union type of each model that is in that union.

An example may look like this.

/// @TypeGraphql.Union = product
model Movie {
  id        Int     @id @default(autoincrement())
  title     String
  length    Int
  actors    Actor[]
}

/// @TypeGraphql.Union = product
model Book {
  id        Int     @id @default(autoincrement())
  title     String
  pages     Int   
}

model Actor {
  id        Int     @id @default(autoincrement())
  name      String
}

Which would generate this type and the resolvers for it.

export const Product = createUnionType({
  name: 'Product',
  types: () => [Movie, Book],
});

The Prisma code for this may look something like this.

const movies = await prisma.movies.findMany(args).then((movies: Movie[]) => plainToClass(Movie, movies));
const books = await prisma.books.findMany(args).then((books: Book[]) => plainToClass(Book, books));
return [...movies, ...books].sort(byArgs(args));

The difficult part would be defining the orderBy and where arguments as you would need to determine what fields were shared between the two (or more) models and use those to generate the arguments.
Additionally sorting will likely have some additional overhead but it would be cool to be able to do something like this.

{
  products {
    ... on Book {
      title
      pages
    }
    ... on Movie {
      title
      length
    }
  }
}

Originally posted by @wSedlacek in https://github.com/MichalLytek/typegraphql-prisma/issues/1#issuecomment-674492557

No files, tests, or implementation entry points are named. Start by locating the generator paths that emit GraphQL types and CRUD resolvers, then determine how union members, shared fields, filtering, ordering, and resolver output would be represented. Done would require an agreed design and working generated union types and resolvers.