Function buildOrderBy

packages/orm/src/client/crud/dialects/base-dialect.ts:1102–1176

(
        query: SelectQueryBuilder<any, any, any>,
        model: string,
        modelAlias: string,
        orderBy: OrArray<OrderBy<Schema, GetModels<Schema>, boolean, boolean>> | undefined,
        negated: boolean,
        take: number | undefined,
    )

    }

    buildOrderBy(
        query: SelectQueryBuilder<any, any, any>,
        model: string,
        modelAlias: string,
        orderBy: OrArray<OrderBy<Schema, GetModels<Schema>, boolean, boolean>> | undefined,
        negated: boolean,
        take: number | undefined,
    ) {
        if (!orderBy) {
            return query;
        }

        let result = query;

        const buildFieldRef = (model: string, field: string, modelAlias: string) => {
            const fieldDef = requireField(this.schema, model, field);
            return fieldDef.originModel
                ? this.fieldRef(fieldDef.originModel, field, fieldDef.originModel)
                : this.fieldRef(model, field, modelAlias);
        };

        enumerate(orderBy).forEach((orderBy, index) => {
            for (const [field, value] of Object.entries<any>(orderBy)) {
                if (!value) {
                    continue;
                }

                // _fuzzyRelevance ordering
                if (field === '_fuzzyRelevance') {
                    result = this.applyFuzzyRelevanceOrderBy(result, model, modelAlias, value, negated, buildFieldRef);
                    continue;
                }

                // _ftsRelevance ordering
                if (field === '_ftsRelevance') {
                    result = this.applyFtsRelevanceOrderBy(result, model, modelAlias, value, negated, buildFieldRef);
                    continue;
                }

                // aggregations
                if (['_count', '_avg', '_sum', '_min', '_max'].includes(field)) {
                    result = this.applyAggregationOrderBy(
                        result,
                        model,
                        modelAlias,
                        field as AggregateOperators,
                        value,
                        negated,
                        buildFieldRef,
                    );
                    continue;
                }

                const fieldDef = requireField(this.schema, model, field);

                if (!fieldDef.relation) {
                    result = this.applyScalarOrderBy(result, model, modelAlias, field, value, negated, buildFieldRef);
                } else {