Method populateField

packages/core/src/entity/EntityLoader.ts:778–902

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

  }

  private async populateField<Entity extends object>(
    entityName: EntityName<Entity>,
    entities: Entity[],
    populate: PopulateOptions<Entity>,
    options: Required<EntityLoaderOptions<Entity>>,
  ): Promise<void> {
    const field = populate.field.split(':')[0] as EntityKey<Entity>;
    const prop = this.#metadata.find(entityName)!.properties[field] as EntityProperty<Entity>;

    if (prop.kind === ReferenceKind.SCALAR && !prop.lazy) {
      return;
    }

    options = { ...options, filters: QueryHelper.mergePropertyFilters(prop.filters, options.filters)! };
    const populated = await this.populateMany<Entity>(entityName, entities, populate, options);

    if (!populate.children && !populate.all) {
      return;
    }

    const children: Entity[] = [];

    for (const entity of entities) {
      const ref = entity[field] as unknown;

      if (Utils.isEntity<Entity>(ref)) {
        children.push(ref);
      } else if (Reference.isReference<Entity>(ref)) {
        children.push(ref.unwrap());
      } else if (Utils.isCollection<Entity>(ref)) {
        children.push(...ref.getItems());
      } else if (ref && prop.kind === ReferenceKind.EMBEDDED) {
        children.push(...Utils.asArray(ref as Entity));
      }
    }

    if (populated.length === 0 && !populate.children) {
      // Populate child-specific relations for TPT entities already in the identity map (GH #7529).
      // Pass a sentinel hint so the existing TPT child handling in `populate()` does the real work.
      if (populate.all && prop.targetMeta?.inheritanceType === 'tpt') {
        const visited = (options as Dictionary).visited as Set<AnyEntity>;
        const pending = Utils.unique(children).filter(
          c => helper(c as AnyEntity).__meta !== prop.targetMeta && !visited.has(c as AnyEntity),
        );

        if (pending.length > 0) {
          const hint = [
            { field: prop.targetMeta.primaryKeys[0], strategy: LoadStrategy.SELECT_IN, all: true },
          ] as PopulateOptions<Entity>[];
          await this.populate(prop.targetMeta.class as EntityName<Entity>, pending as Entity[], hint, {
            ...options,
            lookup: false,
            validate: false,
          });
        }
      }

      return;