Method populateMany

packages/core/src/entity/EntityLoader.ts:281–356

* preload everything in one call (this will update already existing references in IM)

(
    entityName: EntityName<Entity>,
    entities: Entity[],
    populate: PopulateOptions<Entity>,
    options: Required<EntityLoaderOptions<Entity>>,
  )

   * preload everything in one call (this will update already existing references in IM)
   */
  private async populateMany<Entity extends object>(
    entityName: EntityName<Entity>,
    entities: Entity[],
    populate: PopulateOptions<Entity>,
    options: Required<EntityLoaderOptions<Entity>>,
  ): Promise<AnyEntity[]> {
    const [field, ref] = populate.field.split(':', 2) as [EntityKey<Entity>, string | undefined];
    const meta = this.#metadata.find<Entity>(entityName)!;
    const prop = meta.properties[field];

    if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.#driver.getPlatform().usesPivotTable()) {
      const filtered = entities.filter(e => !(e[prop.name] as Collection<any>)?.isInitialized());

      if (filtered.length > 0) {
        await this.populateScalar(meta, filtered, { ...options, fields: [prop.name] as any });
      }
    }

    if (prop.kind === ReferenceKind.SCALAR && prop.lazy) {
      const filtered = entities.filter(
        e =>
          options.refresh ||
          (prop.ref ? !(e[prop.name] as ScalarReference<any>)?.isInitialized() : e[prop.name] === undefined),
      );

      if (options.ignoreLazyScalarProperties || filtered.length === 0) {
        return entities as AnyEntity[];
      }

      await this.populateScalar(meta, filtered, { ...options, fields: [prop.name] as any });

      return entities as AnyEntity[];
    }

    if (prop.kind === ReferenceKind.EMBEDDED) {
      return [];
    }

    const filtered = this.filterCollections<Entity>(entities, field, options, ref);
    const innerOrderBy = Utils.asArray(options.orderBy)
      .filter(
        orderBy =>
          (Array.isArray(orderBy[prop.name]) && (orderBy[prop.name] as unknown[]).length > 0) ||
          Utils.isObject(orderBy[prop.name]),
      )
      .flatMap(orderBy => orderBy[prop.name]);
    const where = await this.extractChildCondition(options, prop);
    const mergedOrderBy = populate.orderBy ? Utils.asArray(populate.orderBy) : innerOrderBy;

    if (prop.kind === ReferenceKind.MANY_TO_MANY && this.#driver.getPlatform().usesPivotTable()) {
      const pivotOrderBy = QueryHelper.mergeOrderBy<Entity>(mergedOrderBy, prop.orderBy, prop.targetMeta?.orderBy);
      const res = await this.findChildrenFromPivotTable<Entity>(filtered, prop, options, pivotOrderBy, populate, !!ref);
      return Utils.flatten(res);
    }

    if (prop.polymorphic && prop.polymorphTargets) {
      return this.populatePolymorphic<Entity>(entities, prop, options, !!ref);
    }