javascript - Problema de rendimiento y limitación de uno a muchos en GraphQL

Tengo una base de datos con 2 tablas => Jugador (10k entradas) y Gol (100k entradas). Tengo una relación uno a muchos entre ellas (Jugador tiene muchos Goles)

@Entity()
@ObjectType()
class Player {
  @Field(() => ID)
  @PrimaryGeneratedColumn("uuid")
  id: string;

  @Field(() => [Goal])
  @OneToMany(
    () => Goal,
    goal => goal.player
  )
  goals: Goal[];
  ...
}

@Entity()
@ObjectType()
class Goal {
  @Field(() => ID)
  @PrimaryGeneratedColumn("uuid")
  id: string;

  @ManyToOne(
    () => Player,
    player => player.id
  )
  player: Player;
  ...
}

Quiero consultar a los jugadores y sus goles para mostrar las clasificaciones de los jugadores en mi aplicación cliente

query scorers{
  players{
    id
    totalGoals
  }
}

El solucionador de jugador se ve así

@Resolver(Player)
class PlayerResolver {
  @Query(() => [Player])
  async players() {
    return this.playerRepository.createQueryBuilder("player").getMany();
  }
  @FieldResolver()
  async totalGoals(@Root() player: Player) {
    return this.goalRepository.count({ player });
  }
}

Esto no es eficiente porque crea una consulta SQL en segundo plano para solicitar los goles de cada jugador. Así que potencialmente son 10 mil consultas. ¿Es la mejor estrategia hacer esto? También me pregunto cómo podría posiblemente ordenar a los jugadores por la cantidad de goles. Estoy usando type-graphql y typeorm.

Respuesta #1

Puedes intentar construir la consulta con join de antemano (a nivel del resolvedor de consultas, usando @Info para leer los campos solicitados) o usar una biblioteca DataLoader para agrupar las consultas y resolver el problema N + 1.