@mikro-orm/sql 7.0.0-dev.113 → 7.0.0-dev.115

package/query/QueryBuilder.js

@@ -1,4 +1,4 @@
-import { helper, isRaw, LoadStrategy, LockMode, PopulateHint, QueryFlag, QueryHelper, raw, RawQueryFragment, Reference, ReferenceKind, serialize, Utils, ValidationError, inspect, } from '@mikro-orm/core';
+import { helper, inspect, isRaw, LoadStrategy, LockMode, PopulateHint, QueryFlag, QueryHelper, raw, RawQueryFragment, Reference, ReferenceKind, serialize, Utils, ValidationError, } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import { QueryBuilderHelper } from './QueryBuilderHelper.js';
 import { CriteriaNodeFactory } from './CriteriaNodeFactory.js';
@@ -47,8 +47,6 @@ export class QueryBuilder {
     _populate = [];
     /** @internal */
     _populateMap = {};
-    /** @internal */
-    rawFragments = new Set();
     aliasCounter = 0;
     flags = new Set([QueryFlag.CONVERT_CUSTOM_TYPES]);
     finalized = false;
@@ -140,7 +138,7 @@ export class QueryBuilder {
             this._fields = Utils.asArray(field);
         }
         else if (distinct || this.hasToManyJoins()) {
-            this._fields = this.mainAlias.metadata.primaryKeys;
+            this._fields = this.mainAlias.meta.primaryKeys;
         }
         else {
             this._fields = [raw('*')];
@@ -276,15 +274,15 @@ export class QueryBuilder {
                 continue;
             }
             filterOptions = QueryHelper.mergePropertyFilters(join.prop.filters, filterOptions);
-            const cond = await em.applyFilters(join.prop.type, join.cond, filterOptions, 'read');
-            if (Utils.hasObjectKeys(cond)) {
+            const cond = await em.applyFilters(join.prop.targetMeta.class, join.cond, filterOptions, 'read');
+            if (Utils.hasObjectKeys(cond) || RawQueryFragment.hasObjectFragments(cond)) {
                 // remove nested filters, we only care about scalars here, nesting would require another join branch
                 for (const key of Object.keys(cond)) {
                     if (Utils.isPlainObject(cond[key]) && Object.keys(cond[key]).every(k => !(Utils.isOperator(k) && !['$some', '$none', '$every'].includes(k)))) {
                         delete cond[key];
                     }
                 }
-                if (Utils.hasObjectKeys(join.cond)) {
+                if (Utils.hasObjectKeys(join.cond) || RawQueryFragment.hasObjectFragments(join.cond)) {
                     /* v8 ignore next */
                     join.cond = { $and: [join.cond, cond] };
                 }
@@ -296,7 +294,7 @@ export class QueryBuilder {
     }
     withSubQuery(subQuery, alias) {
         this.ensureNotFinalized();
-        if (subQuery instanceof RawQueryFragment) {
+        if (isRaw(subQuery)) {
             this.subQueries[alias] = this.platform.formatQuery(subQuery.sql, subQuery.params);
         }
         else {
@@ -306,9 +304,8 @@ export class QueryBuilder {
     }
     where(cond, params, operator) {
         this.ensureNotFinalized();
-        const rawField = RawQueryFragment.getKnownFragment(cond);
-        if (rawField) {
-            const sql = this.platform.formatQuery(rawField.sql, rawField.params);
+        if (isRaw(cond)) {
+            const sql = this.platform.formatQuery(cond.sql, cond.params);
             cond = { [raw(`(${sql})`)]: Utils.asArray(params) };
             operator ??= '$and';
         }
@@ -328,13 +325,13 @@ export class QueryBuilder {
             });
         }
         const op = operator || params;
-        const topLevel = !op || !Utils.hasObjectKeys(this._cond);
+        const topLevel = !op || !(Utils.hasObjectKeys(this._cond) || RawQueryFragment.hasObjectFragments(this._cond));
         const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond);
         const ignoreBranching = this.__populateWhere === 'infer';
         if ([QueryType.UPDATE, QueryType.DELETE].includes(this.type) && criteriaNode.willAutoJoin(this, undefined, { ignoreBranching })) {
             // use sub-query to support joining
             this.setFlag(this.type === QueryType.UPDATE ? QueryFlag.UPDATE_SUB_QUERY : QueryFlag.DELETE_SUB_QUERY);
-            this.select(this.mainAlias.metadata.primaryKeys, true);
+            this.select(this.mainAlias.meta.primaryKeys, true);
         }
         if (topLevel) {
             this._cond = criteriaNode.process(this, { ignoreBranching });
@@ -370,6 +367,7 @@ export class QueryBuilder {
             this._orderBy = [];
         }
         Utils.asArray(orderBy).forEach(o => {
+            this.helper.validateQueryOrder(o);
             const processed = QueryHelper.processWhere({
                 where: o,
                 entityName: this.mainAlias.entityName,
@@ -381,6 +379,7 @@ export class QueryBuilder {
                 type: 'orderBy',
             });
             this._orderBy.push(CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processed).process(this, { matchPopulateJoins: true, type: 'orderBy' }));
+            // this._orderBy.push(CriteriaNodeFactory.createNode<Entity>(this.metadata, Utils.className(this.mainAlias.entityName), processed).process(this, { matchPopulateJoins: true, type: 'orderBy' }));
         });
         return this;
     }
@@ -411,7 +410,7 @@ export class QueryBuilder {
         return this.having(cond, params, '$or');
     }
     onConflict(fields = []) {
-        const meta = this.mainAlias.metadata;
+        const meta = this.mainAlias.meta;
         this.ensureNotFinalized();
         this._onConflict ??= [];
         this._onConflict.push({
@@ -538,11 +537,10 @@ export class QueryBuilder {
             this.fromSubQuery(target, aliasName);
         }
         else {
-            const entityName = Utils.className(target);
-            if (aliasName && this._mainAlias && entityName !== this._mainAlias.aliasName) {
+            if (aliasName && this._mainAlias && Utils.className(target) !== this._mainAlias.aliasName) {
                 throw new Error(`Cannot override the alias to '${aliasName}' since a query already contains references to '${this._mainAlias.aliasName}'`);
             }
-            this.fromEntityName(entityName, aliasName);
+            this.fromEntityName(target, aliasName);
         }
         return this;
     }
@@ -553,9 +551,10 @@ export class QueryBuilder {
         this._query = {};
         this.finalize();
         const qb = this.getQueryBase(processVirtualEntity);
+        const isNotEmptyObject = (obj) => Utils.hasObjectKeys(obj) || RawQueryFragment.hasObjectFragments(obj);
         Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._cond, qb), this._cond && !this._onConflict);
-        Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy')), this._groupBy);
-        Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._having, qb, undefined, 'having'), this._having);
+        Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy')), isNotEmptyObject(this._groupBy));
+        Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._having, qb, undefined, 'having'), isNotEmptyObject(this._having));
         Utils.runIfNotEmpty(() => {
             const queryOrder = this.helper.getQueryOrder(this.type, this._orderBy, this._populateMap);
             if (queryOrder.length > 0) {
@@ -563,7 +562,7 @@ export class QueryBuilder {
                 qb.orderBy(sql);
                 return;
             }
-        }, this._orderBy);
+        }, isNotEmptyObject(this._orderBy));
         Utils.runIfNotEmpty(() => qb.limit(this._limit), this._limit != null);
         Utils.runIfNotEmpty(() => qb.offset(this._offset), this._offset);
         Utils.runIfNotEmpty(() => qb.comment(this._comments), this._comments);
@@ -572,17 +571,9 @@ export class QueryBuilder {
         if (this.lockMode) {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables, this._joins);
         }
-        this.helper.finalize(this.type, qb, this.mainAlias.metadata, this._data, this._returning);
-        this.clearRawFragmentsCache();
+        this.helper.finalize(this.type, qb, this.mainAlias.meta, this._data, this._returning);
         return this._query.qb = qb;
     }
-    /**
-     * @internal
-     */
-    clearRawFragmentsCache() {
-        this.rawFragments.forEach(key => RawQueryFragment.remove(key));
-        this.rawFragments.clear();
-    }
     /**
      * Returns the query with parameters as wildcards.
      */
@@ -622,7 +613,7 @@ export class QueryBuilder {
      * @internal
      */
     getAliasForJoinPath(path, options) {
-        if (!path || path === this.mainAlias.entityName) {
+        if (!path || path === Utils.className(this.mainAlias.entityName)) {
             return this.mainAlias.aliasName;
         }
         const join = typeof path === 'string' ? this.getJoinForPath(path, options) : path;
@@ -666,6 +657,7 @@ export class QueryBuilder {
      * @internal
      */
     getNextAlias(entityName = 'e') {
+        entityName = Utils.className(entityName);
         return this.driver.config.getNamingStrategy().aliasName(entityName, this.aliasCounter++);
     }
     /**
@@ -697,7 +689,7 @@ export class QueryBuilder {
         }
         const loggerContext = { id: this.em?.id, ...this.loggerContext };
         const res = await this.getConnection().execute(query.sql, query.params, method, this.context, loggerContext);
-        const meta = this.mainAlias.metadata;
+        const meta = this.mainAlias.meta;
         if (!options.mapResults || !meta) {
             await this.em?.storeCache(this._cache, cached, res);
             return res;
@@ -711,7 +703,7 @@ export class QueryBuilder {
             const map = {};
             mapped = res.map(r => this.driver.mapResult(r, meta, this._populate, this, map));
             if (options.mergeResults && joinedProps.length > 0) {
-                mapped = this.driver.mergeJoinedResult(mapped, this.mainAlias.metadata, joinedProps);
+                mapped = this.driver.mergeJoinedResult(mapped, this.mainAlias.meta, joinedProps);
             }
         }
         else {
@@ -752,7 +744,7 @@ export class QueryBuilder {
         const query = this.toQuery();
         const loggerContext = { id: this.em?.id, ...this.loggerContext };
         const res = this.getConnection().stream(query.sql, query.params, this.context, loggerContext);
-        const meta = this.mainAlias.metadata;
+        const meta = this.mainAlias.meta;
         if (options.rawResults || !meta) {
             yield* res;
             return;
@@ -769,7 +761,7 @@ export class QueryBuilder {
                 continue;
             }
             if (stack.length > 0 && hash(stack[stack.length - 1]) !== hash(mapped)) {
-                const res = this.driver.mergeJoinedResult(stack, this.mainAlias.metadata, joinedProps);
+                const res = this.driver.mergeJoinedResult(stack, this.mainAlias.meta, joinedProps);
                 for (const row of res) {
                     yield this.mapResult(row, options.mapResults);
                 }
@@ -778,7 +770,7 @@ export class QueryBuilder {
             stack.push(mapped);
         }
         if (stack.length > 0) {
-            const merged = this.driver.mergeJoinedResult(stack, this.mainAlias.metadata, joinedProps);
+            const merged = this.driver.mergeJoinedResult(stack, this.mainAlias.meta, joinedProps);
             yield this.mapResult(merged[0], options.mapResults);
         }
     }
@@ -865,21 +857,21 @@ export class QueryBuilder {
             await this.clone().getCount(),
         ];
     }
-    /**
-     * Returns native query builder instance with sub-query aliased with given alias.
-     * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
-     */
-    as(alias) {
+    as(aliasOrTargetEntity, alias) {
         const qb = this.getNativeQuery();
-        if (alias.includes('.')) {
-            const [a, f] = alias.split('.');
-            const meta = this.metadata.find(a);
+        let finalAlias = aliasOrTargetEntity;
+        /* v8 ignore next */
+        if (typeof aliasOrTargetEntity === 'string' && aliasOrTargetEntity.includes('.')) {
+            throw new Error('qb.as(alias) no longer supports target entity name prefix, use qb.as(TargetEntity, key) signature instead');
+        }
+        if (alias) {
+            const meta = this.metadata.get(aliasOrTargetEntity);
             /* v8 ignore next */
-            alias = meta?.properties[f]?.fieldNames[0] ?? alias;
+            finalAlias = meta.properties[alias]?.fieldNames[0] ?? alias;
         }
-        qb.as(alias);
+        qb.as(finalAlias);
         // tag the instance, so it is possible to detect it easily
-        Object.defineProperty(qb, '__as', { enumerable: false, value: alias });
+        Object.defineProperty(qb, '__as', { enumerable: false, value: finalAlias });
         return qb;
     }
     clone(reset) {
@@ -892,16 +884,14 @@ export class QueryBuilder {
         const properties = [
             'flags', '_populate', '_populateWhere', '_populateFilter', '__populateWhere', '_populateMap', '_joins', '_joinedProps', '_cond', '_data', '_orderBy',
             '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
-            '_comments', '_hintComments', 'rawFragments', 'aliasCounter',
+            '_comments', '_hintComments', 'aliasCounter',
         ];
-        RawQueryFragment.cloneRegistry = this.rawFragments;
         for (const prop of Object.keys(this)) {
             if (reset.includes(prop) || ['_helper', '_query'].includes(prop)) {
                 continue;
             }
             qb[prop] = properties.includes(prop) ? Utils.copy(this[prop]) : this[prop];
         }
-        delete RawQueryFragment.cloneRegistry;
         /* v8 ignore next */
         if (this._fields && !reset.includes('_fields')) {
             qb._fields = [...this._fields];
@@ -935,7 +925,7 @@ export class QueryBuilder {
         if (res instanceof QueryBuilder) {
             return `(${res.getFormattedQuery()}) as ${this.platform.quoteIdentifier(this.alias)}`;
         }
-        if (res instanceof RawQueryFragment) {
+        if (isRaw(res)) {
             const query = this.platform.formatQuery(res.sql, res.params);
             return `(${query}) as ${this.platform.quoteIdentifier(this.alias)}`;
         }
@@ -950,11 +940,11 @@ export class QueryBuilder {
                 kind: ReferenceKind.MANY_TO_ONE,
             };
             if (field instanceof QueryBuilder) {
-                prop.type = field.mainAlias.entityName;
-                prop.targetMeta = field.mainAlias.metadata;
+                prop.type = Utils.className(field.mainAlias.entityName);
+                prop.targetMeta = field.mainAlias.meta;
                 field = field.getNativeQuery();
             }
-            if (field instanceof RawQueryFragment) {
+            if (isRaw(field)) {
                 field = this.platform.formatQuery(field.sql, field.params);
             }
             const key = `${this.alias}.${prop.name}#${alias}`;
@@ -983,7 +973,7 @@ export class QueryBuilder {
         if (!prop) {
             throw new Error(`Trying to join ${q(field)}, but ${q(fromField)} is not a defined relation on ${meta.className}.`);
         }
-        this.createAlias(prop.type, alias);
+        this.createAlias(prop.targetMeta.class, alias);
         cond = QueryHelper.processWhere({
             where: cond,
             entityName: this.mainAlias.entityName,
@@ -992,10 +982,10 @@ export class QueryBuilder {
             aliasMap: this.getAliasMap(),
             aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
         });
-        const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, prop.targetMeta.className, cond);
+        const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, prop.targetMeta.class, cond);
         cond = criteriaNode.process(this, { ignoreBranching: true, alias });
         let aliasedName = `${fromAlias}.${prop.name}#${alias}`;
-        path ??= `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? entityName)}.${prop.name}`;
+        path ??= `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? Utils.className(entityName))}.${prop.name}`;
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {
             this._joins[aliasedName] = this.helper.joinOneToReference(prop, fromAlias, alias, type, cond, schema);
             this._joins[aliasedName].path ??= path;
@@ -1029,11 +1019,6 @@ export class QueryBuilder {
             return this.helper.mapper(name, this.type, undefined, type === 'groupBy' ? null : undefined);
         };
         fields.forEach(field => {
-            const rawField = RawQueryFragment.getKnownFragment(field, false);
-            if (rawField) {
-                ret.push(rawField);
-                return;
-            }
             if (typeof field !== 'string') {
                 ret.push(field);
                 return;
@@ -1078,9 +1063,7 @@ export class QueryBuilder {
             }
             ret.push(getFieldName(field));
         });
-        const meta = this.mainAlias.metadata;
-        /* v8 ignore next */
-        const requiresSQLConversion = meta?.props.filter(p => p.hasConvertToJSValueSQL && p.persist !== false) ?? [];
+        const requiresSQLConversion = this.mainAlias.meta.props.filter(p => p.hasConvertToJSValueSQL && p.persist !== false);
         if (this.flags.has(QueryFlag.CONVERT_CUSTOM_TYPES) && (fields.includes('*') || fields.includes(`${this.mainAlias.aliasName}.*`)) && requiresSQLConversion.length > 0) {
             for (const p of requiresSQLConversion) {
                 ret.push(this.helper.mapper(p.name, this.type));
@@ -1088,10 +1071,7 @@ export class QueryBuilder {
         }
         for (const f of Object.keys(this._populateMap)) {
             if (type === 'where' && this._joins[f]) {
-                const cols = this.helper.mapJoinColumns(this.type, this._joins[f]);
-                for (const col of cols) {
-                    ret.push(col);
-                }
+                ret.push(...this.helper.mapJoinColumns(this.type, this._joins[f]));
             }
         }
         return Utils.unique(ret);
@@ -1118,14 +1098,14 @@ export class QueryBuilder {
     }
     getQueryBase(processVirtualEntity) {
         const qb = this.platform.createNativeQueryBuilder().setFlags(this.flags);
-        const { subQuery, aliasName, entityName, metadata } = this.mainAlias;
+        const { subQuery, aliasName, entityName, meta } = this.mainAlias;
         const requiresAlias = this.finalized && (this._explicitAlias || this.helper.isTableNameAliasRequired(this.type));
         const alias = requiresAlias ? aliasName : undefined;
         const schema = this.getSchema(this.mainAlias);
         const tableName = subQuery ? subQuery.as(aliasName) : this.helper.getTableName(entityName);
         const joinSchema = this._schema ?? this.em?.schema ?? schema;
-        if (metadata?.virtual && processVirtualEntity) {
-            qb.from(raw(this.fromVirtual(metadata)), { indexHint: this._indexHint });
+        if (meta.virtual && processVirtualEntity) {
+            qb.from(raw(this.fromVirtual(meta)), { indexHint: this._indexHint });
         }
         else {
             qb.from(tableName, {
@@ -1169,19 +1149,19 @@ export class QueryBuilder {
         return qb;
     }
     applyDiscriminatorCondition() {
-        const meta = this.mainAlias.metadata;
-        if (!meta?.discriminatorValue) {
+        const meta = this.mainAlias.meta;
+        if (!meta.discriminatorValue) {
             return;
         }
-        const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.find(cls));
+        const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.get(cls));
         const children = [];
         const lookUpChildren = (ret, type) => {
             const children = types.filter(meta2 => meta2.extends === type);
-            children.forEach(m => lookUpChildren(ret, m.className));
+            children.forEach(m => lookUpChildren(ret, m.class));
             ret.push(...children.filter(c => c.discriminatorValue));
             return children;
         };
-        lookUpChildren(children, meta.className);
+        lookUpChildren(children, meta.class);
         this.andWhere({
             [meta.root.discriminatorColumn]: children.length > 0 ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] } : meta.discriminatorValue,
         });
@@ -1193,7 +1173,7 @@ export class QueryBuilder {
         if (!this._type) {
             this.select('*');
         }
-        const meta = this.mainAlias.metadata;
+        const meta = this.mainAlias.meta;
         this.applyDiscriminatorCondition();
         this.processPopulateHint();
         this.processNestedJoins();
@@ -1206,7 +1186,7 @@ export class QueryBuilder {
                 return `${prop.formula(alias)} as ${aliased}`;
             })
                 .filter(field => !this._fields.some(f => {
-                if (f instanceof RawQueryFragment) {
+                if (isRaw(f)) {
                     return f.sql === field && f.params.length === 0;
                 }
                 return f === field;
@@ -1233,7 +1213,7 @@ export class QueryBuilder {
         if (this.populateHintFinalized) {
             return;
         }
-        const meta = this.mainAlias.metadata;
+        const meta = this.mainAlias.meta;
         if (meta && this.flags.has(QueryFlag.AUTO_JOIN_ONE_TO_ONE_OWNER)) {
             const relationsToPopulate = this._populate.map(({ field }) => field);
             meta.relations
@@ -1251,12 +1231,12 @@ export class QueryBuilder {
             }
             if (meta && this.helper.isOneToOneInverse(fromField)) {
                 const prop = meta.properties[fromField];
-                const alias = this.getNextAlias(prop.pivotEntity ?? prop.type);
+                const alias = this.getNextAlias(prop.pivotEntity ?? prop.targetMeta.class);
                 const aliasedName = `${fromAlias}.${prop.name}#${alias}`;
                 this._joins[aliasedName] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, JoinType.leftJoin);
                 this._joins[aliasedName].path = `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? meta.className)}.${prop.name}`;
                 this._populateMap[aliasedName] = this._joins[aliasedName].alias;
-                this.createAlias(prop.type, alias);
+                this.createAlias(prop.targetMeta.class, alias);
             }
         });
         this.processPopulateWhere(false);
@@ -1372,11 +1352,10 @@ export class QueryBuilder {
         if (this._orderBy.length > 0) {
             const orderBy = [];
             for (const orderMap of this._orderBy) {
-                for (const [field, direction] of Object.entries(orderMap)) {
-                    if (RawQueryFragment.isKnownFragment(field)) {
-                        const rawField = RawQueryFragment.getKnownFragment(field, false);
-                        this.rawFragments.add(field);
-                        orderBy.push({ [rawField.clone()]: direction });
+                for (const field of Utils.getObjectQueryKeys(orderMap)) {
+                    const direction = orderMap[field];
+                    if (RawQueryFragment.isKnownFragmentSymbol(field)) {
+                        orderBy.push({ [field]: direction });
                         continue;
                     }
                     const [a, f] = this.helper.splitField(field);
@@ -1401,14 +1380,14 @@ export class QueryBuilder {
                     if (typeof field === 'object' && field && '__as' in field) {
                         return field.__as === prop;
                     }
-                    if (field instanceof RawQueryFragment) {
+                    if (isRaw(field)) {
                         // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
                         return field.sql.includes(prop);
                     }
                     return false;
                 });
                 /* v8 ignore next */
-                if (field instanceof RawQueryFragment) {
+                if (isRaw(field)) {
                     innerQuery.select(field);
                 }
                 else if (field instanceof NativeQueryBuilder) {
@@ -1425,7 +1404,7 @@ export class QueryBuilder {
         subSubQuery.select(pks).from(innerQuery);
         this._limit = undefined;
         this._offset = undefined;
-        if (!this._fields.some(f => RawQueryFragment.isKnownFragment(f))) {
+        if (!this._fields.some(field => isRaw(field))) {
             this.pruneExtraJoins(meta);
         }
         const { sql, params } = subSubQuery.compile();
@@ -1483,8 +1462,8 @@ export class QueryBuilder {
         });
     }
     getSchema(alias) {
-        const { metadata } = alias;
-        const metaSchema = metadata?.schema && metadata.schema !== '*' ? metadata.schema : undefined;
+        const { meta } = alias;
+        const metaSchema = meta.schema && meta.schema !== '*' ? meta.schema : undefined;
         const schema = this._schema ?? metaSchema ?? this.em?.schema ?? this.em?.config.getSchema(true);
         if (schema === this.platform.getDefaultSchemaName()) {
             return undefined;
@@ -1492,8 +1471,8 @@ export class QueryBuilder {
         return schema;
     }
     createAlias(entityName, aliasName, subQuery) {
-        const metadata = this.metadata.find(entityName);
-        const alias = { aliasName, entityName, metadata, subQuery };
+        const meta = this.metadata.find(entityName);
+        const alias = { aliasName, entityName, meta, subQuery };
         this._aliases[aliasName] = alias;
         return alias;
     }
@@ -1551,7 +1530,7 @@ export class QueryBuilder {
         if (!Utils.isEmpty(this._orderBy)) {
             object.orderBy = this._orderBy;
         }
-        const name = this._mainAlias ? `${prefix}QueryBuilder<${this._mainAlias?.entityName}>` : 'QueryBuilder';
+        const name = this._mainAlias ? `${prefix}QueryBuilder<${Utils.className(this._mainAlias?.entityName)}>` : 'QueryBuilder';
         const ret = inspect(object, { depth });
         return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
     }

package/query/QueryBuilderHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, RawQueryFragment } from '@mikro-orm/core';
+import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, type QBQueryOrderMap, Raw, type RawQueryFragmentSymbol } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import type { Field, JoinOptions } from '../typings.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
@@ -14,9 +14,9 @@ export declare class QueryBuilderHelper {
     private readonly driver;
     private readonly platform;
     private readonly metadata;
-    constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, driver: AbstractSqlDriver);
-    mapper(field: string | RawQueryFragment, type?: QueryType): string;
-    mapper(field: string | RawQueryFragment, type?: QueryType, value?: any, alias?: string | null): string;
+    constructor(entityName: EntityName, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, driver: AbstractSqlDriver);
+    mapper(field: string | Raw | RawQueryFragmentSymbol, type?: QueryType): string;
+    mapper(field: string | Raw | RawQueryFragmentSymbol, type?: QueryType, value?: any, alias?: string | null): string;
     processData(data: Dictionary, convertCustomTypes: boolean, multi?: boolean): any;
     joinOneToReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
     joinManyToOneReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
@@ -26,9 +26,9 @@ export declare class QueryBuilderHelper {
         sql: string;
         params: unknown[];
     };
-    mapJoinColumns(type: QueryType, join: JoinOptions): (string | RawQueryFragment)[];
+    mapJoinColumns(type: QueryType, join: JoinOptions): (string | Raw)[];
     isOneToOneInverse(field: string, meta?: EntityMetadata): boolean;
-    getTableName(entityName: string): string;
+    getTableName(entityName: EntityName): string;
     /**
      * Checks whether the RE can be rewritten to simple LIKE query
      */
@@ -45,6 +45,7 @@ export declare class QueryBuilderHelper {
     private processObjectSubCondition;
     private getValueReplacement;
     private getOperatorReplacement;
+    validateQueryOrder<T>(orderBy: QBQueryOrderMap<T>): void;
     getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string[];
     getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string[];
     finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
@@ -61,12 +62,12 @@ export declare class QueryBuilderHelper {
 }
 export interface Alias<T> {
     aliasName: string;
-    entityName: string;
-    metadata?: EntityMetadata<T>;
+    entityName: EntityName<T>;
+    meta: EntityMetadata<T>;
     subQuery?: NativeQueryBuilder;
 }
 export interface OnConflictClause<T> {
-    fields: string[] | RawQueryFragment;
+    fields: string[] | Raw;
     ignore?: boolean;
     merge?: EntityData<T> | Field<T>[];
     where?: QBFilterQuery<T>;