Function buildPopulateOrderBy

packages/sql/src/AbstractSqlDriver.ts:3222–3329

(
    qb: AnyQueryBuilder<T>,
    meta: EntityMetadata<T>,
    populateOrderBy: QueryOrderMap<T>[],
    parentPath: string,
    explicit: boolean,
    parentAlias = qb.alias,
  )

  }

  protected buildPopulateOrderBy<T extends object>(
    qb: AnyQueryBuilder<T>,
    meta: EntityMetadata<T>,
    populateOrderBy: QueryOrderMap<T>[],
    parentPath: string,
    explicit: boolean,
    parentAlias = qb.alias,
  ): QueryOrderMap<T>[] {
    const orderBy: QueryOrderMap<T>[] = [];

    for (let i = 0; i < populateOrderBy.length; i++) {
      const orderHint = populateOrderBy[i];

      for (const field of Utils.getObjectQueryKeys(orderHint)) {
        const childOrder = orderHint[field as keyof typeof orderHint];

        if (RawQueryFragment.isKnownFragmentSymbol(field)) {
          const { sql, params } = RawQueryFragment.getKnownFragment(field)!;
          const key = raw(sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), parentAlias), params);
          orderBy.push({ [key]: childOrder } as QueryOrderMap<T>);
          continue;
        }

        const prop = meta.properties[field];

        if (!prop) {
          throw new Error(`Trying to order by not existing property ${meta.className}.${field}`);
        }

        let path = parentPath;
        const meta2 = prop.targetMeta!;
        if (
          prop.kind !== ReferenceKind.SCALAR &&
          (![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) ||
            !prop.owner ||
            Utils.isPlainObject(childOrder))
        ) {
          path += `.${field}`;
        }

        if (prop.kind === ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
          path += '[pivot]';
        }

        const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
        const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true }) ?? parentAlias;

        if (!join) {
          // an owner to-one relation that is not joined (e.g. ordering a populated collection by such
          // a relation's primary key) can be ordered by its local FK columns, matching the `select-in`
          // and `balanced` strategies instead of silently dropping the clause
          if (
            prop.owner &&
            [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
            Utils.isPlainObject(childOrder)
          ) {
            for (const childField of Utils.getObjectQueryKeys(childOrder as Dictionary)) {
              const idx = prop.referencedPKs.indexOf(childField as EntityKey);