Give an option to combine schema types and mapper types together.

[xoldd]

I want to combine typescript schema types and typescript mapper types together to generate a combined type that combines fields of both types. This would reduce the amount of typescript conflicts in resolver code.

For example in the following code snippets 1st one is the default graphql codegen generated typescript type for User. The 2nd one is the database type generated for User. In resolver code resorting to using only one of the types results in much headache, instead we should just combine both the types and use a type that's much more flexible.

// 1st graphql schema type
type GraphQLSchemaUser = {
  id: string | number
  bestFriend?: User | null
}

// 2nd database type
type DataBaseUser = {
  id: string;
  bestFriendId: string;
}

type User =  GraphQLSchemaUser | DataBaseUser;
// 3rd combined graphql schema + database type
type User = {
  id: string | number
  bestFriend?: User | null
  bestFriendId: string
}
// when we choose to resolve bestFriend within a Query type resolver
const Query = {
  user: (_parent, args) => {
    const user = await db.users.findOne({ where: { id: args.id });
    const bestFriend = await db.users.findOne({ where: { id: user.bestFriendId });
    return {...user, bestFriend}
  }
}
// when we choose to resolve bestFriend in a User field resolver
const Query = {
  user: (_parent, args) => {
    const user = await db.users.findOne({ where: { id: args.id });
    return user;
  }
}
// User type fields resolver
const User = {
  bestFriend: (parent, args) => {
    const bestFriend = await db.users.findOne({ where: { id: parent.bestFriendId });
    return bestFriend
  }
}

Now when resolvers make use of the 3rd type we have the freedom to resolve bestFriend within the query/mutation resolvers or delegate it to the User field resolver bestFriend which can then make use of the parent.bestFriendId to resolve the corresponding bestFriend. Best of both worlds and we retain all the type information.

For two fields sharing the same name, which field's type should be used?

I think using type of the field which is less restrictive makes sense. For example take a look at the email field of the User type, in 1st case email field is nullish(both nullable and undefined), this could be required for cases where we don't want to reveal email field information to a client freely. In 2nd case it is not nullish because it represents the database state of the field.

// 1st graphql schema type
type GraphQLSchemaUser = {
  id: string | number
  bestFriend?: User | null
  email?: string | null
}

// 2nd database type
type DataBaseUser = {
  id: string;
  bestFriendId: string;
  email: string
}

Now when we combine the 1st and 2nd cases we should opt for type of the email field of User in 1st case which is less strict:- email?: string | null

type User =  GraphQLSchemaUser | DataBaseUser;
// 3rd combined graphql schema + database type
type User = {
  id: string | number
  bestFriend?: User | null
  bestFriendId: string
  email?: string | null
}
// User type fields resolver
const User = {
  email: (parent, args, ctx) => {
    if(ctx.currentUser.id !== parent.id) {
      throw new GraphQLError("Cannot access the private field email.");
    }
    return parent.email;
  }
}