@mikro-orm/core 7.3.0-dev.16 → 7.3.0-dev.18

package/EntityManager.js

@@ -743,10 +743,15 @@ export class EntityManager {
         if (Utils.isEmpty(options.orderBy) && !Raw.hasObjectFragments(options.orderBy)) {
             throw new Error('Explicit `orderBy` option required');
         }
+        const meta = this.metadata.get(entityName);
+        // same merge as em.find, so the cursor and the query see the same orderBy
+        if (meta.orderBy) {
+            options.orderBy = QueryHelper.mergeOrderBy(options.orderBy, meta.orderBy);
+        }
         const [entities, count] = options.includeCount !== false
             ? await em.findAndCount(entityName, options.where, options)
             : [await em.find(entityName, options.where, options)];
-        return new Cursor(entities, count, options, this.metadata.get(entityName));
+        return new Cursor(entities, count, options, meta);
     }
     /**
      * Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been
@@ -781,14 +786,38 @@ export class EntityManager {
             em.#unitOfWork.unsetIdentity(entity);
             return null;
         }
+        // `serialize()` applies `Type.toJSON()` and `serializedName`, take only relations and embeddables from it, scalars from the entity
+        const getData = (e, data = helper(e).serialize({
+            ignoreSerializers: true,
+            includeHidden: true,
+            convertCustomTypes: false,
+        })) => {
+            for (const prop of helper(e).__meta.props) {
+                if (prop.kind === ReferenceKind.SCALAR && !prop.ref) {
+                    if (helper(e).__initialized || prop.primary) {
+                        data[prop.name] = e[prop.name];
+                    }
+                    continue;
+                }
+                if (prop.serializedName && prop.serializedName in data) {
+                    data[prop.name] = data[prop.serializedName];
+                }
+                if (prop.kind === ReferenceKind.EMBEDDED && e[prop.name] != null) {
+                    Utils.asArray(e[prop.name]).forEach((item, i) => getData(item, prop.array ? data[prop.name][i] : data[prop.name]));
+                }
+            }
+            return data;
+        };
+        const hydrate = (target, source) => {
+            em.config
+                .getHydrator(this.metadata)
+                .hydrate(target, helper(target).__meta, getData(source), em.#entityFactory, 'full', false, false);
+            Utils.merge(helper(target).__originalEntityData, this.#comparator.prepareEntity(source));
+        };
         let found = false;
         for (const e of fork.#unitOfWork.getIdentityMap()) {
             const ref = em.getReference(e.constructor, helper(e).getPrimaryKey());
-            const data = helper(e).serialize({ ignoreSerializers: true, includeHidden: true, convertCustomTypes: false });
-            em.config
-                .getHydrator(this.metadata)
-                .hydrate(ref, helper(ref).__meta, data, em.#entityFactory, 'full', false, false);
-            Utils.merge(helper(ref).__originalEntityData, this.#comparator.prepareEntity(e));
+            hydrate(ref, e);
             // index a refreshed `targetKey` value, `getByKey` ignores the old one as stale
             if (helper(ref).__meta.root.targetKeys) {
                 em.#unitOfWork.getIdentityMap().store(ref);
@@ -796,15 +825,7 @@ export class EntityManager {
             found ||= ref === entity;
         }
         if (!found) {
-            const data = helper(reloaded).serialize({
-                ignoreSerializers: true,
-                includeHidden: true,
-                convertCustomTypes: false,
-            });
-            em.config
-                .getHydrator(this.metadata)
-                .hydrate(entity, wrapped.__meta, data, em.#entityFactory, 'full', false, false);
-            Utils.merge(wrapped.__originalEntityData, this.#comparator.prepareEntity(reloaded));
+            hydrate(entity, reloaded);
         }
         return entity;
     }
@@ -1025,6 +1046,15 @@ export class EntityManager {
                     where[meta.primaryKeys[0]] = ret.insertId;
                 }
             }
+            // a `null` unique value cannot identify the row, and as it never conflicts, the row was inserted
+            if (!Utils.hasObjectKeys(where)) {
+                const insertId = meta.simplePK && ret.insertId != null ? { [meta.primaryKeys[0]]: ret.insertId } : {};
+                Object.assign(where, Utils.getPrimaryKeyCond(entity, meta.primaryKeys) ?? insertId);
+            }
+            // an empty condition would hydrate the entity from an arbitrary row, mongo still gets one for nested conflict fields
+            if (!Utils.hasObjectKeys(where) && platform.usesPivotTable()) {
+                throw new Error(`Cannot find the upserted ${meta.className} row, as neither its primary key nor a unique value is known`);
+            }
             const data2 = await em.withSessionContext(options.ctx ?? em.#transactionContext, ctx => this.driver.findOne(meta.class, where, {
                 fields: returning.concat(...(options.onConflictMergeFields ?? [])),
                 ctx,
@@ -1032,6 +1062,9 @@ export class EntityManager {
                 connectionType: 'write',
                 schema: options.schema,
             }));
+            if (!data2) {
+                throw new Error(`Cannot find the upserted ${meta.className} row for condition ${JSON.stringify(where)}`);
+            }
             em.getHydrator().hydrate(entity, meta, data2, em.#entityFactory, 'full', false, true);
         }
         // recompute the data as there might be some values missing (e.g. those with db column defaults)
@@ -1183,8 +1216,10 @@ export class EntityManager {
                     unique.findIndex(p => data[p] ?? data[p.substring(0, p.indexOf('.'))] != null);
             const tmp = getWhereCondition(meta, options.onConflictFields, row, where);
             propIndex = tmp.propIndex;
+            // a partial composite PK cannot identify the row
+            const partialPK = meta.compositePK && !Utils.isPlainObject(tmp.where) && meta.primaryKeys.some(pk => row[pk] == null);
             where = QueryHelper.processWhere({
-                where: tmp.where,
+                where: partialPK ? {} : tmp.where,
                 entityName,
                 metadata: this.metadata,
                 platform: this.getPlatform(),
@@ -1199,6 +1234,25 @@ export class EntityManager {
             allWhere.push(where);
             dataIndexes.push(i);
         }
+        // mongo inserts the rows with an empty condition as part of the batch and reports their ids
+        const positional = !this.getPlatform().usesPivotTable() ||
+            ((this.getPlatform().usesReturningStatement() || this.getPlatform().usesOutputStatement()) &&
+                options.onConflictAction !== 'ignore' &&
+                !options.onConflictWhere);
+        const hasUniqueKey = !!options.onConflictFields || meta.uniques.length > 0 || meta.props.some(p => p.unique && !p.primary);
+        // only an autoincrement PK can be derived from the `insertId` of the batch
+        const autoincrement = meta.getPrimaryProps().some(p => p.autoincrement);
+        // a TPT child table does not return its rows, so they are never mapped by position
+        const peel = !!meta.tptParent || (!positional && (hasUniqueKey || !autoincrement));
+        // a row with a `null` unique value has nothing to be reloaded by, the single row path maps its PK from the insert
+        for (let idx = 0; peel && idx < allWhere.length; idx++) {
+            if (!Utils.hasObjectKeys(allWhere[idx])) {
+                result[dataIndexes[idx]] = await em.upsert(entityName, data[dataIndexes[idx]], options);
+                allData.splice(idx, 1);
+                allWhere.splice(idx, 1);
+                dataIndexes.splice(idx--, 1);
+            }
+        }
         if (allData.length === 0) {
             return [...new Set(result)];
         }
@@ -1248,7 +1302,11 @@ export class EntityManager {
         // skip the reload only when RETURNING brought back a row for every input
         // (onConflictWhere can suppress writes, leaving some rows out)
         // oxfmt-ignore
-        const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(allWhere[0]) ? Object.keys(allWhere[0]).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
+        const getUniqueFields = (where) => options.onConflictFields ?? (Utils.isPlainObject(where) ? Object.keys(where).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
+        // a row without a condition has no unique fields to derive
+        const uniqueFields = getUniqueFields(allWhere.find(cond => Utils.hasObjectKeys(cond)) ?? allWhere[0]);
+        // an empty condition identifies no row, it must not turn into a reload condition matching every row
+        const getRowUniqueFields = (where) => Utils.isPlainObject(where) && !Utils.hasObjectKeys(where) ? uniqueFields : getUniqueFields(where);
         const platform = this.getPlatform();
         const returning = getOnConflictReturningFields(meta, data[dataIndexes[0]], uniqueFields, options, platform);
         if (options.onConflictWhere && res.rows?.length !== allData.length) {
@@ -1265,10 +1323,14 @@ export class EntityManager {
                 Utils.keys(cond).forEach(key => add.add(key));
             }
             const where = { $or: [] };
+            // a row without a condition was inserted, only the primary key reported for it can identify it
+            const insertedPKs = allData.map((row, idx) => Utils.hasObjectKeys(allWhere[idx]) ? null : Utils.getPrimaryKeyCond(entitiesByData.get(row), meta.primaryKeys));
             dataIndexes.forEach((index, idx) => {
                 const item = data[index];
-                where.$or[idx] = {};
-                const props = Array.isArray(uniqueFields) ? uniqueFields : Object.keys(item);
+                where.$or[idx] = { ...insertedPKs[idx] };
+                // the inputs of one batch can be identified by different unique keys
+                const fields = insertedPKs[idx] ? [] : getRowUniqueFields(allWhere[idx]);
+                const props = Array.isArray(fields) ? fields : Object.keys(item);
                 props.forEach(prop => {
                     where.$or[idx][prop] = item[prop];
                 });
@@ -1283,8 +1345,8 @@ export class EntityManager {
                 connectionType: 'write',
                 schema: options.schema,
             }));
-            for (const [entity, cond] of loadPK.entries()) {
-                const row = data2.find(row => {
+            if (loadPK.size > 0) {
+                const comparableRows = data2.map(row => {
                     const tmp = {};
                     add.forEach(k => {
                         const prop = meta.properties[k];
@@ -1292,25 +1354,58 @@ export class EntityManager {
                             tmp[k] = prop?.customType ? prop.customType.convertToDatabaseValue(row[k], this.getPlatform()) : row[k];
                         }
                     });
-                    return this.#comparator.matching(entityName, cond, tmp);
+                    return tmp;
                 });
-                /* v8 ignore next */
-                if (!row) {
-                    throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
+                // rows carry the keys of every condition in the batch, compare only this one's
+                const isMatch = (cond, idx) => this.#comparator.matching(entityName, cond, Object.fromEntries(Object.entries(comparableRows[idx]).filter(([k]) => k in cond)));
+                // When every condition key is a comparable prop checked with `!==`, a matching row has the same primitive
+                // values, so rows can be grouped by those values once instead of comparing every row for every entity.
+                // Props outside `comparableProps` are skipped by the comparator, so they never qualify for grouping.
+                const groupableProps = new Set(meta.comparableProps.filter(prop => this.#comparator.isStrictlyCompared(prop)));
+                const groups = new Map();
+                // `null` and `undefined` share a key, which can only make a group wider than what `matching` accepts
+                const groupKey = (data, keys) => keys.map(k => (data[k] == null ? 'null' : `${typeof data[k]}:${data[k]}`)).join('\0');
+                const findRowIndex = (cond) => {
+                    const keys = Utils.keys(cond);
+                    if (!keys.every(k => groupableProps.has(meta.properties[k]))) {
+                        return comparableRows.findIndex((_, idx) => isMatch(cond, idx));
+                    }
+                    const signature = keys.join('\0');
+                    if (!groups.has(signature)) {
+                        const rowsByKey = new Map();
+                        comparableRows.forEach((tmp, idx) => {
+                            const rowKey = groupKey(tmp, keys);
+                            const indexes = rowsByKey.get(rowKey) ?? [];
+                            indexes.push(idx);
+                            rowsByKey.set(rowKey, indexes);
+                        });
+                        groups.set(signature, rowsByKey);
+                    }
+                    const group = groups.get(signature);
+                    return group.get(groupKey(cond, keys))?.find(idx => isMatch(cond, idx)) ?? -1;
+                };
+                for (const [entity, cond] of loadPK.entries()) {
+                    const row = data2[findRowIndex(cond)];
+                    /* v8 ignore next */
+                    if (!row) {
+                        throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
+                    }
+                    em.getHydrator().hydrate(entity, meta, row, em.#entityFactory, 'full', false, true);
                 }
-                em.getHydrator().hydrate(entity, meta, row, em.#entityFactory, 'full', false, true);
             }
             if (loadPK.size !== data2.length && Array.isArray(uniqueFields)) {
                 for (let i = 0; i < allData.length; i++) {
                     const data = allData[i];
-                    const cond = uniqueFields.reduce((a, b) => {
-                        // @ts-ignore
-                        a[b] = data[b];
-                        return a;
-                    }, {});
+                    const fields = (insertedPKs[i] ? meta.primaryKeys : getRowUniqueFields(allWhere[i]));
+                    const cond = insertedPKs[i] ??
+                        fields.reduce((a, b) => {
+                            // @ts-ignore
+                            a[b] = data[b];
+                            return a;
+                        }, {});
                     const entity = entitiesByData.get(data);
                     const row = data2.find(item => {
-                        const pk = uniqueFields.reduce((a, b) => {
+                        const pk = fields.reduce((a, b) => {
                             // @ts-ignore
                             a[b] = item[b];
                             return a;

package/drivers/DatabaseDriver.d.ts

@@ -81,6 +81,8 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
      */
     private mapCursorOffset;
     protected createCursorCondition<T extends object>(definition: (readonly [keyof T & string, QueryOrder])[], offsets: Dictionary[], inverse: boolean, meta: EntityMetadata<T>, fromJson?: boolean): FilterQuery<T>;
+    /** @internal Polymorphic embeddable variants can declare same-named properties with different field names. */
+    protected variantProps(prop: EntityProperty, data?: Dictionary): Dictionary<EntityProperty>;
     /** @internal */
     mapDataToFieldNames(data: Dictionary, stringifyJsonArrays: boolean, properties?: Record<string, EntityProperty>, convertCustomTypes?: boolean, object?: boolean): Dictionary;
     protected inlineEmbeddables<T extends object>(meta: EntityMetadata<T>, data: T, where?: boolean): void;

package/drivers/DatabaseDriver.js

@@ -403,6 +403,19 @@ export class DatabaseDriver {
         }
         return { ...atOrPast, ...past };
     }
+    /** @internal Polymorphic embeddable variants can declare same-named properties with different field names. */
+    variantProps(prop, data) {
+        const meta = prop.targetMeta;
+        // eslint-disable-next-line eqeqeq
+        const variant = meta?.polymorphs?.find(m => m.discriminatorValue == data?.[meta.discriminatorColumn]);
+        const props = variant ? { ...prop.embeddedProps } : prop.embeddedProps;
+        for (const p of variant ? Object.values(props) : []) {
+            if (variant.properties[p.embedded[1]] && Utils.isSameKind(variant.properties[p.embedded[1]], p)) {
+                props[p.embedded[1]] = p;
+            }
+        }
+        return props;
+    }
     /** @internal */
     mapDataToFieldNames(data, stringifyJsonArrays, properties, convertCustomTypes, object) {
         if (!properties || data == null) {
@@ -417,17 +430,17 @@ export class DatabaseDriver {
             if (prop.embeddedProps && !prop.object && !object) {
                 const copy = data[k];
                 delete data[k];
-                Object.assign(data, this.mapDataToFieldNames(copy, stringifyJsonArrays, prop.embeddedProps, convertCustomTypes));
+                Object.assign(data, this.mapDataToFieldNames(copy, stringifyJsonArrays, this.variantProps(prop, copy), convertCustomTypes));
                 return;
             }
             if (prop.embeddedProps && (object || prop.object)) {
                 const copy = data[k];
                 delete data[k];
                 if (prop.array) {
-                    data[prop.fieldNames[0]] = copy?.map((item) => this.mapDataToFieldNames(item, stringifyJsonArrays, prop.embeddedProps, convertCustomTypes, true));
+                    data[prop.fieldNames[0]] = copy?.map((item) => this.mapDataToFieldNames(item, stringifyJsonArrays, this.variantProps(prop, item), convertCustomTypes, true));
                 }
                 else {
-                    data[prop.fieldNames[0]] = this.mapDataToFieldNames(copy, stringifyJsonArrays, prop.embeddedProps, convertCustomTypes, true);
+                    data[prop.fieldNames[0]] = this.mapDataToFieldNames(copy, stringifyJsonArrays, this.variantProps(prop, copy), convertCustomTypes, true);
                 }
                 if (stringifyJsonArrays && prop.array && !object) {
                     data[prop.fieldNames[0]] = this.platform.convertJsonToDatabaseValue(data[prop.fieldNames[0]]);

package/entity/EntityAssigner.js

@@ -234,14 +234,26 @@ export class EntityAssigner {
                 entity[propName].push(...Object.values(tmp));
             });
         }
+        const polymorphs = prop.targetMeta?.polymorphs;
+        // eslint-disable-next-line eqeqeq
+        const variant = polymorphs?.find(m => m.discriminatorValue == value[prop.targetMeta.discriminatorColumn]);
         const create = () => EntityAssigner.validateEM(em) &&
-            em.getEntityFactory().createEmbeddable(prop.targetMeta.class, value, {
+            em.getEntityFactory().createEmbeddable((variant ?? prop.targetMeta).class, value, {
                 convertCustomTypes: options.convertCustomTypes,
                 newEntity: options.mergeEmbeddedProperties ? !('propName' in entity) : true,
             });
-        entity[propName] = (options.mergeEmbeddedProperties ? entity[propName] || create() : create());
+        // a different polymorphic variant cannot be merged into the current one
+        const merge = options.mergeEmbeddedProperties && (!variant || entity[propName]?.constructor === variant.class);
+        entity[propName] = (merge ? entity[propName] || create() : create());
+        const props = polymorphs ? { ...prop.embeddedProps } : prop.embeddedProps;
+        // polymorphic variants can declare same-named properties of different kinds or relation targets
+        for (const p of polymorphs ? entity[propName].__meta.props : []) {
+            if (props[p.name] && props[p.name].targetMeta?.class !== p.targetMeta?.class) {
+                props[p.name] = { ...p, nullable: prop.nullable || p.nullable };
+            }
+        }
         Object.keys(value).forEach(key => {
-            EntityAssigner.assignProperty(entity[propName], key, prop.embeddedProps, value, options);
+            EntityAssigner.assignProperty(entity[propName], key, props, value, options);
         });
     }
     static createCollectionItem(item, em, prop, invalid, options) {

package/entity/EntityFactory.d.ts

@@ -38,6 +38,13 @@ export declare class EntityFactory {
     constructor(em: EntityManager);
     /** Creates a new entity instance or returns an existing one from the identity map, hydrating it with the provided data. */
     create<T extends object, P extends string = string>(entityName: EntityName<T>, data: EntityData<T>, options?: FactoryOptions): New<T, P>;
+    /**
+     * Whether merging `data` into an initialized entity would change nothing: every key is a scalar the entity already
+     * holds by identity, and keys `mergeData` always re-applies (formula, version, generated, discriminator) match the snapshot.
+     */
+    private isNoopMerge;
+    /** Whether hydrating `value` into `prop` would leave `current` as is, mirroring the hydrator's Date and boolean coercion. */
+    private holdsValue;
     /** Merges new data into an existing entity, preserving user-modified properties. */
     mergeData<T extends object>(meta: EntityMetadata<T>, entity: T, data: EntityData<T>, options?: FactoryOptions): void;
     /** Creates or retrieves an uninitialized entity reference by its primary key or alternate key. */

package/entity/EntityFactory.js

@@ -149,8 +149,45 @@ export class EntityFactory {
         wrapped.__processing = false;
         return entity;
     }
+    /**
+     * Whether merging `data` into an initialized entity would change nothing: every key is a scalar the entity already
+     * holds by identity, and keys `mergeData` always re-applies (formula, version, generated, discriminator) match the snapshot.
+     */
+    isNoopMerge(meta, entity, data, options) {
+        const wrapped = helper(entity);
+        if (!wrapped.__initialized || options.normalizeAccessors) {
+            return false;
+        }
+        for (const key of Utils.keys(data)) {
+            const prop = meta.properties[key];
+            const value = data[key];
+            // custom types are left to the full merge, as their JS and database values can differ
+            if (!prop || prop.customType || value === undefined || !this.holdsValue(prop, entity[key], value)) {
+                return false;
+            }
+            const reapplied = prop.formula || prop.version || prop.generated || key === meta.root.discriminatorColumn;
+            if (reapplied && (wrapped.__originalEntityData?.[key] !== value || !wrapped.__loadedProperties.has(key))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /** Whether hydrating `value` into `prop` would leave `current` as is, mirroring the hydrator's Date and boolean coercion. */
+    holdsValue(prop, current, value) {
+        if (current instanceof Date && value instanceof Date) {
+            return current.getTime() === value.getTime();
+        }
+        if (prop.runtimeType === 'boolean' && value != null) {
+            return current === !!value;
+        }
+        return current === value;
+    }
     /** Merges new data into an existing entity, preserving user-modified properties. */
     mergeData(meta, entity, data, options = {}) {
+        // joined rows often repeat exactly what the entity already holds, skip the snapshot and diffing then
+        if (this.isNoopMerge(meta, entity, data, options)) {
+            return;
+        }
         // merge unchanged properties automatically
         data = QueryHelper.processParams(data);
         const existsData = this.#comparator.prepareEntity(entity);

package/entity/EntityLoader.js

@@ -312,18 +312,25 @@ export class EntityLoader {
     }
     initializeManyToMany(filtered, children, prop, field, customOrder, partial, readonly) {
         if (prop.mappedBy) {
+            // group children by owner in one pass
+            const map = new Map(filtered.map(entity => [entity, []]));
+            for (const child of children) {
+                for (const owner of child[prop.mappedBy].getItems(false)) {
+                    map.get(owner)?.push(child);
+                }
+            }
             for (const entity of filtered) {
-                const items = children.filter(child => child[prop.mappedBy].contains(entity, false));
-                entity[field].hydrate(items, true, partial, readonly);
+                entity[field].hydrate(map.get(entity), true, partial, readonly);
             }
         }
         else {
             // owning side of M:N without pivot table needs to be reordered
+            const childIndex = new Map(children.map((child, idx) => [child, idx]));
             for (const entity of filtered) {
-                const order = !customOrder ? [...entity[prop.name].getItems(false)] : []; // copy order of references
-                const items = children.filter(child => entity[prop.name].contains(child, false));
-                if (!customOrder) {
-                    items.sort((a, b) => order.indexOf(a) - order.indexOf(b));
+                // keep the order of references, or the order of loaded children when a custom order is used
+                const items = entity[prop.name].getItems(false).filter(item => childIndex.has(item));
+                if (customOrder) {
+                    items.sort((a, b) => childIndex.get(a) - childIndex.get(b));
                 }
                 entity[field].hydrate(items, true, partial, readonly);
             }
@@ -673,12 +680,20 @@ export class EntityLoader {
         const subCond = Utils.isPlainObject(where[prop.name]) ? { ...where[prop.name] } : {};
         const meta2 = prop.targetMeta;
         const pk = Utils.getPrimaryKeyHash(meta2.primaryKeys);
+        // `$not` wrapping entity conditions stays on the target entity, only operators on the relation itself map to its PK
+        const isRelationOperator = (key, value) => {
+            if (key === '$not' && Utils.isPlainObject(value)) {
+                return Utils.getObjectQueryKeys(value).every(k => Utils.isOperator(k, false));
+            }
+            return Utils.isOperator(key, false);
+        };
         ['$and', '$or'].forEach(op => {
             if (where[op]) {
                 const child = where[op]
                     .map((cond) => cond[prop.name])
                     .filter((sub) => sub != null &&
-                    !(Utils.isPlainObject(sub) && Utils.getObjectQueryKeys(sub).every(key => Utils.isOperator(key, false))))
+                    !(Utils.isPlainObject(sub) &&
+                        Utils.getObjectQueryKeys(sub).every(key => isRelationOperator(key, sub[key]))))
                     .map((cond) => {
                     if (Utils.isPrimaryKey(cond)) {
                         return { [pk]: cond };
@@ -691,7 +706,7 @@ export class EntityLoader {
                 }
             }
         });
-        const operators = Object.keys(subCond).filter(key => Utils.isOperator(key, false));
+        const operators = Object.keys(subCond).filter(key => isRelationOperator(key, subCond[key]));
         if (operators.length > 0) {
             subCond[pk] = Utils.isPlainObject(subCond[pk]) ? { ...subCond[pk] } : (subCond[pk] ?? {});
             operators.forEach(op => {
@@ -809,7 +824,7 @@ export class EntityLoader {
         if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(wrapped.__meta.properties[f].kind)) {
             return entity[f].getItems(false).every((item) => this.isPropertyLoaded(item, r.join('.')));
         }
-        return this.isPropertyLoaded(entity[f], r.join('.'));
+        return this.isPropertyLoaded(Reference.unwrapReference(entity[f]), r.join('.'));
     }
     filterReferences(entities, field, options, ref, populate) {
         if (ref) {

package/entity/defineEntity.d.ts

@@ -600,7 +600,7 @@ type EntityTarget = {
     '~entity': any;
 } | EntityClass;
 declare const propertyBuilders: PropertyBuilders;
-type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'json' | 'string' | 'text' | 'datetime' | 'time' | 'enum';
+type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'double' | 'json' | 'string' | 'text' | 'datetime' | 'time' | 'enum';
 /** Map of factory functions for creating type-safe property builders (scalars, enums, embeddables, and relations). */
 export type PropertyBuilders = {
     [K in Exclude<keyof typeof types, PropertyBuildersOverrideKeys>]: () => UniversalPropertyOptionsBuilder<InferPropertyValueType<(typeof types)[K]>, EmptyOptions, IncludeKeysForProperty>;
@@ -608,6 +608,7 @@ export type PropertyBuilders = {
     bigint: <Mode extends 'bigint' | 'number' | 'string' = 'bigint'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.bigint<Mode>>, EmptyOptions, IncludeKeysForProperty>;
     array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.array<T>>, EmptyOptions, IncludeKeysForProperty>;
     decimal: <Mode extends 'number' | 'string' = 'string'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.decimal<Mode>>, EmptyOptions, IncludeKeysForProperty>;
+    double: <Mode extends 'number' | 'string' = 'number'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.double<Mode>>, EmptyOptions, IncludeKeysForProperty>;
     json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
     string: () => StringPropertyOptionsBuilder<InferPropertyValueType<typeof types.string>, EmptyOptions>;
     text: () => StringPropertyOptionsBuilder<InferPropertyValueType<typeof types.text>, EmptyOptions>;
@@ -637,6 +638,21 @@ type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends t
 type PartialWhere<TProperties, TBase> = string | FilterQuery<{
     [K in AllKeys<TProperties, TBase> & string]?: unknown;
 }>;
+type DefineEntityFilterMap = Dictionary<{
+    name: string;
+    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>, entityName?: string) => MaybePromise<FilterQuery<any>>);
+    default?: boolean;
+    entity?: EntityName<any> | EntityName<any>[];
+    args?: boolean;
+    strict?: boolean;
+    rls?: boolean | {
+        setting?: string;
+    };
+}>;
+type DefineEntityFilterMapLoose = Dictionary<{
+    name: string;
+    cond: Dictionary;
+}>;
 /** Metadata descriptor for `defineEntity()`, combining entity options with property definitions. */
 export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false, TDiscriminatorColumn extends string | undefined = undefined, TDiscriminatorValue extends string | number | undefined = undefined, TBaseDiscriminatorColumn extends string | undefined = undefined, TEmbeddable extends boolean = false, TForceUndefined extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminator' | 'discriminatorColumn' | 'discriminatorValue' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'triggers' | 'repository' | 'filters' | 'orderBy'> {
     name: TName;
@@ -648,20 +664,10 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         '~discriminatorColumn'?: TBaseDiscriminatorColumn;
     });
     properties: TProperties | ((properties: PropertyBuilders) => TProperties);
-    primaryKeys?: TPK & InferPrimaryKeyConstraint<TProperties>[];
+    primaryKeys?: TPK & NoInfer<InferPrimaryKeyConstraint<TProperties>>[];
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
-    filters?: Dictionary<{
-        name: string;
-        cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>, entityName?: string) => MaybePromise<FilterQuery<any>>);
-        default?: boolean;
-        entity?: EntityName<any> | EntityName<any>[];
-        args?: boolean;
-        strict?: boolean;
-        rls?: boolean | {
-            setting?: string;
-        };
-    }>;
+    filters?: DefineEntityFilterMap | IsNever<TRepository, never, DefineEntityFilterMapLoose>;
     forceObject?: TForceObject;
     /** Hydrate `null` as `undefined` for this entity and infer nullable properties as `T | undefined`. */
     forceUndefined?: TForceUndefined;
@@ -676,16 +682,16 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     /** Alias for `discriminator`. */
     discriminatorColumn?: TDiscriminatorColumn;
     discriminatorValue?: TDiscriminatorValue;
-    versionProperty?: AllKeys<TProperties, TBase>;
-    concurrencyCheckKeys?: Set<AllKeys<TProperties, TBase>>;
-    serializedPrimaryKey?: AllKeys<TProperties, TBase>;
+    versionProperty?: NoInfer<AllKeys<TProperties, TBase>>;
+    concurrencyCheckKeys?: Set<NoInfer<AllKeys<TProperties, TBase>>>;
+    serializedPrimaryKey?: NoInfer<AllKeys<TProperties, TBase>>;
     indexes?: {
         properties?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
         name?: string;
         type?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
-        where?: PartialWhere<TProperties, TBase>;
+        where?: NoInfer<PartialWhere<TProperties, TBase>>;
         columns?: IndexColumnOptions[];
         include?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
         fillFactor?: number;
@@ -698,7 +704,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         name?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
-        where?: PartialWhere<TProperties, TBase>;
+        where?: NoInfer<PartialWhere<TProperties, TBase>>;
         deferMode?: DeferMode | `${DeferMode}`;
         columns?: IndexColumnOptions[];
         include?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];

package/entity/defineEntity.js

@@ -519,6 +519,7 @@ const propertyBuilders = {
     bigint: (mode) => new UniversalPropertyOptionsBuilder({ type: new types.bigint(mode) }),
     array: (toJsValue = i => i, toDbValue = i => i) => new UniversalPropertyOptionsBuilder({ type: new types.array(toJsValue, toDbValue) }),
     decimal: (mode) => new UniversalPropertyOptionsBuilder({ type: new types.decimal(mode) }),
+    double: (mode) => new UniversalPropertyOptionsBuilder({ type: new types.double(mode) }),
     json: () => new UniversalPropertyOptionsBuilder({ type: types.json }),
     string: () => new StringPropertyOptionsBuilder({
         type: types.string,

package/entity/validators.js

@@ -24,7 +24,10 @@ export function validateProperty(prop, givenValue, entity) {
 }
 function getValue(o, prop) {
     if (prop.embedded && prop.embedded[0] in o) {
-        return o[prop.embedded[0]]?.[prop.embedded[1]];
+        const embeddable = o[prop.embedded[0]];
+        const variantProp = embeddable?.__meta?.properties[prop.embedded[1]];
+        // a same-named property of a different kind in another polymorphic variant
+        return variantProp && !Utils.isSameKind(variantProp, prop) ? undefined : embeddable?.[prop.embedded[1]];
     }
     /* v8 ignore next */
     if (prop.ref) {

package/hydration/ObjectHydrator.js

@@ -313,6 +313,10 @@ export class ObjectHydrator extends Hydrator {
                             ? dataKey + this.wrap(childProp.embedded[1])
                             : this.wrap(childProp.name);
                         const prop2 = childMeta.properties[childProp.embedded[1]];
+                        // a same-named property of a different kind in another variant
+                        if (prop2 && !Utils.isSameKind(prop2, childProp)) {
+                            return;
+                        }
                         const prop3 = {
                             ...prop2,
                             name: childProp.name,

package/metadata/MetadataDiscovery.d.ts

@@ -34,6 +34,11 @@ export declare class MetadataDiscovery {
     private initManyToOneFields;
     private initOneToManyFields;
     private processEntity;
+    /**
+     * Groups the relations of all entities by target class name in one pass, so `findReferencingProperties()`
+     * does not go over the relations of every entity for each entity. Lists keep the order of `metadata` and `relations`.
+     */
+    private indexReferencingProperties;
     private findReferencingProperties;
     private initFactoryField;
     private ensureCorrectFKOrderInPivotEntity;