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

package/AbstractSqlDriver.d.ts

@@ -15,23 +15,23 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     getPlatform(): Platform;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
     private createQueryBuilderFromOptions;
-    find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: ObjectQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
-    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: ObjectQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: EntityName<T>, where: ObjectQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: EntityName<T>, where: ObjectQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     protected hasToManyJoins<T extends object>(hint: PopulateOptions<T>, meta: EntityMetadata<T>): boolean;
-    findVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
-    countVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: CountOptions<T, any>): Promise<number>;
-    protected findFromVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    countVirtual<T extends object>(entityName: EntityName<T>, where: ObjectQuery<T>, options: CountOptions<T, any>): Promise<number>;
+    protected findFromVirtual<T extends object>(entityName: EntityName<T>, where: ObjectQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
     protected streamFromVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any>): AsyncIterableIterator<EntityData<T>>;
     protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
     protected wrapVirtualExpressionInSubqueryStream<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>, type: QueryType.SELECT): AsyncIterableIterator<T>;
     mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T, any, any, any>, map?: Dictionary): EntityData<T> | null;
     private mapJoinedProps;
-    count<T extends object>(entityName: string, where: any, options?: CountOptions<T>): Promise<number>;
-    nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
-    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
-    nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
+    count<T extends object>(entityName: EntityName<T>, where: any, options?: CountOptions<T>): Promise<number>;
+    nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
+    nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
+    nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     /**
      * Fast comparison for collection snapshots that are represented by PK arrays.
      * Compares scalars via `===` and fallbacks to Utils.equals()` for more complex types like Buffer.
@@ -69,8 +69,8 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
         ctx?: Transaction;
         connectionType?: ConnectionType;
     }): ConnectionType;
-    protected extractManyToMany<T>(entityName: string, data: EntityDictionary<T>): EntityData<T>;
-    protected processManyToMany<T extends object>(meta: EntityMetadata<T> | undefined, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
+    protected extractManyToMany<T>(meta: EntityMetadata<T>, data: EntityDictionary<T>): EntityData<T>;
+    protected processManyToMany<T extends object>(meta: EntityMetadata<T>, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
     protected buildPopulateWhere<T extends object>(meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'populateWhere'>): ObjectQuery<T>;
     protected buildOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];

package/AbstractSqlDriver.js

@@ -25,7 +25,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const connectionType = this.resolveConnectionType({ ctx: options.ctx, connectionType: options.connectionType });
         const populate = this.autoJoinOneToOneOwner(meta, options.populate, options.fields);
         const joinedProps = this.joinedProps(meta, populate, options);
-        const qb = this.createQueryBuilder(meta.className, options.ctx, connectionType, false, options.logging, undefined, options.em);
+        const qb = this.createQueryBuilder(meta.class, options.ctx, connectionType, false, options.logging, undefined, options.em);
         const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options);
         const orderBy = this.buildOrderBy(qb, meta, populate, options);
         const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
@@ -66,8 +66,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async find(entityName, where, options = {}) {
         options = { populate: [], orderBy: [], ...options };
-        const meta = this.metadata.find(entityName);
-        if (meta?.virtual) {
+        const meta = this.metadata.get(entityName);
+        if (meta.virtual) {
             return this.findVirtual(entityName, where, options);
         }
         const qb = await this.createQueryBuilderFromOptions(meta, where, options);
@@ -167,7 +167,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
     async wrapVirtualExpressionInSubquery(meta, expression, where, options, type) {
         const qb = await this.createQueryBuilderFromOptions(meta, where, options);
         qb.setFlag(QueryFlag.DISABLE_PAGINATE);
-        const isCursorPagination = [options.first, options.last, options.before, options.after].some(v => v != null);
+        const isCursorPagination = [
+            options.first,
+            options.last,
+            options.before,
+            options.after,
+        ].some(v => v != null);
         const native = qb.getNativeQuery(false);
         if (type === QueryType.COUNT) {
             native
@@ -221,7 +226,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 return;
             }
             const pivotRefJoin = prop.kind === ReferenceKind.MANY_TO_MANY && ref;
-            const meta2 = this.metadata.find(prop.type);
+            const meta2 = prop.targetMeta;
             let path = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
             if (!parentJoinPath) {
                 path = '[populate]' + path;
@@ -317,10 +322,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
                         const item = parseJsonSafe(relationPojo[prop.name]);
                         if (Array.isArray(item)) {
-                            relationPojo[prop.name] = item.map(row => row == null ? row : this.comparator.mapResult(prop.type, row));
+                            relationPojo[prop.name] = item.map(row => row == null ? row : this.comparator.mapResult(prop.targetMeta, row));
                         }
                         else {
-                            relationPojo[prop.name] = item == null ? item : this.comparator.mapResult(prop.type, item);
+                            relationPojo[prop.name] = item == null ? item : this.comparator.mapResult(prop.targetMeta, item);
                         }
                     }
                 }
@@ -377,19 +382,18 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async nativeInsert(entityName, data, options = {}) {
         options.convertCustomTypes ??= true;
-        const meta = this.metadata.find(entityName);
-        const collections = this.extractManyToMany(entityName, data);
-        const pks = meta?.primaryKeys ?? [this.config.getNamingStrategy().referenceColumnName()];
+        const meta = this.metadata.get(entityName);
+        const collections = this.extractManyToMany(meta, data);
         const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
         const res = await this.rethrow(qb.insert(data).execute('run', false));
         res.row = res.row || {};
         let pk;
-        if (pks.length > 1) { // owner has composite pk
-            pk = Utils.getPrimaryKeyCond(data, pks);
+        if (meta.primaryKeys.length > 1) { // owner has composite pk
+            pk = Utils.getPrimaryKeyCond(data, meta.primaryKeys);
         }
         else {
             /* v8 ignore next */
-            res.insertId = data[pks[0]] ?? res.insertId ?? res.row[pks[0]];
+            res.insertId = data[meta.primaryKeys[0]] ?? res.insertId ?? res.row[meta.primaryKeys[0]];
             pk = [res.insertId];
         }
         await this.processManyToMany(meta, pk, collections, false, options);
@@ -398,23 +402,22 @@ export class AbstractSqlDriver extends DatabaseDriver {
     async nativeInsertMany(entityName, data, options = {}, transform) {
         options.processCollections ??= true;
         options.convertCustomTypes ??= true;
-        const meta = this.metadata.find(entityName)?.root;
-        const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
-        const pks = this.getPrimaryKeyFields(entityName);
+        const meta = this.metadata.get(entityName).root;
+        const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
+        const pks = this.getPrimaryKeyFields(meta);
         const set = new Set();
         data.forEach(row => Utils.keys(row).forEach(k => set.add(k)));
-        const props = [...set].map(name => meta?.properties[name] ?? { name, fieldNames: [name] });
+        const props = [...set].map(name => meta.properties[name] ?? { name, fieldNames: [name] });
         let fields = Utils.flatten(props.map(prop => prop.fieldNames));
         const duplicates = Utils.findDuplicates(fields);
         const params = [];
         if (duplicates.length) {
             fields = Utils.unique(fields);
         }
-        /* v8 ignore next */
-        const tableName = meta ? this.getTableName(meta, options) : this.platform.quoteIdentifier(entityName);
+        const tableName = this.getTableName(meta, options);
         let sql = `insert into ${tableName} `;
         sql += fields.length > 0 ? '(' + fields.map(k => this.platform.quoteIdentifier(k)).join(', ') + ')' : `(${this.platform.quoteIdentifier(pks[0])})`;
-        if (meta && this.platform.usesOutputStatement()) {
+        if (this.platform.usesOutputStatement()) {
             const returningProps = meta.props
                 .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
                 .filter(prop => !(prop.name in data[0]) || isRaw(data[0][prop.name]));
@@ -531,13 +534,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async nativeUpdate(entityName, where, data, options = {}) {
         options.convertCustomTypes ??= true;
-        const meta = this.metadata.find(entityName);
-        const pks = this.getPrimaryKeyFields(entityName);
-        const collections = this.extractManyToMany(entityName, data);
+        const meta = this.metadata.get(entityName);
+        const pks = this.getPrimaryKeyFields(meta);
+        const collections = this.extractManyToMany(meta, data);
         let res = { affectedRows: 0, insertId: 0, row: {} };
         if (Utils.isPrimaryKey(where) && pks.length === 1) {
             /* v8 ignore next */
-            where = { [meta?.primaryKeys[0] ?? pks[0]]: where };
+            where = { [meta.primaryKeys[0] ?? pks[0]]: where };
         }
         if (Utils.hasObjectKeys(data)) {
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext)
@@ -561,7 +564,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 qb.update(data).where(where);
                 // reload generated columns and version fields
                 const returning = [];
-                meta?.props
+                meta.props
                     .filter(prop => (prop.generated && !prop.primary) || prop.version)
                     .forEach(prop => returning.push(prop.name));
                 qb.returning(returning);
@@ -593,7 +596,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             return this.rethrow(qb.execute('run', false));
         }
-        const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
+        const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
         const keys = new Set();
         const fields = new Set();
         const returning = new Set();
@@ -606,7 +609,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
         }
         // reload generated columns and version fields
-        meta?.props
+        meta.props
             .filter(prop => prop.generated || prop.version || prop.primary)
             .forEach(prop => returning.add(prop.name));
         const pkCond = Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames)).map(pk => `${this.platform.quoteIdentifier(pk)} = ?`).join(' and ');
@@ -699,8 +702,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
         return res;
     }
     async nativeDelete(entityName, where, options = {}) {
-        const meta = this.metadata.find(entityName);
-        const pks = this.getPrimaryKeyFields(entityName);
+        const meta = this.metadata.get(entityName);
+        const pks = this.getPrimaryKeyFields(meta);
         if (Utils.isPrimaryKey(where) && pks.length === 1) {
             where = { [pks[0]]: where };
         }
@@ -753,7 +756,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             if (coll.property.kind === ReferenceKind.ONE_TO_MANY) {
                 const cols = coll.property.referencedColumnNames;
-                const qb = this.createQueryBuilder(coll.property.type, options?.ctx, 'write')
+                const qb = this.createQueryBuilder(coll.property.targetMeta.class, options?.ctx, 'write')
                     .withSchema(this.getSchemaName(meta, options));
                 if (coll.getSnapshot() === undefined) {
                     if (coll.property.orphanRemoval) {
@@ -774,7 +777,6 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 await this.rethrow(query.execute());
                 continue;
             }
-            /* v8 ignore next */
             const pivotMeta = this.metadata.find(coll.property.pivotEntity);
             let schema = pivotMeta.schema;
             if (schema === '*') {
@@ -802,10 +804,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (owners.length === 0) {
             return {};
         }
-        const pivotMeta = this.metadata.find(prop.pivotEntity);
+        const pivotMeta = this.metadata.get(prop.pivotEntity);
         const pivotProp1 = pivotMeta.relations[prop.owner ? 1 : 0];
         const pivotProp2 = pivotMeta.relations[prop.owner ? 0 : 1];
-        const ownerMeta = this.metadata.find(pivotProp2.type);
+        const ownerMeta = pivotProp2.targetMeta;
         const cond = {
             [pivotProp2.name]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) },
         };
@@ -820,7 +822,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const fields = pivotJoin
             ? [pivotProp1.name, pivotProp2.name]
             : [pivotProp1.name, pivotProp2.name, ...childFields];
-        const res = await this.find(pivotMeta.className, where, {
+        const res = await this.find(pivotMeta.class, where, {
             ctx,
             ...options,
             fields,
@@ -830,7 +832,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             populateWhere: undefined,
             // @ts-ignore
             _populateWhere: 'infer',
-            populateFilter: !Utils.isEmpty(options?.populateFilter) ? { [pivotProp2.name]: options?.populateFilter } : undefined,
+            populateFilter: !Utils.isEmpty(options?.populateFilter) || RawQueryFragment.hasObjectFragments(options?.populateFilter) ? { [pivotProp2.name]: options?.populateFilter } : undefined,
         });
         const map = {};
         for (const owner of owners) {
@@ -844,7 +846,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         return map;
     }
     getPivotOrderBy(prop, pivotProp, orderBy, parentOrderBy) {
-        if (!Utils.isEmpty(orderBy)) {
+        if (!Utils.isEmpty(orderBy) || RawQueryFragment.hasObjectFragments(orderBy)) {
             return Utils.asArray(orderBy).map(o => ({ [pivotProp.name]: o }));
         }
         if (prop.kind === ReferenceKind.MANY_TO_MANY && Utils.asArray(parentOrderBy).some(o => o[prop.name])) {
@@ -852,7 +854,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 .filter(o => o[prop.name])
                 .map(o => ({ [pivotProp.name]: o[prop.name] }));
         }
-        if (!Utils.isEmpty(prop.orderBy)) {
+        if (!Utils.isEmpty(prop.orderBy) || RawQueryFragment.hasObjectFragments(prop.orderBy)) {
             return Utils.asArray(prop.orderBy).map(o => ({ [pivotProp.name]: o }));
         }
         if (prop.fixedOrder) {
@@ -865,8 +867,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async *stream(entityName, where, options) {
         options = { populate: [], orderBy: [], ...options };
-        const meta = this.metadata.find(entityName);
-        if (meta?.virtual) {
+        const meta = this.metadata.get(entityName);
+        if (meta.virtual) {
             yield* this.streamFromVirtual(entityName, where, options);
             return;
         }
@@ -1003,7 +1005,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (ref && !hint.filter && (prop.kind === ReferenceKind.MANY_TO_ONE || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
                 continue;
             }
-            const meta2 = this.metadata.find(prop.type);
+            const meta2 = prop.targetMeta;
             const pivotRefJoin = prop.kind === ReferenceKind.MANY_TO_MANY && ref;
             const tableAlias = qb.getNextAlias(prop.name);
             const field = `${options.parentTableAlias}.${prop.name}`;
@@ -1114,26 +1116,20 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return 'write';
     }
-    extractManyToMany(entityName, data) {
-        if (!this.metadata.has(entityName)) {
-            return {};
-        }
+    extractManyToMany(meta, data) {
         const ret = {};
-        this.metadata.find(entityName).relations.forEach(prop => {
+        for (const prop of meta.relations) {
             if (prop.kind === ReferenceKind.MANY_TO_MANY && data[prop.name]) {
                 ret[prop.name] = data[prop.name].map((item) => Utils.asArray(item));
                 delete data[prop.name];
             }
-        });
+        }
         return ret;
     }
     async processManyToMany(meta, pks, collections, clear, options) {
-        if (!meta) {
-            return;
-        }
         for (const prop of meta.relations) {
             if (collections[prop.name]) {
-                const pivotMeta = this.metadata.find(prop.pivotEntity);
+                const pivotMeta = this.metadata.get(prop.pivotEntity);
                 const persister = new PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema, options?.loggerContext);
                 persister.enqueueUpdate(prop, collections[prop.name], clear, pks);
                 await this.rethrow(persister.execute());
@@ -1142,7 +1138,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async lockPessimistic(entity, options) {
         const meta = helper(entity).__meta;
-        const qb = this.createQueryBuilder(entity.constructor.name, options.ctx, undefined, undefined, options.logging).withSchema(options.schema ?? meta.schema);
+        const qb = this.createQueryBuilder(meta.class, options.ctx, undefined, undefined, options.logging).withSchema(options.schema ?? meta.schema);
         const cond = Utils.getPrimaryKeyCond(entity, meta.primaryKeys);
         qb.select(raw('1')).where(cond).setLockMode(options.lockMode, options.lockTableAliases);
         await this.rethrow(qb.execute());
@@ -1152,21 +1148,21 @@ export class AbstractSqlDriver extends DatabaseDriver {
         for (const hint of joinedProps) {
             const [propName] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
-            if (!Utils.isEmpty(prop.where)) {
+            if (!Utils.isEmpty(prop.where) || RawQueryFragment.hasObjectFragments(prop.where)) {
                 where[prop.name] = Utils.copy(prop.where);
             }
             if (hint.children) {
                 const inner = this.buildPopulateWhere(prop.targetMeta, hint.children, {});
-                if (!Utils.isEmpty(inner)) {
+                if (!Utils.isEmpty(inner) || RawQueryFragment.hasObjectFragments(inner)) {
                     where[prop.name] ??= {};
                     Object.assign(where[prop.name], inner);
                 }
             }
         }
-        if (Utils.isEmpty(options.populateWhere)) {
+        if (Utils.isEmpty(options.populateWhere) && !RawQueryFragment.hasObjectFragments(options.populateWhere)) {
             return where;
         }
-        if (Utils.isEmpty(where)) {
+        if (Utils.isEmpty(where) && !RawQueryFragment.hasObjectFragments(where)) {
             return options.populateWhere;
         }
         /* v8 ignore next */
@@ -1178,31 +1174,31 @@ export class AbstractSqlDriver extends DatabaseDriver {
         // as `options.populateWhere` will be always recomputed to respect filters
         const populateWhereAll = options._populateWhere !== 'infer' && !Utils.isEmpty(options._populateWhere);
         const path = (populateWhereAll ? '[populate]' : '') + meta.className;
+        const optionsOrderBy = Utils.asArray(options.orderBy);
         const populateOrderBy = this.buildPopulateOrderBy(qb, meta, Utils.asArray(options.populateOrderBy ?? options.orderBy), path, !!options.populateOrderBy);
         const joinedPropsOrderBy = this.buildJoinedPropsOrderBy(qb, meta, joinedProps, options, path);
-        return [...Utils.asArray(options.orderBy), ...populateOrderBy, ...joinedPropsOrderBy];
+        return [...optionsOrderBy, ...populateOrderBy, ...joinedPropsOrderBy];
     }
     buildPopulateOrderBy(qb, meta, populateOrderBy, parentPath, explicit, parentAlias = qb.alias) {
         const orderBy = [];
         for (let i = 0; i < populateOrderBy.length; i++) {
             const orderHint = populateOrderBy[i];
-            for (const propName of Utils.keys(orderHint)) {
-                const raw = RawQueryFragment.getKnownFragment(propName, explicit);
-                if (raw) {
-                    const sql = raw.sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), parentAlias);
-                    const raw2 = new RawQueryFragment(sql, raw.params);
-                    orderBy.push({ [raw2]: orderHint[propName] });
+            for (const field of Utils.getObjectQueryKeys(orderHint)) {
+                const childOrder = orderHint[field];
+                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 });
                     continue;
                 }
-                const prop = meta.properties[propName];
+                const prop = meta.properties[field];
                 if (!prop) {
-                    throw new Error(`Trying to order by not existing property ${meta.className}.${propName}`);
+                    throw new Error(`Trying to order by not existing property ${meta.className}.${field}`);
                 }
                 let path = parentPath;
-                const meta2 = this.metadata.find(prop.type);
-                const childOrder = orderHint[prop.name];
+                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 += `.${propName}`;
+                    path += `.${field}`;
                 }
                 if (prop.kind === ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
                     path += '[pivot]';
@@ -1228,9 +1224,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     }
                     continue;
                 }
-                const order = typeof childOrder === 'object' ? childOrder[propName] : childOrder;
+                const order = typeof childOrder === 'object' ? childOrder[field] : childOrder;
                 if (order) {
-                    orderBy.push({ [`${propAlias}.${propName}`]: order });
+                    orderBy.push({ [`${propAlias}.${field}`]: order });
                 }
             }
         }
@@ -1249,22 +1245,23 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
             const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true });
-            const meta2 = this.metadata.find(prop.type);
+            const meta2 = prop.targetMeta;
             if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
                 const alias = ref ? propAlias : join.ownerAlias;
                 orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: QueryOrder.ASC });
             }
             if (propOrderBy) {
                 for (const item of Utils.asArray(propOrderBy)) {
-                    for (const field of Utils.keys(item)) {
-                        const rawField = RawQueryFragment.getKnownFragment(field, false);
-                        if (rawField) {
-                            const sql = propAlias ? rawField.sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), propAlias) : rawField.sql;
-                            const raw2 = raw(sql, rawField.params);
-                            orderBy.push({ [raw2.toString()]: item[field] });
+                    for (const field of Utils.getObjectQueryKeys(item)) {
+                        const order = item[field];
+                        if (RawQueryFragment.isKnownFragmentSymbol(field)) {
+                            const { sql, params } = RawQueryFragment.getKnownFragment(field);
+                            const sql2 = propAlias ? sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), propAlias) : sql;
+                            const key = raw(sql2, params);
+                            orderBy.push({ [key]: order });
                             continue;
                         }
-                        orderBy.push({ [`${propAlias}.${field}`]: item[field] });
+                        orderBy.push({ [`${propAlias}.${field}`]: order });
                     }
                 }
             }
@@ -1332,7 +1329,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 const prop = QueryHelper.findProperty(rootPropName, {
                     metadata: this.metadata,
                     platform: this.platform,
-                    entityName: meta.className,
+                    entityName: meta.class,
                     where: {},
                     aliasMap: qb.getAliasMap(),
                 });

package/PivotCollectionPersister.js

@@ -120,7 +120,7 @@ export class PivotCollectionPersister {
                 for (const item of chunk) {
                     cond.$or.push(item.getCondition());
                 }
-                await this.driver.nativeDelete(this.meta.className, cond, {
+                await this.driver.nativeDelete(this.meta.class, cond, {
                     ctx: this.ctx,
                     schema: this.schema,
                     loggerContext: this.loggerContext,
@@ -131,7 +131,7 @@ export class PivotCollectionPersister {
             const filtered = this.collectStatements(this.inserts);
             for (let i = 0; i < filtered.length; i += this.batchSize) {
                 const chunk = filtered.slice(i, i + this.batchSize);
-                await this.driver.nativeInsertMany(this.meta.className, chunk, {
+                await this.driver.nativeInsertMany(this.meta.class, chunk, {
                     ctx: this.ctx,
                     schema: this.schema,
                     convertCustomTypes: false,
@@ -144,7 +144,7 @@ export class PivotCollectionPersister {
             const filtered = this.collectStatements(this.upserts);
             for (let i = 0; i < filtered.length; i += this.batchSize) {
                 const chunk = filtered.slice(i, i + this.batchSize);
-                await this.driver.nativeUpdateMany(this.meta.className, [], chunk, {
+                await this.driver.nativeUpdateMany(this.meta.class, [], chunk, {
                     ctx: this.ctx,
                     schema: this.schema,
                     convertCustomTypes: false,

package/SqlEntityManager.d.ts

@@ -27,7 +27,7 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
     getKysely<TDB = undefined, TOptions extends GetKyselyOptions = GetKyselyOptions>(options?: TOptions): Kysely<TDB extends undefined ? InferKyselyDB<EntitiesFromManager<this>, TOptions> : TDB>;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): Promise<T>;
     getRepository<T extends object, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
-    protected applyDiscriminatorCondition<Entity extends object>(entityName: string, where: FilterQuery<Entity>): FilterQuery<Entity>;
+    protected applyDiscriminatorCondition<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<Entity>): FilterQuery<Entity>;
 }
 type EntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends any[] ? (Extract<NonNullable<TEntityManager['~entities']>[number], EntitySchemaWithMeta>) : never;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.113",
+  "version": "7.0.0-dev.115",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.113"
+    "@mikro-orm/core": "7.0.0-dev.115"
   }
 }

package/plugin/transformer.js

@@ -706,7 +706,7 @@ export class MikroTransformer extends OperationNodeTransformer {
      * Find entity metadata by table name or entity name
      */
     findEntityMetadata(name) {
-        const byEntity = this.metadata.find(name);
+        const byEntity = this.metadata.getByClassName(name, false);
         if (byEntity) {
             return byEntity;
         }

package/query/CriteriaNode.d.ts

@@ -1,4 +1,4 @@
-import { type EntityKey, type EntityProperty, type MetadataStorage } from '@mikro-orm/core';
+import { type EntityKey, type EntityProperty, type MetadataStorage, type RawQueryFragmentSymbol, type EntityName } from '@mikro-orm/core';
 import type { ICriteriaNode, ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
 /**
  * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.
@@ -7,14 +7,14 @@ import type { ICriteriaNode, ICriteriaNodeProcessOptions, IQueryBuilder } from '
  */
 export declare class CriteriaNode<T extends object> implements ICriteriaNode<T> {
     protected readonly metadata: MetadataStorage;
-    readonly entityName: string;
+    readonly entityName: EntityName<T>;
     readonly parent?: ICriteriaNode<T> | undefined;
-    readonly key?: EntityKey<T> | undefined;
+    readonly key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined;
     readonly strict: boolean;
     payload: any;
     prop?: EntityProperty<T>;
     index?: number;
-    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | undefined, validate?: boolean, strict?: boolean);
+    constructor(metadata: MetadataStorage, entityName: EntityName<T>, parent?: ICriteriaNode<T> | undefined, key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined, validate?: boolean, strict?: boolean);
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
     unwrap(): any;
     shouldInline(payload: any): boolean;

package/query/CriteriaNode.js

@@ -20,7 +20,7 @@ export class CriteriaNode {
         this.key = key;
         this.strict = strict;
         const meta = parent && metadata.find(parent.entityName);
-        if (meta && key) {
+        if (meta && key && !RawQueryFragment.isKnownFragmentSymbol(key)) {
             const pks = Utils.splitPrimaryKeys(key);
             if (pks.length > 1) {
                 return;
@@ -29,8 +29,8 @@ export class CriteriaNode {
                 this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k && prop.persist !== false));
                 const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));
                 // do not validate if the key is prefixed or type casted (e.g. `k::text`)
-                if (validate && !isProp && !k.includes('.') && !k.includes('::') && !Utils.isOperator(k) && !RawQueryFragment.isKnownFragment(k)) {
-                    throw new Error(`Trying to query by not existing property ${entityName}.${k}`);
+                if (validate && !isProp && !k.includes('.') && !k.includes('::') && !Utils.isOperator(k)) {
+                    throw new Error(`Trying to query by not existing property ${Utils.className(entityName)}.${k}`);
                 }
             }
         }
@@ -50,11 +50,9 @@ export class CriteriaNode {
     shouldRename(payload) {
         const type = this.prop ? this.prop.kind : null;
         const composite = this.prop?.joinColumns ? this.prop.joinColumns.length > 1 : false;
-        const customExpression = RawQueryFragment.isKnownFragment(this.key);
-        const scalar = payload === null || Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
-        const plainObject = Utils.isPlainObject(payload);
-        const keys = plainObject ? Object.keys(payload) : [];
-        const operator = plainObject && keys.every(k => Utils.isOperator(k, false));
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
+        const scalar = payload === null || Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
+        const operator = Utils.isPlainObject(payload) && Utils.getObjectQueryKeys(payload).every(k => Utils.isOperator(k, false));
         if (composite) {
             return true;
         }
@@ -81,10 +79,10 @@ export class CriteriaNode {
     getPath(addIndex = false) {
         // use index on parent only if we are processing to-many relation
         const addParentIndex = this.prop && [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(this.prop.kind);
-        const parentPath = this.parent?.getPath(addParentIndex) ?? this.entityName;
+        const parentPath = this.parent?.getPath(addParentIndex) ?? Utils.className(this.entityName);
         const index = addIndex && this.index != null ? `[${this.index}]` : '';
         // ignore group operators to allow easier mapping (e.g. for orderBy)
-        const key = this.key && !['$and', '$or', '$not'].includes(this.key) ? '.' + this.key : '';
+        const key = this.key && !RawQueryFragment.isKnownFragmentSymbol(this.key) && !['$and', '$or', '$not'].includes(this.key) ? '.' + this.key : '';
         const ret = parentPath + index + key;
         if (this.isPivotJoin()) {
             // distinguish pivot table join from target entity join
@@ -96,9 +94,9 @@ export class CriteriaNode {
         if (!this.key || !this.prop) {
             return false;
         }
-        const customExpression = RawQueryFragment.isKnownFragment(this.key);
-        const scalar = this.payload === null || Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
-        const operator = Utils.isObject(this.payload) && Object.keys(this.payload).every(k => Utils.isOperator(k, false));
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
+        const scalar = this.payload === null || Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || rawField;
+        const operator = Utils.isObject(this.payload) && Utils.getObjectQueryKeys(this.payload).every(k => Utils.isOperator(k, false));
         return this.prop.kind === ReferenceKind.MANY_TO_MANY && (scalar || operator);
     }
     getPivotPath(path) {
@@ -111,6 +109,7 @@ export class CriteriaNode {
         return this.strict;
     }
     /** @ignore */
+    /* v8 ignore next */
     [Symbol.for('nodejs.util.inspect.custom')]() {
         const o = {};
         ['entityName', 'key', 'index', 'payload']