@mikro-orm/knex 6.0.0-dev.8 → 6.0.0-dev.80

package/query/QueryBuilder.js

@@ -1,6 +1,19 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _QueryBuilder_query;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBuilder = void 0;
+const util_1 = require("util");
 const core_1 = require("@mikro-orm/core");
 const enums_1 = require("./enums");
 const QueryBuilderHelper_1 = require("./QueryBuilderHelper");
@@ -39,12 +52,13 @@ class QueryBuilder {
     /**
      * @internal
      */
-    constructor(entityName, metadata, driver, context, alias, connectionType, em) {
+    constructor(entityName, metadata, driver, context, alias, connectionType, em, logging) {
         this.metadata = metadata;
         this.driver = driver;
         this.context = context;
         this.connectionType = connectionType;
         this.em = em;
+        this.logging = logging;
         /** @internal */
         this._populate = [];
         /** @internal */
@@ -63,6 +77,7 @@ class QueryBuilder {
         this._aliases = {};
         this.platform = this.driver.getPlatform();
         this.knex = this.driver.getConnection(this.connectionType).getKnex();
+        _QueryBuilder_query.set(this, void 0);
         if (alias) {
             this.aliasCounter++;
             this._explicitAlias = true;
@@ -115,7 +130,7 @@ class QueryBuilder {
             this._fields = this.mainAlias.metadata.primaryKeys;
         }
         else {
-            this._fields = [this.raw('*')];
+            this._fields = [(0, core_1.raw)('*')];
         }
         if (distinct) {
             this.flags.add(core_1.QueryFlag.DISTINCT);
@@ -129,12 +144,12 @@ class QueryBuilder {
     leftJoin(field, alias, cond = {}) {
         return this.join(field, alias, cond, 'leftJoin');
     }
-    joinAndSelect(field, alias, cond = {}, type = 'innerJoin', path) {
+    joinAndSelect(field, alias, cond = {}, type = 'innerJoin', path, fields) {
         if (!this.type) {
             this.select('*');
         }
         const prop = this.joinReference(field, alias, cond, type, path);
-        this.addSelect(this.getFieldsForJoinedLoad(prop, alias));
+        this.addSelect(this.getFieldsForJoinedLoad(prop, alias, fields));
         const [fromAlias] = this.helper.splitField(field);
         const populate = this._joinedProps.get(fromAlias);
         const item = { field: prop.name, strategy: core_1.LoadStrategy.JOINED, children: [] };
@@ -147,13 +162,16 @@ class QueryBuilder {
         this._joinedProps.set(alias, item);
         return this;
     }
-    leftJoinAndSelect(field, alias, cond = {}) {
-        return this.joinAndSelect(field, alias, cond, 'leftJoin');
+    leftJoinAndSelect(field, alias, cond = {}, fields) {
+        return this.joinAndSelect(field, alias, cond, 'leftJoin', undefined, fields);
     }
-    getFieldsForJoinedLoad(prop, alias) {
+    innerJoinAndSelect(field, alias, cond = {}, fields) {
+        return this.joinAndSelect(field, alias, cond, 'innerJoin', undefined, fields);
+    }
+    getFieldsForJoinedLoad(prop, alias, explicitFields) {
         const fields = [];
         prop.targetMeta.props
-            .filter(prop => this.platform.shouldHaveColumn(prop, this._populate))
+            .filter(prop => explicitFields ? explicitFields.includes(prop.name) || prop.primary : this.platform.shouldHaveColumn(prop, this._populate))
             .forEach(prop => fields.push(...this.driver.mapPropToFieldNames(this, prop, alias)));
         return fields;
     }
@@ -164,9 +182,15 @@ class QueryBuilder {
     }
     where(cond, params, operator) {
         this.ensureNotFinalized();
-        if (core_1.Utils.isString(cond)) {
-            cond = { [`(${cond})`]: core_1.Utils.asArray(params) };
-            operator = operator || '$and';
+        const rawField = core_1.RawQueryFragment.getKnownFragment(cond);
+        if (rawField) {
+            const sql = this.platform.formatQuery(rawField.sql, rawField.params);
+            cond = { [(0, core_1.raw)(`(${sql})`)]: core_1.Utils.asArray(params) };
+            operator ??= '$and';
+        }
+        else if (core_1.Utils.isString(cond)) {
+            cond = { [(0, core_1.raw)(`(${cond})`, core_1.Utils.asArray(params))]: [] };
+            operator ??= '$and';
         }
         else {
             cond = core_1.QueryHelper.processWhere({
@@ -234,7 +258,7 @@ class QueryBuilder {
     having(cond = {}, params) {
         this.ensureNotFinalized();
         if (core_1.Utils.isString(cond)) {
-            cond = { [`(${cond})`]: core_1.Utils.asArray(params) };
+            cond = { [(0, core_1.raw)(`(${cond})`, params)]: [] };
         }
         this._having = CriteriaNodeFactory_1.CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond).process(this);
         return this;
@@ -262,6 +286,10 @@ class QueryBuilder {
         this._onConflict[this._onConflict.length - 1].merge = data;
         return this;
     }
+    returning(fields) {
+        this._returning = fields != null ? core_1.Utils.asArray(fields) : fields;
+        return this;
+    }
     /**
      * @internal
      */
@@ -277,11 +305,6 @@ class QueryBuilder {
     ref(field) {
         return this.knex.ref(field);
     }
-    raw(sql, bindings = []) {
-        const raw = this.knex.raw(sql, bindings);
-        raw.__raw = true; // tag it as there is now way to check via `instanceof`
-        return raw;
-    }
     limit(limit, offset = 0) {
         this.ensureNotFinalized();
         this._limit = limit;
@@ -354,13 +377,15 @@ class QueryBuilder {
     getKnexQuery() {
         this.finalize();
         const qb = this.getQueryBase();
+        qb.__raw = true; // tag it as there is now way to check via `instanceof`
         core_1.Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type ?? enums_1.QueryType.SELECT, this._cond, qb), this._cond && !this._onConflict);
         core_1.Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy')), this._groupBy);
         core_1.Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type ?? enums_1.QueryType.SELECT, this._having, qb, undefined, 'having'), this._having);
         core_1.Utils.runIfNotEmpty(() => {
             const queryOrder = this.helper.getQueryOrder(this.type ?? enums_1.QueryType.SELECT, this._orderBy, this._populateMap);
             if (queryOrder) {
-                return qb.orderByRaw(queryOrder);
+                qb.orderByRaw(queryOrder);
+                return;
             }
         }, this._orderBy);
         core_1.Utils.runIfNotEmpty(() => qb.limit(this._limit), this._limit != null);
@@ -372,26 +397,34 @@ class QueryBuilder {
         if (this.lockMode) {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables);
         }
-        this.helper.finalize(this.type ?? enums_1.QueryType.SELECT, qb, this.mainAlias.metadata);
+        this.helper.finalize(this.type ?? enums_1.QueryType.SELECT, qb, this.mainAlias.metadata, this._data, this._returning);
         return qb;
     }
     /**
      * Returns the query with parameters as wildcards.
      */
     getQuery() {
-        return this.getKnexQuery().toSQL().toNative().sql;
+        return this.toQuery().sql;
+    }
+    toQuery() {
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f")) {
+            return __classPrivateFieldGet(this, _QueryBuilder_query, "f");
+        }
+        const sql = this.getKnexQuery().toSQL();
+        const query = sql.toNative();
+        return __classPrivateFieldSet(this, _QueryBuilder_query, { sql: query.sql, params: query.bindings ?? [], _sql: sql }, "f");
     }
     /**
      * Returns the list of all parameters for this query.
      */
     getParams() {
-        return this.getKnexQuery().toSQL().toNative().bindings;
+        return this.toQuery().params;
     }
     /**
      * Returns raw interpolated query string with all the parameters inlined.
      */
     getFormattedQuery() {
-        const query = this.getKnexQuery().toSQL();
+        const query = this.toQuery()._sql;
         return this.platform.formatQuery(query.sql, query.bindings);
     }
     /**
@@ -433,7 +466,7 @@ class QueryBuilder {
             return cached.data;
         }
         const type = this.connectionType || (method === 'run' ? 'write' : 'read');
-        const res = await this.driver.getConnection(type).execute(query.sql, query.bindings, method, this.context);
+        const res = await this.driver.getConnection(type).execute(query.sql, query.bindings, method, this.context, this.logging);
         const meta = this.mainAlias.metadata;
         if (!mapResults || !meta) {
             await this.em?.storeCache(this._cache, cached, res);
@@ -464,7 +497,27 @@ class QueryBuilder {
         if (this._joinedProps.size > 0) {
             res = this.driver.mergeJoinedResult(res, this.mainAlias.metadata);
         }
-        return res.map(r => this.em.map(this.mainAlias.entityName, r, { schema: this._schema }));
+        const entities = [];
+        function propagatePopulateHint(entity, hint) {
+            (0, core_1.helper)(entity).__serializationContext.populate ??= hint;
+            hint.forEach(pop => {
+                const value = entity[pop.field];
+                if (core_1.Utils.isEntity(value, true)) {
+                    (0, core_1.helper)(value).populated();
+                    propagatePopulateHint(value, pop.children ?? []);
+                }
+                else if (core_1.Utils.isCollection(value)) {
+                    value.populated();
+                    value.getItems(false).forEach(item => propagatePopulateHint(item, pop.children ?? []));
+                }
+            });
+        }
+        for (const r of res) {
+            const entity = this.em.map(this.mainAlias.entityName, r, { schema: this._schema });
+            propagatePopulateHint(entity, this._populate);
+            entities.push(entity);
+        }
+        return entities;
     }
     /**
      * Executes the query, returning the first result or null
@@ -488,11 +541,24 @@ class QueryBuilder {
         }
         return res ? +res.count : 0;
     }
+    /**
+     * Executes the query, returning both array of results and total count query (without offset and limit).
+     */
+    async getResultAndCount() {
+        return Promise.all([
+            this.getResultList(),
+            this.getCount(),
+        ]);
+    }
     /**
      * Provides promise-like interface so we can await the QB instance.
      */
     then(onfulfilled, onrejected) {
-        switch (this.type ?? enums_1.QueryType.SELECT) {
+        let type = this.type ?? enums_1.QueryType.SELECT;
+        if (this.flags.has(core_1.QueryFlag.UPDATE_SUB_QUERY) || this.flags.has(core_1.QueryFlag.DELETE_SUB_QUERY)) {
+            type = enums_1.QueryType.UPDATE;
+        }
+        switch (type) {
             case enums_1.QueryType.INSERT:
             case enums_1.QueryType.UPDATE:
             case enums_1.QueryType.DELETE:
@@ -515,7 +581,10 @@ class QueryBuilder {
             /* istanbul ignore next */
             alias = meta?.properties[f]?.fieldNames[0] ?? alias;
         }
-        return qb.as(alias);
+        const ret = qb.as(alias);
+        // tag the instance, so it is possible to detect it easily
+        Object.defineProperty(ret, '__as', { enumerable: false, value: alias });
+        return ret;
     }
     clone() {
         const qb = new QueryBuilder(this.mainAlias.entityName, this.metadata, this.driver, this.context, this.mainAlias.aliasName, this.connectionType, this.em);
@@ -523,7 +592,7 @@ class QueryBuilder {
         // clone array/object properties
         const properties = [
             'flags', '_populate', '_populateWhere', '_populateMap', '_joins', '_joinedProps', '_cond', '_data', '_orderBy',
-            '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables',
+            '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
         ];
         properties.forEach(prop => qb[prop] = core_1.Utils.copy(this[prop]));
         /* istanbul ignore else */
@@ -554,11 +623,15 @@ class QueryBuilder {
     joinReference(field, alias, cond, type, path) {
         this.ensureNotFinalized();
         const [fromAlias, fromField] = this.helper.splitField(field);
-        const entityName = this._aliases[fromAlias]?.entityName;
+        const q = (str) => `'${str}'`;
+        if (!this._aliases[fromAlias]) {
+            throw new Error(`Trying to join ${q(fromField)} with alias ${q(fromAlias)}, but ${q(fromAlias)} is not a known alias. Available aliases are: ${Object.keys(this._aliases).map(q).join(', ')}.`);
+        }
+        const entityName = this._aliases[fromAlias].entityName;
         const meta = this.metadata.get(entityName);
         const prop = meta.properties[fromField];
         if (!prop) {
-            throw new Error(`Trying to join ${field}, but ${fromField} is not a defined relation on ${meta.className}`);
+            throw new Error(`Trying to join ${q(field)}, but ${q(fromField)} is not a defined relation on ${meta.className}.`);
         }
         this.createAlias(prop.type, alias);
         cond = core_1.QueryHelper.processWhere({
@@ -570,11 +643,11 @@ class QueryBuilder {
             aliased: !this.type || [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(this.type),
         });
         let aliasedName = `${fromAlias}.${prop.name}#${alias}`;
-        path ?? (path = `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? entityName)}.${prop.name}`);
-        if (prop.reference === core_1.ReferenceType.ONE_TO_MANY) {
+        path ??= `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? entityName)}.${prop.name}`;
+        if (prop.kind === core_1.ReferenceKind.ONE_TO_MANY) {
             this._joins[aliasedName] = this.helper.joinOneToReference(prop, fromAlias, alias, type, cond);
         }
-        else if (prop.reference === core_1.ReferenceType.MANY_TO_MANY) {
+        else if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY) {
             let pivotAlias = alias;
             if (type !== 'pivotJoin') {
                 const oldPivotAlias = this.getAliasForJoinPath(path + '[pivot]');
@@ -585,7 +658,7 @@ class QueryBuilder {
             Object.assign(this._joins, joins);
             this.createAlias(prop.pivotEntity, pivotAlias);
         }
-        else if (prop.reference === core_1.ReferenceType.ONE_TO_ONE) {
+        else if (prop.kind === core_1.ReferenceKind.ONE_TO_ONE) {
             this._joins[aliasedName] = this.helper.joinOneToReference(prop, fromAlias, alias, type, cond);
         }
         else { // MANY_TO_ONE
@@ -599,17 +672,25 @@ class QueryBuilder {
     prepareFields(fields, type = 'where') {
         const ret = [];
         fields.forEach(field => {
+            const rawField = core_1.RawQueryFragment.getKnownFragment(field);
+            if (rawField) {
+                const sql = this.platform.formatQuery(rawField.sql, rawField.params);
+                ret.push(this.knex.raw(sql));
+                return;
+            }
             if (!core_1.Utils.isString(field)) {
-                return ret.push(field);
+                ret.push(field);
+                return;
             }
             const join = Object.keys(this._joins).find(k => field === k.substring(0, k.indexOf('#')));
             if (join && type === 'where') {
-                return ret.push(...this.helper.mapJoinColumns(this.type ?? enums_1.QueryType.SELECT, this._joins[join]));
+                ret.push(...this.helper.mapJoinColumns(this.type ?? enums_1.QueryType.SELECT, this._joins[join]));
+                return;
             }
             const [a, f] = this.helper.splitField(field);
             const prop = this.helper.getProperty(f, a);
             /* istanbul ignore next */
-            if (prop && [core_1.ReferenceType.ONE_TO_MANY, core_1.ReferenceType.MANY_TO_MANY].includes(prop.reference)) {
+            if (prop && [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
                 return;
             }
             if (prop?.embedded) {
@@ -617,7 +698,7 @@ class QueryBuilder {
                 ret.push(fieldName);
                 return;
             }
-            if (prop?.reference === core_1.ReferenceType.EMBEDDED) {
+            if (prop?.kind === core_1.ReferenceKind.EMBEDDED) {
                 if (prop.object) {
                     ret.push(this.helper.mapper(prop.fieldNames[0], this.type));
                 }
@@ -640,7 +721,7 @@ class QueryBuilder {
         });
         const meta = this.mainAlias.metadata;
         /* istanbul ignore next */
-        const requiresSQLConversion = meta?.props.filter(p => p.customType?.convertToJSValueSQL) ?? [];
+        const requiresSQLConversion = meta?.props.filter(p => p.hasConvertToJSValueSQL) ?? [];
         if (this.flags.has(core_1.QueryFlag.CONVERT_CUSTOM_TYPES) && (fields.includes('*') || fields.includes(`${this.mainAlias.aliasName}.*`)) && requiresSQLConversion.length > 0) {
             requiresSQLConversion.forEach(p => ret.push(this.helper.mapper(p.name, this.type)));
         }
@@ -649,7 +730,7 @@ class QueryBuilder {
                 const cols = this.helper.mapJoinColumns(this.type ?? enums_1.QueryType.SELECT, this._joins[f]);
                 ret.push(...cols);
             }
-            if (this._joins[f].prop.reference !== core_1.ReferenceType.ONE_TO_ONE && this._joins[f].inverseJoinColumns) {
+            if (this._joins[f].prop.kind !== core_1.ReferenceKind.ONE_TO_ONE && this._joins[f].inverseJoinColumns) {
                 this._joins[f].inverseJoinColumns.forEach(inverseJoinColumn => {
                     core_1.Utils.renameKey(this._cond, inverseJoinColumn, `${this._joins[f].alias}.${inverseJoinColumn}`);
                 });
@@ -668,7 +749,7 @@ class QueryBuilder {
         }
         if (data) {
             if (core_1.Utils.isEntity(data)) {
-                data = (0, core_1.helper)(data).toJSON();
+                data = this.em?.getComparator().prepareEntity(data) ?? (0, core_1.serialize)(data);
             }
             this._data = this.helper.processData(data, this.flags.has(core_1.QueryFlag.CONVERT_CUSTOM_TYPES));
         }
@@ -722,6 +803,24 @@ class QueryBuilder {
         }
         return qb;
     }
+    applyDiscriminatorCondition() {
+        const meta = this.mainAlias.metadata;
+        if (!meta?.discriminatorValue) {
+            return;
+        }
+        const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.find(cls));
+        const children = [];
+        const lookUpChildren = (ret, type) => {
+            const children = types.filter(meta2 => meta2.extends === type);
+            children.forEach(m => lookUpChildren(ret, m.className));
+            ret.push(...children.filter(c => c.discriminatorValue));
+            return children;
+        };
+        lookUpChildren(children, meta.className);
+        this.andWhere({
+            [meta.root.discriminatorColumn]: children.length > 0 ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] } : meta.discriminatorValue,
+        });
+    }
     finalize() {
         if (this.finalized) {
             return;
@@ -730,10 +829,11 @@ class QueryBuilder {
             this.select('*');
         }
         const meta = this.mainAlias.metadata;
+        this.applyDiscriminatorCondition();
         if (meta && this.flags.has(core_1.QueryFlag.AUTO_JOIN_ONE_TO_ONE_OWNER)) {
             const relationsToPopulate = this._populate.map(({ field }) => field);
             meta.relations
-                .filter(prop => prop.reference === core_1.ReferenceType.ONE_TO_ONE && !prop.owner && !relationsToPopulate.includes(prop.name))
+                .filter(prop => prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !relationsToPopulate.includes(prop.name))
                 .map(prop => ({ field: prop.name }))
                 .forEach(item => this._populate.push(item));
         }
@@ -742,7 +842,8 @@ class QueryBuilder {
             const aliasedField = `${fromAlias}.${fromField}`;
             const join = Object.keys(this._joins).find(k => `${aliasedField}#${this._joins[k].alias}` === k);
             if (join && this._joins[join] && this.helper.isOneToOneInverse(fromField)) {
-                return this._populateMap[join] = this._joins[join].alias;
+                this._populateMap[join] = this._joins[join].alias;
+                return;
             }
             if (this.metadata.find(field)?.pivotTable) { // pivot table entity
                 this.autoJoinPivotTable(field);
@@ -763,14 +864,20 @@ class QueryBuilder {
                 const aliased = this.knex.ref(prop.fieldNames[0]).toString();
                 return `${prop.formula(alias)} as ${aliased}`;
             })
-                .filter(field => !this._fields.includes(field))
-                .forEach(field => this.addSelect(field));
+                .filter(field => !this._fields.some(f => {
+                if (f instanceof core_1.RawQueryFragment) {
+                    return f.sql === field && f.params.length === 0;
+                }
+                return f === field;
+            }))
+                .forEach(field => this._fields.push((0, core_1.raw)(field)));
         }
+        this.processPopulateWhere();
         core_1.QueryHelper.processObjectParams(this._data);
         core_1.QueryHelper.processObjectParams(this._cond);
         core_1.QueryHelper.processObjectParams(this._having);
-        // automatically enable paginate flag when we detect to-many joins
-        if (!this.flags.has(core_1.QueryFlag.DISABLE_PAGINATE) && this.hasToManyJoins()) {
+        // automatically enable paginate flag when we detect to-many joins, but only if there is no `group by` clause
+        if (!this.flags.has(core_1.QueryFlag.DISABLE_PAGINATE) && this._groupBy.length === 0 && this.hasToManyJoins()) {
             this.flags.add(core_1.QueryFlag.PAGINATE);
         }
         if (meta && this.flags.has(core_1.QueryFlag.PAGINATE) && (this._limit > 0 || this._offset > 0)) {
@@ -781,17 +888,54 @@ class QueryBuilder {
         }
         this.finalized = true;
     }
+    processPopulateWhere() {
+        if (this._populateWhere == null || this._populateWhere === core_1.PopulateHint.ALL) {
+            return;
+        }
+        const joins = Object.values(this._joins);
+        joins.forEach(join => {
+            join.cond_ = join.cond;
+            join.cond = {};
+        });
+        const replaceOnConditions = (cond) => {
+            Object.keys(cond).forEach(k => {
+                if (core_1.Utils.isOperator(k)) {
+                    if (Array.isArray(cond[k])) {
+                        return cond[k].forEach((c) => replaceOnConditions(c));
+                    }
+                    return replaceOnConditions(cond[k]);
+                }
+                const [a] = this.helper.splitField(k);
+                const join = joins.find(j => j.alias === a);
+                if (join) {
+                    join.cond = { ...join.cond, [k]: cond[k] };
+                }
+            });
+        };
+        if (this._populateWhere === core_1.PopulateHint.INFER) {
+            replaceOnConditions(this._cond);
+        }
+        else if (typeof this._populateWhere === 'object') {
+            const cond = CriteriaNodeFactory_1.CriteriaNodeFactory
+                .createNode(this.metadata, this.mainAlias.entityName, this._populateWhere)
+                .process(this);
+            replaceOnConditions(cond);
+        }
+    }
     hasToManyJoins() {
         return Object.values(this._joins).some(join => {
-            return [core_1.ReferenceType.ONE_TO_MANY, core_1.ReferenceType.MANY_TO_MANY].includes(join.prop.reference);
+            return [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(join.prop.kind);
         });
     }
     wrapPaginateSubQuery(meta) {
         const pks = this.prepareFields(meta.primaryKeys, 'sub-query');
         const subQuery = this.clone().select(pks).groupBy(pks).limit(this._limit);
+        // revert the on conditions added via populateWhere, we want to apply those only once
+        Object.values(subQuery._joins).forEach(join => join.cond = join.cond_ ?? {});
         if (this._offset) {
             subQuery.offset(this._offset);
         }
+        const addToSelect = [];
         if (this._orderBy.length > 0) {
             const orderBy = [];
             for (const orderMap of this._orderBy) {
@@ -799,28 +943,38 @@ class QueryBuilder {
                     const [a, f] = this.helper.splitField(field);
                     const prop = this.helper.getProperty(f, a);
                     const type = this.platform.castColumn(prop);
-                    orderBy.push({
-                        [`min(${this.ref(this.helper.mapper(field, this.type, undefined, null))}${type})`]: direction,
-                    });
+                    const fieldName = this.helper.mapper(field, this.type, undefined, null);
+                    if (!prop?.persist && !prop?.formula) {
+                        addToSelect.push(fieldName);
+                    }
+                    orderBy.push({ [(0, core_1.raw)(`min(${this.ref(fieldName)}${type})`)]: direction });
                 }
             }
             subQuery.orderBy(orderBy);
         }
         subQuery.finalized = true;
         const knexQuery = subQuery.as(this.mainAlias.aliasName).clearSelect().select(pks);
+        if (addToSelect.length > 0) {
+            addToSelect.forEach(prop => {
+                const field = this._fields.find(field => {
+                    if (typeof field === 'object' && field && '__as' in field) {
+                        return field.__as === prop;
+                    }
+                    // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
+                    return field.toString().includes(prop);
+                });
+                if (field) {
+                    knexQuery.select(field);
+                }
+            });
+        }
         // multiple sub-queries are needed to get around mysql limitations with order by + limit + where in + group by (o.O)
         // https://stackoverflow.com/questions/17892762/mysql-this-version-of-mysql-doesnt-yet-support-limit-in-all-any-some-subqu
         const subSubQuery = this.getKnex().select(pks).from(knexQuery);
+        subSubQuery.__raw = true; // tag it as there is now way to check via `instanceof`
         this._limit = undefined;
         this._offset = undefined;
-        const cond = this._cond;
         this.select(this._fields).where({ [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: subSubQuery } });
-        if (this._populateWhere === core_1.PopulateHint.INFER) {
-            this.andWhere(cond);
-        }
-        else if (typeof this._populateWhere === 'object') {
-            this.andWhere(this._populateWhere);
-        }
     }
     wrapModifySubQuery(meta) {
         const subQuery = this.clone();
@@ -841,8 +995,8 @@ class QueryBuilder {
         const prop = this._cond[pivotMeta.name + '.' + owner.name] || this._orderBy[pivotMeta.name + '.' + owner.name] ? inverse : owner;
         const pivotAlias = this.getNextAlias(pivotMeta.name);
         this._joins[field] = this.helper.joinPivotTable(field, prop, this.mainAlias.aliasName, pivotAlias, 'leftJoin');
-        core_1.Utils.renameKey(this._cond, `${field}.${owner.name}`, core_1.Utils.getPrimaryKeyHash(owner.fieldNames.map(fieldName => `${pivotAlias}.${fieldName}`)));
-        core_1.Utils.renameKey(this._cond, `${field}.${inverse.name}`, core_1.Utils.getPrimaryKeyHash(inverse.fieldNames.map(fieldName => `${pivotAlias}.${fieldName}`)));
+        core_1.Utils.renameKey(this._cond, `${field}.${owner.name}`, core_1.Utils.getPrimaryKeyHash(owner.fieldNames.map(fieldName => `${pivotAlias}.${fieldName}`)), true);
+        core_1.Utils.renameKey(this._cond, `${field}.${inverse.name}`, core_1.Utils.getPrimaryKeyHash(inverse.fieldNames.map(fieldName => `${pivotAlias}.${fieldName}`)), true);
         this._populateMap[field] = this._joins[field].alias;
     }
     getSchema(alias) {
@@ -864,11 +1018,11 @@ class QueryBuilder {
     fromSubQuery(target, aliasName) {
         const subQuery = target.getKnexQuery();
         const { entityName } = target.mainAlias;
-        aliasName ?? (aliasName = this.getNextAlias(entityName));
+        aliasName ??= this.getNextAlias(entityName);
         this.createMainAlias(entityName, aliasName, subQuery);
     }
     fromEntityName(entityName, aliasName) {
-        aliasName ?? (aliasName = this._mainAlias?.aliasName ?? this.getNextAlias(entityName));
+        aliasName ??= this._mainAlias?.aliasName ?? this.getNextAlias(entityName);
         this.createMainAlias(entityName, aliasName);
     }
     createQueryBuilderHelper() {
@@ -885,5 +1039,27 @@ class QueryBuilder {
             throw new Error('This QueryBuilder instance is already finalized, clone it first if you want to modify it.');
         }
     }
+    /* istanbul ignore next */
+    [(_QueryBuilder_query = new WeakMap(), util_1.inspect.custom)](depth) {
+        const object = { ...this };
+        const hidden = ['metadata', 'driver', 'context', 'platform', 'knex', 'type'];
+        Object.keys(object).filter(k => k.startsWith('_')).forEach(k => delete object[k]);
+        Object.keys(object).filter(k => object[k] == null).forEach(k => delete object[k]);
+        hidden.forEach(k => delete object[k]);
+        let prefix = this.type ? this.type.substring(0, 1) + this.type.toLowerCase().substring(1) : '';
+        if (this._data) {
+            object.data = this._data;
+        }
+        if (!core_1.Utils.isEmpty(this._cond)) {
+            object.where = this._cond;
+        }
+        if (this._onConflict?.[0]) {
+            prefix = 'Upsert';
+            object.onConflict = this._onConflict[0];
+        }
+        const name = this._mainAlias ? `${prefix}QueryBuilder<${this._mainAlias?.entityName}>` : 'QueryBuilder';
+        const ret = (0, util_1.inspect)(object, { depth });
+        return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
+    }
 }
 exports.QueryBuilder = QueryBuilder;

package/query/QueryBuilderHelper.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { Dictionary, EntityData, EntityMetadata, EntityProperty, FlatQueryOrderMap, QBFilterQuery } from '@mikro-orm/core';
+import type { Dictionary, EntityData, EntityKey, EntityMetadata, EntityProperty, FlatQueryOrderMap, QBFilterQuery } from '@mikro-orm/core';
 import { LockMode } from '@mikro-orm/core';
 import { QueryType } from './enums';
 import type { Field, JoinOptions } from '../typings';
@@ -43,16 +43,14 @@ export declare class QueryBuilderHelper {
     }[], qb: Knex.QueryBuilder): void;
     appendQueryCondition(type: QueryType, cond: any, qb: Knex.QueryBuilder, operator?: '$and' | '$or', method?: 'where' | 'having'): void;
     private appendQuerySubCondition;
-    private processCustomExpression;
     private processObjectSubCondition;
     private getOperatorReplacement;
     getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string;
     getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string;
-    finalize(type: QueryType, qb: Knex.QueryBuilder, meta?: EntityMetadata): void;
-    splitField(field: string, greedyAlias?: boolean): [string, string];
+    finalize(type: QueryType, qb: Knex.QueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
+    splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>];
     getLockSQL(qb: Knex.QueryBuilder, lockMode: LockMode, lockTables?: string[]): void;
     updateVersionProperty(qb: Knex.QueryBuilder, data: Dictionary): void;
-    static isCustomExpression(field: string, hasAlias?: boolean): boolean;
     private prefix;
     private appendGroupCondition;
     private isPrefixed;