Field resolvers are not deferring to the resolvers for their object type as i would expect

[quirkles]

Im creating an app for managing players on soccer teams.

Heres a simplified db diagram:

This is my team resolver

@Resolver(() => TeamModel)
export class TeamResolver {
  @Query(() => TeamModel)
  async team(@Arg("id") id: string) {
    const teamRepo = this.teamRepositoryFactory();
    return teamRepo.findOneBy({ id });
  }

  @FieldResolver(() => [UserToTeamModel])
  async players(@Root() team: TeamModel): Promise<UserToTeamModel[]> {
    const teamModel = await this.teamRepositoryFactory().findOneOrFail({
      where: { id: team.id },
      relations: ["userToTeams"],
    });
    return teamModel.userToTeams;
  }
}

And the user to team resolver:

@Resolver(() => UserToTeamModel)
export class TeamPlayerResolver {
  @FieldResolver(() => UserModel)
  async user(@Root() teamPlayer: UserToTeamModel): Promise<UserModel> {
    return this.userRepositoryFactory().findOneOrFail({
      where: { id: teamPlayer.userId },
    });
  }

  @FieldResolver(() => TeamModel)
  async team(@Root() teamPlayer: UserToTeamModel): Promise<TeamModel> {
    return this.teamRepositoryFactory().findOneOrFail({
      where: { id: teamPlayer.teamId },
    });
  }
}

Im using typeorm, here are the models:

Team

@Entity({ name: "team" })
@ObjectType("Team", {})
export class TeamModel extends BaseEntity {
  @PrimaryGeneratedColumn("uuid")
  @Field(() => ID)
  id!: string;

  @Field(() => String)
  @Column()
  name!: string;

  @OneToMany(() => UserToTeamModel, (userToTeam) => userToTeam.team)
  userToTeams!: UserToTeamModel[];

  @AfterLoad()
  async nullChecks() {
    if (!this.userToTeams) {
      this.userToTeams = [];
    }
  }
}

Model

@Entity({ name: "user_to_team" })
@ObjectType("TeamPlayer", {})
export class UserToTeamModel extends BaseEntity {
  @PrimaryGeneratedColumn()
  public id!: number;

  @Column()
  public position!: string;

  @Field(() => ID)
  @Column()
  public userId!: string;

  @Field(() => ID)
  @Column()
  public teamId!: string;

  @Field(() => UserModel)
  @ManyToOne(() => UserModel, (user) => user.userToTeams)
  public user!: UserModel;

  @Field(() => TeamModel)
  @ManyToOne(() => TeamModel, (team) => team.userToTeams)
  public team!: TeamModel;
}

This is the error im seeing:

I suppose what i was expecting is that because im querying the user field of a team model it would hit the field resolver of the user to team resolver because the players field resolver resolvers to a userToTeamModel:

  @FieldResolver(() => UserToTeamModel)
  async players(@Root() team: TeamModel): Promise<UserToTeamModel[]> {
    const teamModel = await this.teamRepositoryFactory().findOneOrFail({
      where: { id: team.id },
      relations: ["userToTeams"],
    });
    return teamModel.userToTeams;
  }
}

and the userToteam resolver has the return type defined :

@Resolver(() => UserToTeamModel)
export class TeamPlayerResolver {
  @FieldResolver(() => UserModel)
  async user(@Root() teamPlayer: UserToTeamModel): Promise<UserModel> {
    return this.userRepositoryFactory().findOneOrFail({
      where: { id: teamPlayer.userId },
    });
  }

so even though the userToTeam players field resolver doesnt return a model with the player field populated it would defer to the field resolver for that field.

Am i just fundamentally mistaken about how the field resolvers work? How would i go about implementing this? I could, of course populate the user relation in the userToTeam field resolver of the team resolver, but that user itself will have fields that are queryable i will want to defer to the field resolvers on the user resolver for.

The un-simplified code is here: https://github.com/quirkles/madrid_reds_graphql/tree/main/src, the models are in the datalayer folder.

[quirkles]

Turns out im a completle idiot, i was simply not registering the necessary resolver: