Self Answer... After I am looking into TypeORM index.d.ts, I take it that there are some parameter in createQueryBuilder named queryRunner so. If you input there your own query runner for transaction you can use queryBuilder with queryRunner

As like:

  public createOrderTransaction = async (
    data: CreateOrderInputDTO,
  ): Promise<Order> => {
    const queryRunner = this.connection.createQueryRunner();

    await queryRunner.connect();
    await queryRunner.startTransaction();
    try {
      const order = await this.createOrder(data, queryRunner);
      await this.createOrderRecord(order.id, data, queryRunner);
      await queryRunner.commitTransaction();
      return order;
    } catch (error) {
      this.logger.error(
        "Transaction Error: 'createOrderTransaction' is failed: ",
        error,
      );
      if (queryRunner.isTransactionActive) {
        await queryRunner.rollbackTransaction();
      }
    }
  };

createOrder as like:

 private createOrderRecord = async (
    orderId: string,
    data: CreateOrderInputDTO,
    queryRunner?: QueryRunner,
  ): Promise<void> => {
    await this.orderRecordRepository
      .createQueryBuilder('order_record', queryRunner)
      .insert()
      .into(OrderRecord)
      .values([
        {
          ...data,
          orderId,
          createdAt: new Date(),
        },
      ])
      .execute();

    await this.orderRecordRepository
      .createQueryBuilder('order_record', queryRunner)
      .relation(OrderRecord, 'orderDetails')
      .of(orderId)
      .add(data.orderDetails);
  };

Above code is indeed working, confirmed using TypeORM's logging, it shows the transaction starting and all the following queries before committing.

More info on how to enable Logging and to verify if your queries are under the same transaction: https://github.com/typeorm/typeorm/blob/master/docs/logging.md

Ok, so I solved it. It was down to the fact that forEach seems to behave asynchronously so the code would jump to the end of the transaction before completing the loop. While looking for a solution I changed the methods I use and some of the functionality so the code ended up quite different, but the main thing is that I used Promise.all() and passed it the result of a .map() that returned promises.

await getManager().transaction(async transactionalEntityManager => {
                savedFeed = await transactionalEntityManager.save(newFeed);
                if (feed.feedSources) {
                    newFeed.feedSources = [];
                    await Promise.all(
                        feed.feedSources.map(async feedSource => {
                            return new Promise(async (resolve, reject) => {
                                const referencedSource = await Source.findOne(feedSource.sourceId);
                                console.log('===referencedSource===\n', referencedSource);
                                if (!referencedSource)
                                    throw new Error(
                                        'Could not find referenced source with id ' + feedSource.id
                                    );
                                const currentFeedSource = new FeedSource();
                                currentFeedSource.source = referencedSource;
                                currentFeedSource.feed = savedFeed;
                                feedSource.postColor
                                    ? (currentFeedSource.postColor = feedSource.postColor)
                                    : '';
                                feedSource.fontColor
                                    ? (currentFeedSource.fontColor = feedSource.fontColor)
                                    : '';
                                console.log('===currentFeedSource===\n', currentFeedSource);
                                await transactionalEntityManager.save(currentFeedSource);
                                resolve(true);
                            });
                        })
                    );
                }

I had exactly the same expectations as you. Coming from Rails and Spring, I expected to have transactional tests and found no solution directly from Typeorm.

It is hard to reuse the same transactions during the tests because the connection class always create a new QueryRunner for every database command or transaction. Diving into TypeORM, the solution I found was to monkey patch the method which creates the query runner, to reuse it during the tests. I created this library to reuse this code in several projects: https://github.com/viniciusjssouza/typeorm-transactional-tests.