Eager relation is fetched twice when the query already joins and selects it (`relationLoadStrategy: 'query'`)

import 'reflect-metadata';
import { Column, DataSource, Entity, ManyToOne, OneToMany, PrimaryGeneratedColumn } from 'typeorm';

let transformerCalls = 0;

@Entity()
class Variant {
    @PrimaryGeneratedColumn() id: number;
    @Column() sku: string;
    @OneToMany(() => Price, price => price.variant, { eager: true }) prices: Price[];
}

@Entity()
class Price {
    @PrimaryGeneratedColumn() id: number;
    @Column({
        transformer: {
            to: (v: number) => v,
            from: (v: number) => {
                transformerCalls++;
                return v;
            },
        },
    })
    amount: number;
    @ManyToOne(() => Variant, variant => variant.prices) variant: Variant;
}

async function main() {
    const selects: string[] = [];
    const dataSource = new DataSource({
        type: 'better-sqlite3',
        database: ':memory:',
        entities: [Price, Variant],
        synchronize: true,
        logging: ['query'],
        logger: {
            logQuery: (query: string) => {
                if (query.startsWith('SELECT') && query.includes('price')) {
                    selects.push(query);
                }
            },
            logQueryError: () => undefined,
            logQuerySlow: () => undefined,
            logSchemaBuild: () => undefined,
            logMigration: () => undefined,
            log: () => undefined,
        } as any,
    });
    await dataSource.initialize();

    const variant = await dataSource.getRepository(Variant).save({ sku: 'SKU1' });
    await dataSource.getRepository(Price).save({ amount: 500, variant });

    transformerCalls = 0;
    selects.length = 0;

    const rows = await dataSource
        .getRepository(Variant)
        .createQueryBuilder('variant')
        .setFindOptions({ relationLoadStrategy: 'query' })
        .leftJoinAndSelect('variant.prices', 'variant__prices')
        .orderBy('variant__prices.amount', 'ASC')
        .getMany();

    console.log('rows', rows.length, 'prices', rows[0].prices.length);
    console.log('SELECTs touching price:', selects.length);
    console.log('column transformer calls:', transformerCalls);
    selects.forEach((q, i) => console.log(`  [${i + 1}] ${q}`));
    await dataSource.destroy();
}

main().catch(e => {
    console.error(`${e.constructor.name}: ${e.message}`);
    process.exit(1);
});

rows 1 prices 1
SELECTs touching price: 3
column transformer calls: 2
  [1] SELECT "variant"."id" AS "variant_id", "variant"."sku" AS "variant_sku", "variant__prices"."id" AS "variant__prices_id", "variant__prices"."amount" AS "variant__prices_amount", "variant__prices"."variantId" AS "variant__prices_variantId" FROM "variant" "variant" LEFT JOIN "price" "variant__prices" ON "variant__prices"."variantId"="variant"."id" ORDER BY "variant__prices"."amount" ASC
  [2] SELECT "Price"."id" AS "Price_id", "Price"."amount" AS "Price_amount", "Price"."variantId" AS "Price_variantId" FROM "price" "Price" WHERE "Price"."variantId" IN (?)
  [3] SELECT "Price"."id" AS "Price_prices_id", "Price"."variantId" AS "Variant_id" FROM "price" "Price" WHERE "Price"."variantId" IN (1)

else if (this.expressionMap.relationLoadStrategy === "query") {
    this.concatRelationMetadata(...this.expressionMap.mainAlias.metadata.eagerRelations)
}