Handling parents in resolvers on entity fields since typescipt-resolvers v5

[RMHonor]

The latest version of typescript resolvers has improved the type safety of resolvers for fields that are federated entities (thank Eddy!): #10297

In practice, what this means is that the parent argument in resolvers is a union of the federated entity or the type of the parent (or its mapper).

E.g. schema:

type User @key(fields: "id") {
  id: ID!
  firstName: String!
  lastName: String!
  fullName: String
}

The challenge now is, despite defining a reference resolver, the resolvers aren't aware that these fields are defined. It's using the federated entity type, rather than the defined User type (or mapped type if we had one)

Resolvers:

const resolvers: Resolvers = {
  User: {
    __resolverReference: (user) => { // expects a return type of User
      return {
        id: user.id,
        firstName: "Bob",
        lastName: "Smith",
      };
    },
    fullName: (user) => {
      return user.firstName + user.lastName; // property firstName does not exist
    },
  },
};

My question is what's the best way to handle this? For now what we've done is define a basic type guard:

if ("firstName" in user) {
  ...
}

But this is introducing extra runtime code (okay, a tiny amount), to perform a check that will always be true. Is there a better way?

Alternatively, could the resolver types be structured in such a way that the resolvers include the true type if a reference resolver has been defined? i.e.

type ResolverWithReference = {
  __resolveReference: never;
  fullName: (parent: FederatedUser) => string;
};

type ResolverWithoutReference = {
  __resolveReference: (entity: FederatedUser) => User;
  fullName: (parent: User) => string;
};

// I know the types here are actually vastly more complicated, but I hope it captures my thinking
type Resolver = ResolverWithReference | ResolverWithoutReference;