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

package/drivers/IDatabaseDriver.d.ts

@@ -8,7 +8,7 @@ import type { EntityManager } from '../EntityManager.js';
 import type { DriverException } from '../exceptions.js';
 import type { Configuration } from '../utils/Configuration.js';
 import type { LoggingOptions, LogContext } from '../logging/Logger.js';
-import type { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import type { Raw } from '../utils/RawQueryFragment.js';
 export declare const EntityManagerType: unique symbol;
 export interface IDatabaseDriver<C extends Connection = Connection> {
     [EntityManagerType]: EntityManager<this>;
@@ -25,21 +25,21 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
     /**
      * Finds selection of entities
      */
-    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
     /**
      * Finds single entity (table row, document)
      */
-    findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
-    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
-    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>): Promise<QueryResult<T>>;
-    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
-    nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: NativeDeleteOptions<T>): Promise<QueryResult<T>>;
+    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>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: NativeDeleteOptions<T>): Promise<QueryResult<T>>;
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
-    count<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
-    aggregate(entityName: string, pipeline: any[]): Promise<any[]>;
+    count<T extends object, P extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
+    aggregate(entityName: EntityName, pipeline: any[]): Promise<any[]>;
     mapResult<T extends object>(result: EntityDictionary<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[]): EntityData<T> | null;
     /**
      * When driver uses pivot tables for M:N, this method will load identifiers for given collections from them
@@ -189,7 +189,7 @@ export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOpti
     processCollections?: boolean;
 }
 export interface UpsertOptions<Entity, Fields extends string = never> extends Omit<NativeInsertUpdateOptions<Entity>, 'upsert'> {
-    onConflictFields?: (keyof Entity)[] | RawQueryFragment;
+    onConflictFields?: (keyof Entity)[] | Raw;
     onConflictAction?: 'ignore' | 'merge';
     onConflictMergeFields?: AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
     onConflictExcludeFields?: AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];

package/entity/Collection.js

@@ -4,6 +4,7 @@ import { DataloaderType, ReferenceKind } from '../enums.js';
 import { Reference } from './Reference.js';
 import { helper, wrap } from './wrap.js';
 import { QueryHelper } from '../utils/QueryHelper.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 import { inspect } from '../logging/inspect.js';
 export class Collection {
     owner;
@@ -83,7 +84,7 @@ export class Collection {
             return this._count = this.length;
         }
         const cond = this.createLoadCountCondition(where ?? {});
-        const count = await em.count(this.property.type, cond, countOptions);
+        const count = await em.count(this.property.targetMeta.class, cond, countOptions);
         if (!where) {
             this._count = count;
         }
@@ -95,12 +96,12 @@ export class Collection {
         opts.orderBy = this.createOrderBy(opts.orderBy);
         let items;
         if (this.property.kind === ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable()) {
-            const cond = await em.applyFilters(this.property.type, where, options.filters ?? {}, 'read');
+            const cond = await em.applyFilters(this.property.targetMeta.class, where, options.filters ?? {}, 'read');
             const map = await em.getDriver().loadFromPivotTable(this.property, [helper(this.owner).__primaryKeys], cond, opts.orderBy, ctx, options);
-            items = map[helper(this.owner).getSerializedPrimaryKey()].map((item) => em.merge(this.property.type, item, { convertCustomTypes: true }));
+            items = map[helper(this.owner).getSerializedPrimaryKey()].map((item) => em.merge(this.property.targetMeta.class, item, { convertCustomTypes: true }));
         }
         else {
-            items = await em.find(this.property.type, this.createCondition(where), opts);
+            items = await em.find(this.property.targetMeta.class, this.createCondition(where), opts);
         }
         if (options.store) {
             this.hydrate(items, true);
@@ -298,7 +299,7 @@ export class Collection {
         return cond;
     }
     createOrderBy(orderBy = []) {
-        if (Utils.isEmpty(orderBy) && this.property.orderBy) {
+        if (Utils.isEmpty(orderBy) && !Raw.hasObjectFragments(orderBy) && this.property.orderBy) {
             orderBy = this.property.orderBy;
         }
         return Utils.asArray(orderBy);
@@ -330,7 +331,7 @@ export class Collection {
     }
     checkInitialized() {
         if (!this.isInitialized()) {
-            throw new Error(`Collection<${this.property.type}> of entity ${this.owner.constructor.name}[${helper(this.owner).getSerializedPrimaryKey()}] not initialized`);
+            throw new Error(`Collection<${this.property.type}> of entity ${helper(this.owner).__meta.name}[${helper(this.owner).getSerializedPrimaryKey()}] not initialized`);
         }
     }
     /**

package/entity/EntityAssigner.js

@@ -77,7 +77,7 @@ export class EntityAssigner {
                 if (options.updateByPrimaryKey) {
                     const pk = Utils.extractPK(value, prop.targetMeta);
                     if (pk) {
-                        const ref = options.em.getReference(prop.type, pk, options);
+                        const ref = options.em.getReference(prop.targetMeta.class, pk, options);
                         // if the PK differs, we want to change the target entity, not update it
                         const wrappedChild = helper(ref);
                         const sameTarget = wrappedChild.getSerializedPrimaryKey() === wrapped.getSerializedPrimaryKey();
@@ -141,13 +141,13 @@ export class EntityAssigner {
             entity[prop.name] = Reference.wrapReference(value, prop);
         }
         else if (Utils.isPrimaryKey(value, true) && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = prop.mapToPk ? value : Reference.wrapReference(em.getReference(prop.type, value, options), prop);
+            entity[prop.name] = prop.mapToPk ? value : Reference.wrapReference(em.getReference(prop.targetMeta.class, value, options), prop);
         }
         else if (Utils.isPlainObject(value) && options.merge && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = Reference.wrapReference(em.merge(prop.type, value, options), prop);
+            entity[prop.name] = Reference.wrapReference(em.merge(prop.targetMeta.class, value, options), prop);
         }
         else if (Utils.isPlainObject(value) && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = Reference.wrapReference(em.create(prop.type, value, options), prop);
+            entity[prop.name] = Reference.wrapReference(em.create(prop.targetMeta.class, value, options), prop);
         }
         else {
             const name = entity.constructor.name;
@@ -166,7 +166,7 @@ export class EntityAssigner {
             if (options.updateNestedEntities && options.updateByPrimaryKey && Utils.isPlainObject(item)) {
                 const pk = Utils.extractPK(item, prop.targetMeta);
                 if (pk && EntityAssigner.validateEM(em)) {
-                    const ref = em.getUnitOfWork().getById(prop.type, pk, options.schema);
+                    const ref = em.getUnitOfWork().getById(prop.targetMeta.class, pk, options.schema);
                     if (ref) {
                         return EntityAssigner.assign(ref, item, options);
                     }
@@ -207,7 +207,7 @@ export class EntityAssigner {
                 entity[propName].push(...Object.values(tmp));
             });
         }
-        const create = () => EntityAssigner.validateEM(em) && em.getEntityFactory().createEmbeddable(prop.type, value, {
+        const create = () => EntityAssigner.validateEM(em) && em.getEntityFactory().createEmbeddable(prop.targetMeta.class, value, {
             convertCustomTypes: options.convertCustomTypes,
             newEntity: options.mergeEmbeddedProperties ? !('propName' in entity) : true,
         });
@@ -221,13 +221,13 @@ export class EntityAssigner {
             return item;
         }
         if (Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
-            return em.getReference(prop.type, item, options);
+            return em.getReference(prop.targetMeta.class, item, options);
         }
         if (Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
-            return em.merge(prop.type, item, options);
+            return em.merge(prop.targetMeta.class, item, options);
         }
         if (Utils.isPlainObject(item) && EntityAssigner.validateEM(em)) {
-            return em.create(prop.type, item, options);
+            return em.create(prop.targetMeta.class, item, options);
         }
         invalid.push(item);
         return item;

package/entity/EntityFactory.js

@@ -30,7 +30,6 @@ export class EntityFactory {
         if (data.__entity) {
             return data;
         }
-        entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         if (meta.virtual) {
             data = { ...data };
@@ -110,12 +109,12 @@ export class EntityFactory {
         data = QueryHelper.processParams(data);
         const existsData = this.comparator.prepareEntity(entity);
         const originalEntityData = helper(entity).__originalEntityData ?? {};
-        const diff = this.comparator.diffEntities(meta.className, originalEntityData, existsData);
+        const diff = this.comparator.diffEntities(meta.class, originalEntityData, existsData);
         // version properties are not part of entity snapshots
         if (meta.versionProperty && data[meta.versionProperty] && data[meta.versionProperty] !== originalEntityData[meta.versionProperty]) {
             diff[meta.versionProperty] = data[meta.versionProperty];
         }
-        const diff2 = this.comparator.diffEntities(meta.className, existsData, data, { includeInverseSides: true });
+        const diff2 = this.comparator.diffEntities(meta.class, existsData, data, { includeInverseSides: true });
         // do not override values changed by user
         Utils.keys(diff).forEach(key => delete diff2[key]);
         Utils.keys(diff2).filter(key => {
@@ -152,18 +151,17 @@ export class EntityFactory {
                 // we just create the entity from scratch, which will automatically pick the right one from the identity map and call `mergeData` on it
                 data[prop.name]
                     .filter(child => Utils.isPlainObject(child)) // objects with prototype can be PKs (e.g. `ObjectId`)
-                    .forEach(child => this.create(prop.type, child, options)); // we can ignore the value, we just care about the `mergeData` call
+                    .forEach(child => this.create(prop.targetMeta.class, child, options)); // we can ignore the value, we just care about the `mergeData` call
                 return;
             }
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name]) && entity[prop.name] && helper(entity[prop.name]).__initialized) {
-                this.create(prop.type, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
+                this.create(prop.targetMeta.class, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
             }
         });
         this.unitOfWork.normalizeEntityData(meta, originalEntityData);
     }
     createReference(entityName, id, options = {}) {
         options.convertCustomTypes ??= true;
-        entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         const schema = this.driver.getSchemaName(meta, options);
         if (meta.simplePK) {
@@ -188,7 +186,6 @@ export class EntityFactory {
         return this.create(entityName, id, { ...options, initialized: false });
     }
     createEmbeddable(entityName, data, options = {}) {
-        entityName = Utils.className(entityName);
         data = { ...data };
         const meta = this.metadata.get(entityName);
         const meta2 = this.processDiscriminatorColumn(meta, data);
@@ -200,7 +197,7 @@ export class EntityFactory {
     createEntity(data, meta, options) {
         const schema = this.driver.getSchemaName(meta, options);
         if (options.newEntity || meta.forceConstructor || meta.virtual) {
-            if (!meta.class) {
+            if (meta.polymorphs) {
                 throw new Error(`Cannot create entity ${meta.className}, class prototype is unknown`);
             }
             const params = this.extractConstructorParams(meta, data, options);
@@ -263,13 +260,13 @@ export class EntityFactory {
     findEntity(data, meta, options) {
         const schema = this.driver.getSchemaName(meta, options);
         if (meta.simplePK) {
-            return this.unitOfWork.getById(meta.className, data[meta.primaryKeys[0]], schema);
+            return this.unitOfWork.getById(meta.class, data[meta.primaryKeys[0]], schema);
         }
         if (!Array.isArray(data) && meta.primaryKeys.some(pk => data[pk] == null)) {
             return undefined;
         }
         const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform, options.convertCustomTypes);
-        return this.unitOfWork.getById(meta.className, pks, schema);
+        return this.unitOfWork.getById(meta.class, pks, schema);
     }
     processDiscriminatorColumn(meta, data) {
         if (!meta.root.discriminatorColumn) {
@@ -278,7 +275,7 @@ export class EntityFactory {
         const prop = meta.properties[meta.root.discriminatorColumn];
         const value = data[prop.name];
         const type = meta.root.discriminatorMap[value];
-        meta = type ? this.metadata.find(type) : meta;
+        meta = type ? this.metadata.get(type) : meta;
         return meta;
     }
     /**
@@ -307,7 +304,7 @@ export class EntityFactory {
             const value = data[k];
             if (prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && value) {
                 const pk = Reference.unwrapReference(value);
-                const entity = this.unitOfWork.getById(prop.type, pk, options.schema, true);
+                const entity = this.unitOfWork.getById(prop.targetMeta.class, pk, options.schema, true);
                 if (entity) {
                     return entity;
                 }
@@ -316,10 +313,10 @@ export class EntityFactory {
                 }
                 const nakedPk = Utils.extractPK(value, prop.targetMeta, true);
                 if (Utils.isObject(value) && !nakedPk) {
-                    return this.create(prop.type, value, options);
+                    return this.create(prop.targetMeta.class, value, options);
                 }
                 const { newEntity, initialized, ...rest } = options;
-                const target = this.createReference(prop.type, nakedPk, rest);
+                const target = this.createReference(prop.targetMeta.class, nakedPk, rest);
                 return Reference.wrapReference(target, prop);
             }
             if (prop?.kind === ReferenceKind.EMBEDDED && value) {
@@ -327,7 +324,7 @@ export class EntityFactory {
                 if (Utils.isEntity(value)) {
                     return value;
                 }
-                return this.createEmbeddable(prop.type, value, options);
+                return this.createEmbeddable(prop.targetMeta.class, value, options);
             }
             if (!prop) {
                 const tmp = { ...data };
@@ -335,8 +332,8 @@ export class EntityFactory {
                     if (!options.convertCustomTypes || !prop.customType || tmp[prop.name] == null) {
                         continue;
                     }
-                    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(tmp[prop.name]) && !Utils.extractPK(tmp[prop.name], meta.properties[prop.name].targetMeta, true)) {
-                        tmp[prop.name] = Reference.wrapReference(this.create(meta.properties[prop.name].type, tmp[prop.name], options), prop);
+                    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(tmp[prop.name]) && !Utils.extractPK(tmp[prop.name], prop.targetMeta, true)) {
+                        tmp[prop.name] = Reference.wrapReference(this.create(prop.targetMeta.class, tmp[prop.name], options), prop);
                     }
                     else if (prop.kind === ReferenceKind.SCALAR) {
                         tmp[prop.name] = prop.customType.convertToJSValue(tmp[prop.name], this.platform);

package/entity/EntityHelper.d.ts

@@ -6,9 +6,9 @@ import { type EntityMetadata, type EntityProperty, type IHydrator } from '../typ
 export declare class EntityHelper {
     static decorate<T extends object>(meta: EntityMetadata<T>, em: EntityManager): void;
     /**
-     * As a performance optimization, we create entity state methods in a lazy manner. We first add
+     * As a performance optimization, we create entity state methods lazily. We first add
      * the `null` value to the prototype to reserve space in memory. Then we define a setter on the
-     * prototype, that will be executed exactly once per entity instance. There we redefine given
+     * prototype that will be executed exactly once per entity instance. There we redefine the given
      * property on the entity instance, so shadowing the prototype setter.
      */
     private static defineBaseProperties;

package/entity/EntityHelper.js

@@ -38,9 +38,9 @@ export class EntityHelper {
         }
     }
     /**
-     * As a performance optimization, we create entity state methods in a lazy manner. We first add
+     * As a performance optimization, we create entity state methods lazily. We first add
      * the `null` value to the prototype to reserve space in memory. Then we define a setter on the
-     * prototype, that will be executed exactly once per entity instance. There we redefine given
+     * prototype that will be executed exactly once per entity instance. There we redefine the given
      * property on the entity instance, so shadowing the prototype setter.
      */
     static defineBaseProperties(meta, prototype, em) {

package/entity/EntityLoader.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, ConnectionType, EntityProperty, FilterQuery, PopulateOptions } from '../typings.js';
+import type { AnyEntity, ConnectionType, EntityName, EntityProperty, FilterQuery, PopulateOptions } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums.js';
 import type { EntityField, FilterOptions } from '../drivers/IDatabaseDriver.js';
@@ -30,8 +30,8 @@ export declare class EntityLoader {
      * Loads specified relations in batch.
      * This will execute one query for each relation, that will populate it on all the specified entities.
      */
-    populate<Entity extends object, Fields extends string = PopulatePath.ALL>(entityName: string, entities: Entity[], populate: PopulateOptions<Entity>[] | boolean, options: EntityLoaderOptions<Entity, Fields>): Promise<void>;
-    normalizePopulate<Entity>(entityName: string, populate: (PopulateOptions<Entity> | boolean)[] | PopulateOptions<Entity> | boolean, strategy?: LoadStrategy, lookup?: boolean): PopulateOptions<Entity>[];
+    populate<Entity extends object, Fields extends string = PopulatePath.ALL>(entityName: EntityName<Entity>, entities: Entity[], populate: PopulateOptions<Entity>[] | boolean, options: EntityLoaderOptions<Entity, Fields>): Promise<void>;
+    normalizePopulate<Entity>(entityName: EntityName<Entity>, populate: (PopulateOptions<Entity> | boolean)[] | PopulateOptions<Entity> | boolean, strategy?: LoadStrategy, lookup?: boolean): PopulateOptions<Entity>[];
     private setSerializationContext;
     /**
      * Merge multiple populates for the same entity with different children. Also skips `*` fields, those can come from

package/entity/EntityLoader.js

@@ -4,8 +4,8 @@ import { ValidationError } from '../errors.js';
 import { LoadStrategy, PopulatePath, ReferenceKind, } from '../enums.js';
 import { Reference } from './Reference.js';
 import { helper } from './wrap.js';
-import { raw, RawQueryFragment } from '../utils/RawQueryFragment.js';
 import { expandDotPaths } from './utils.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export class EntityLoader {
     em;
     metadata;
@@ -157,7 +157,7 @@ export class EntityLoader {
         const ids = Utils.unique(filtered.map(e => Utils.getPrimaryKeyValues(e, meta, true)));
         const where = this.mergePrimaryCondition(ids, pk, options, meta, this.metadata, this.driver.getPlatform());
         const { filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging, fields } = options;
-        await this.em.find(meta.className, where, {
+        await this.em.find(meta.class, where, {
             filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging,
             fields: fields,
             populate: [],
@@ -181,7 +181,7 @@ export class EntityLoader {
         for (const child of children) {
             const pk = child.__helper.__data[prop.mappedBy] ?? child[prop.mappedBy];
             if (pk) {
-                const key = helper(mapToPk ? this.em.getReference(prop.type, pk) : pk).getSerializedPrimaryKey();
+                const key = helper(mapToPk ? this.em.getReference(prop.targetMeta.class, pk) : pk).getSerializedPrimaryKey();
                 map[key]?.push(child);
             }
         }
@@ -237,28 +237,14 @@ export class EntityLoader {
         if (typeof populateWhere === 'object') {
             populateWhere = await this.extractChildCondition({ where: populateWhere }, prop);
         }
-        if (!Utils.isEmpty(prop.where)) {
+        if (!Utils.isEmpty(prop.where) || Raw.hasObjectFragments(prop.where)) {
             where = { $and: [where, prop.where] };
         }
-        const propOrderBy = [];
-        if (prop.orderBy) {
-            for (const item of Utils.asArray(prop.orderBy)) {
-                for (const field of Utils.keys(item)) {
-                    const rawField = RawQueryFragment.getKnownFragment(field, false);
-                    if (rawField) {
-                        const raw2 = raw(rawField.sql, rawField.params);
-                        propOrderBy.push({ [raw2.toString()]: item[field] });
-                        continue;
-                    }
-                    propOrderBy.push({ [field]: item[field] });
-                }
-            }
-        }
-        const orderBy = [...Utils.asArray(options.orderBy), ...propOrderBy].filter((order, idx, array) => {
+        const orderBy = [...Utils.asArray(options.orderBy), ...Utils.asArray(prop.orderBy)].filter((order, idx, array) => {
             // skip consecutive ordering with the same key to get around mongo issues
-            return idx === 0 || !Utils.equals(Object.keys(array[idx - 1]), Object.keys(order));
+            return idx === 0 || !Utils.equals(Utils.getObjectQueryKeys(array[idx - 1]), Utils.getObjectQueryKeys(order));
         });
-        const items = await this.em.find(prop.type, where, {
+        const items = await this.em.find(meta.class, where, {
             filters, convertCustomTypes, lockMode, populateWhere, logging,
             orderBy,
             populate: populate.children ?? populate.all ?? [],
@@ -297,7 +283,7 @@ export class EntityLoader {
         return { items, partial };
     }
     mergePrimaryCondition(ids, pk, options, meta, metadata, platform) {
-        const cond1 = QueryHelper.processWhere({ where: { [pk]: { $in: ids } }, entityName: meta.className, metadata, platform, convertCustomTypes: !options.convertCustomTypes });
+        const cond1 = QueryHelper.processWhere({ where: { [pk]: { $in: ids } }, entityName: meta.class, metadata, platform, convertCustomTypes: !options.convertCustomTypes });
         const where = { ...options.where };
         Utils.dropUndefinedProperties(where);
         return where[pk]
@@ -349,7 +335,11 @@ export class EntityLoader {
         for (const entity of entities) {
             visited.add(entity);
         }
-        await this.populate(prop.type, unique, populate.children ?? populate.all, {
+        // skip lazy scalar properties
+        if (!prop.targetMeta) {
+            return;
+        }
+        await this.populate(prop.targetMeta.class, unique, populate.children ?? populate.all, {
             where: await this.extractChildCondition(options, prop, false),
             orderBy: innerOrderBy,
             fields,
@@ -394,12 +384,12 @@ export class EntityLoader {
         for (const entity of filtered) {
             const items = map[entity.__helper.getSerializedPrimaryKey()].map(item => {
                 if (pivotJoin) {
-                    return this.em.getReference(prop.type, item, {
+                    return this.em.getReference(prop.targetMeta.class, item, {
                         convertCustomTypes: true,
                         schema: options.schema ?? this.em.config.get('schema'),
                     });
                 }
-                const entity = this.em.getEntityFactory().create(prop.type, item, {
+                const entity = this.em.getEntityFactory().create(prop.targetMeta.class, item, {
                     refresh,
                     merge: true,
                     convertCustomTypes: true,
@@ -415,16 +405,13 @@ export class EntityLoader {
     async extractChildCondition(options, prop, filters = false) {
         const where = options.where;
         const subCond = Utils.isPlainObject(where[prop.name]) ? where[prop.name] : {};
-        const meta2 = this.metadata.find(prop.type);
-        if (!meta2) {
-            return {};
-        }
+        const meta2 = prop.targetMeta;
         const pk = Utils.getPrimaryKeyHash(meta2.primaryKeys);
         ['$and', '$or'].forEach(op => {
             if (where[op]) {
                 const child = where[op]
                     .map((cond) => cond[prop.name])
-                    .filter((sub) => sub != null && !(Utils.isPlainObject(sub) && Object.keys(sub).every(key => Utils.isOperator(key, false))))
+                    .filter((sub) => sub != null && !(Utils.isPlainObject(sub) && Utils.getObjectQueryKeys(sub).every(key => Utils.isOperator(key, false))))
                     .map((cond) => {
                     if (Utils.isPrimaryKey(cond)) {
                         return { [pk]: cond };
@@ -445,7 +432,7 @@ export class EntityLoader {
             });
         }
         if (filters) {
-            return this.em.applyFilters(prop.type, subCond, options.filters, 'read', options);
+            return this.em.applyFilters(meta2.class, subCond, options.filters, 'read', options);
         }
         return subCond;
     }
@@ -578,10 +565,10 @@ export class EntityLoader {
         if (!meta && !prefix) {
             return populate;
         }
-        if (visited.includes(entityName) || !meta) {
+        if (!meta || visited.includes(meta)) {
             return [];
         }
-        visited.push(entityName);
+        visited.push(meta);
         const ret = prefix === '' ? [...populate] : [];
         meta.relations
             .filter(prop => {
@@ -594,12 +581,12 @@ export class EntityLoader {
             const field = this.getRelationName(meta, prop);
             const prefixed = prefix ? `${prefix}.${field}` : field;
             const nestedPopulate = populate.filter(p => p.field === prop.name).flatMap(p => p.children).filter(Boolean);
-            const nested = this.lookupEagerLoadedRelationships(prop.type, nestedPopulate, strategy, prefixed, visited.slice());
+            const nested = this.lookupEagerLoadedRelationships(prop.targetMeta.class, nestedPopulate, strategy, prefixed, visited.slice());
             if (nested.length > 0) {
                 ret.push(...nested);
             }
             else {
-                const selfReferencing = [meta.className, meta.root.className, ...visited].includes(prop.type) && prop.eager;
+                const selfReferencing = [meta.tableName, ...visited.map(m => m.tableName)].includes(prop.targetMeta.tableName) && prop.eager;
                 ret.push({
                     field: prefixed,
                     // enforce select-in strategy for self-referencing relations

package/entity/WrappedEntity.js

@@ -71,7 +71,7 @@ export class WrappedEntity {
         if (!this.__em) {
             throw ValidationError.entityNotManaged(this.entity);
         }
-        return this.__em.findOne(this.entity.constructor.name, this.entity, { ...options, refresh: true, schema: this.__schema });
+        return this.__em.findOne(this.entity.constructor, this.entity, { ...options, refresh: true, schema: this.__schema });
     }
     async populate(populate, options = {}) {
         if (!this.__em) {

package/entity/defineEntity.d.ts

@@ -326,7 +326,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /** Override default name for pivot table (see {@doclink naming-strategy | Naming Strategy}). */
     pivotTable(pivotTable: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
-    pivotEntity(pivotEntity: string | (() => EntityName<any>)): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    pivotEntity(pivotEntity: () => EntityName): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     joinColumn(joinColumn: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
@@ -380,15 +380,15 @@ declare const propertyBuilders: {
     time: (length?: number) => UniversalPropertyOptionsBuilder<any, EmptyOptions, IncludeKeysForProperty>;
     type: <T extends PropertyValueType>(type: T) => UniversalPropertyOptionsBuilder<InferPropertyValueType<T>, EmptyOptions, IncludeKeysForProperty>;
     enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T, EmptyOptions, IncludeKeysForEnumOptions>;
-    embedded: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any> | EntitySchemaWithMeta<any, any, any, any, any>[] | EntityClass<any>[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions, IncludeKeysForEmbeddedOptions>;
-    manyToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+    embedded: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass | EntitySchemaWithMeta<any, any, any, any, any>[] | EntityClass[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions, IncludeKeysForEmbeddedOptions>;
+    manyToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
         kind: "m:n";
     }, IncludeKeysForManyToManyOptions>;
-    manyToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+    manyToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
         kind: "m:1";
     }, IncludeKeysForManyToOneOptions>;
-    oneToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<InferEntity<Target>>;
-    oneToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+    oneToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<InferEntity<Target>>;
+    oneToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
         kind: "1:1";
     }, IncludeKeysForOneToOneOptions>;
     date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
@@ -454,15 +454,15 @@ export declare namespace defineEntity {
         time: (length?: number) => UniversalPropertyOptionsBuilder<any, EmptyOptions, IncludeKeysForProperty>;
         type: <T extends PropertyValueType>(type: T) => UniversalPropertyOptionsBuilder<InferPropertyValueType<T>, EmptyOptions, IncludeKeysForProperty>;
         enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T, EmptyOptions, IncludeKeysForEnumOptions>;
-        embedded: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any> | EntitySchemaWithMeta<any, any, any, any, any>[] | EntityClass<any>[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions, IncludeKeysForEmbeddedOptions>;
-        manyToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+        embedded: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass | EntitySchemaWithMeta<any, any, any, any, any>[] | EntityClass[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions, IncludeKeysForEmbeddedOptions>;
+        manyToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
             kind: "m:n";
         }, IncludeKeysForManyToManyOptions>;
-        manyToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+        manyToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
             kind: "m:1";
         }, IncludeKeysForManyToOneOptions>;
-        oneToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<InferEntity<Target>>;
-        oneToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+        oneToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<InferEntity<Target>>;
+        oneToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
             kind: "1:1";
         }, IncludeKeysForOneToOneOptions>;
         date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;

package/entity/validators.js

@@ -1,6 +1,6 @@
 import { Utils } from '../utils/Utils.js';
 import { ValidationError } from '../errors.js';
-import { isRaw } from '../utils/RawQueryFragment.js';
+import { isRaw, Raw } from '../utils/RawQueryFragment.js';
 import { SCALAR_TYPES } from '../enums.js';
 /** @internal */
 export function validateProperty(prop, givenValue, entity) {
@@ -59,7 +59,7 @@ export function validatePrimaryKey(entity, meta) {
 }
 /** @internal */
 export function validateEmptyWhere(where) {
-    if (Utils.isEmpty(where)) {
+    if (Utils.isEmpty(where) && !Raw.hasObjectFragments(where)) {
         throw new Error(`You cannot call 'EntityManager.findOne()' with empty 'where' parameter`);
     }
 }

package/errors.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, Constructor, Dictionary, EntityMetadata, EntityProperty, IPrimaryKey } from './typings.js';
+import type { AnyEntity, Constructor, Dictionary, EntityMetadata, EntityName, EntityProperty, IPrimaryKey } from './typings.js';
 export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Error {
     readonly entity?: T | undefined;
     constructor(message: string, entity?: T | undefined);
@@ -13,7 +13,7 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     static entityNotManaged(entity: AnyEntity): ValidationError;
     static notEntity(owner: AnyEntity, prop: EntityProperty, data: any): ValidationError;
     static notDiscoveredEntity(data: any, meta?: EntityMetadata, action?: string): ValidationError;
-    static invalidPropertyName(entityName: string, invalid: string): ValidationError;
+    static invalidPropertyName(entityName: EntityName, invalid: string): ValidationError;
     static invalidCollectionValues(entityName: string, propName: string, invalid: unknown): ValidationError;
     static invalidEnumArrayItems(entityName: string, invalid: unknown): ValidationError;
     static invalidType(type: Constructor<any>, value: any, mode: string): ValidationError;
@@ -24,9 +24,9 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     static invalidCompositeIdentifier(meta: EntityMetadata): ValidationError;
     static cannotCommit(): ValidationError;
     static cannotUseGlobalContext(): ValidationError;
-    static cannotUseOperatorsInsideEmbeddables(className: string, propName: string, payload: unknown): ValidationError;
-    static cannotUseGroupOperatorsInsideScalars(className: string, propName: string, payload: unknown): ValidationError;
-    static invalidEmbeddableQuery(className: string, propName: string, embeddableType: string): ValidationError;
+    static cannotUseOperatorsInsideEmbeddables(entityName: EntityName, propName: string, payload: unknown): ValidationError;
+    static cannotUseGroupOperatorsInsideScalars(entityName: EntityName, propName: string, payload: unknown): ValidationError;
+    static invalidEmbeddableQuery(entityName: EntityName, propName: string, embeddableType: string): ValidationError;
     static invalidQueryCondition(cond: unknown): ValidationError;
 }
 export declare class CursorError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
@@ -49,11 +49,11 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static unknownIndexProperty(meta: EntityMetadata, prop: string, type: string): MetadataError;
     static multipleVersionFields(meta: EntityMetadata, fields: string[]): MetadataError;
     static invalidVersionFieldType(meta: EntityMetadata): MetadataError;
-    static fromUnknownEntity(className: string, source: string): MetadataError;
+    static fromUnknownEntity(entityName: string, source: string): MetadataError;
     static noEntityDiscovered(): MetadataError;
     static onlyAbstractEntitiesDiscovered(): MetadataError;
-    static duplicateEntityDiscovered(paths: string[], subject?: string): MetadataError;
-    static duplicateFieldName(className: string, names: [string, string][]): MetadataError;
+    static duplicateEntityDiscovered(paths: string[]): MetadataError;
+    static duplicateFieldName(entityName: EntityName, names: [string, string][]): MetadataError;
     static multipleDecorators(entityName: string, propertyName: string): MetadataError;
     static missingMetadata(entity: string): MetadataError;
     static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError<Partial<any>>;