Function buildFields

packages/sql/src/AbstractSqlDriver.ts:3450–3547

(
    meta: EntityMetadata<T>,
    populate: PopulateOptions<T>[],
    joinedProps: PopulateOptions<T>[],
    qb: AnyQueryBuilder<T>,
    alias: string,
    options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>,
    schema?: string,
  )

  }

  protected buildFields<T extends object>(
    meta: EntityMetadata<T>,
    populate: PopulateOptions<T>[],
    joinedProps: PopulateOptions<T>[],
    qb: AnyQueryBuilder<T>,
    alias: string,
    options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>,
    schema?: string,
  ): InternalField<T>[] {
    const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => this.isPopulated(meta, prop, p)));
    const hasLazyFormulas = meta.props.some(p => p.lazy && p.formula);
    const requiresSQLConversion = meta.props.some(p => p.customType?.convertToJSValueSQL && p.persist !== false);
    const hasExplicitFields = !!options.fields;
    const ret: InternalField<T>[] = [];
    let addFormulas = false;

    // handle root entity properties first, this is used for both strategies in the same way
    if (options.fields) {
      for (const field of this.normalizeFields(options.fields as string[])) {
        if (field === '*') {
          ret.push('*');
          continue;
        }

        const parts = field.split('.');
        const rootPropName = parts.shift()!; // first one is the `prop`
        const prop = QueryHelper.findProperty<T>(rootPropName, {
          metadata: this.metadata,
          platform: this.platform,
          entityName: meta.class,
          where: {} as FilterQuery<T>,
          aliasMap: qb.getAliasMap(),
        });

        this.processField(meta, prop, parts.join('.'), ret);
      }

      if (!options.fields.includes('*') && !options.fields.includes(`${qb.alias}.*`)) {
        ret.unshift(...meta.primaryKeys.filter(pk => !options.fields!.includes(pk)));
      }

      if (
        meta.root.inheritanceType === 'sti' &&
        !options.fields.includes(`${qb.alias}.${meta.root.discriminatorColumn!}`)
      ) {
        ret.push(meta.root.discriminatorColumn!);
      }
    } else if (!Utils.isEmpty(options.exclude) || lazyProps.some(p => !p.formula && (p.kind !== '1:1' || p.owner))) {
      const props = meta.props.filter(prop =>
        this.platform.shouldHaveColumn(prop, populate, options.exclude as string[], false, false),
      );
      ret.push(...props.filter(p => !lazyProps.includes(p)).map(p => p.name));
      addFormulas = true;
    } else if (hasLazyFormulas || requiresSQLConversion) {
      ret.push('*');
      addFormulas = true;
    } else {
      ret.push('*');