@mikro-orm/core 7.2.2-dev.8 → 7.2.2

package/EntityManager.d.ts

@@ -580,6 +580,11 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * Checks whether this EntityManager is currently operating inside a database transaction.
      */
     isInTransaction(): boolean;
+    /**
+     * Checks whether transactions are disabled for this EntityManager.
+     * @internal
+     */
+    isTransactionDisabled(): boolean;
     /**
      * Gets the transaction context (driver dependent object used to make sure queries are executed on same connection).
      */
@@ -633,7 +638,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     /**
      * @internal
      */
-    tryCache<T extends object, R>(entityName: EntityName<T>, config: boolean | number | [string, number] | undefined, key: unknown, refresh?: boolean, merge?: boolean): Promise<{
+    tryCache<T extends object, R>(entityName: EntityName<T>, config: boolean | number | [string, number] | undefined, key: unknown, refresh?: boolean, merge?: boolean, schema?: string): Promise<{
         data?: R | null;
         key: string;
     } | undefined>;

package/EntityManager.js

@@ -133,7 +133,7 @@ export class EntityManager {
         options.populate = (await em.preparePopulate(entityName, options));
         const populate = options.populate;
         const cacheKey = em.cacheKey(entityName, options, 'em.find', where);
-        const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true);
+        const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true, options.schema);
         if (cached?.data) {
             await em.#entityLoader.populate(entityName, cached.data, populate, {
                 ...options,
@@ -789,6 +789,10 @@ export class EntityManager {
                 .getHydrator(this.metadata)
                 .hydrate(ref, helper(ref).__meta, data, em.#entityFactory, 'full', false, false);
             Utils.merge(helper(ref).__originalEntityData, this.#comparator.prepareEntity(e));
+            // index a refreshed `targetKey` value, `getByKey` ignores the old one as stale
+            if (helper(ref).__meta.root.targetKeys) {
+                em.#unitOfWork.getIdentityMap().store(ref);
+            }
             found ||= ref === entity;
         }
         if (!found) {
@@ -834,7 +838,7 @@ export class EntityManager {
         validateParams(where);
         options.populate = (await em.preparePopulate(entityName, options));
         const cacheKey = em.cacheKey(entityName, options, 'em.findOne', where);
-        const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true);
+        const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true, options.schema);
         if (cached?.data !== undefined) {
             if (cached.data) {
                 await em.#entityLoader.populate(entityName, [cached.data], options.populate, {
@@ -1110,7 +1114,18 @@ export class EntityManager {
                 const ret = [];
                 for (const idx of shapes.values()) {
                     const res = await this.upsertMany(entityName, idx.map(i => data[i]), options);
-                    idx.forEach((i, j) => (ret[i] = res[j]));
+                    const seen = new Set();
+                    let j = 0;
+                    // `res` holds every entity once, so skip the rows resolving to an entity an earlier row already took
+                    for (const i of idx) {
+                        const row = data[i];
+                        const entity = Utils.isEntity(row)
+                            ? row
+                            : em.#unitOfWork.tryGetById(entityName, row, options.schema, false);
+                        if (!seen.has(entity)) {
+                            seen.add((ret[i] = res[j++]));
+                        }
+                    }
                 }
                 // rows resolving to the same entity are returned once, as in the single statement path
                 return [...new Set(ret.filter(entity => entity))];
@@ -1123,9 +1138,10 @@ export class EntityManager {
         const generatedFields = new Set();
         const allData = [];
         const allWhere = [];
+        const dataIndexes = [];
+        const result = [];
         const entities = new Map();
         const entitiesByData = new Map();
-        const entitiesByAllDataIdx = new Map();
         for (let i = 0; i < data.length; i++) {
             let row = data[i];
             let where;
@@ -1133,14 +1149,12 @@ export class EntityManager {
                 const entity = row;
                 if (helper(entity).__managed && helper(entity).__em === em && !this.config.get('upsertManaged')) {
                     em.#entityFactory.mergeData(meta, entity, row, { initialized: true });
-                    entities.set(entity, row);
-                    entitiesByData.set(row, entity);
+                    result[i] = entity;
                     continue;
                 }
                 where = helper(entity).getPrimaryKey();
                 getOnCreateGeneratedFields(meta, entity).forEach(field => generatedFields.add(field));
                 em.#entityFactory.assignDefaultValues(entity, meta);
-                entitiesByAllDataIdx.set(allData.length, entity);
                 row = em.#comparator.prepareEntity(entity);
             }
             else {
@@ -1150,8 +1164,7 @@ export class EntityManager {
                     const exists = em.#unitOfWork.getById(entityName, where, options.schema);
                     if (exists) {
                         em.assign(exists, row);
-                        entities.set(exists, row);
-                        entitiesByData.set(row, exists);
+                        result[i] = exists;
                         continue;
                     }
                 }
@@ -1184,22 +1197,25 @@ export class EntityManager {
             validateParams(row, 'insert data');
             allData.push(row);
             allWhere.push(where);
+            dataIndexes.push(i);
         }
-        if (entities.size === data.length) {
-            return [...entities.keys()];
+        if (allData.length === 0) {
+            return [...new Set(result)];
         }
         // `onCreate` generated values are for the insert clause only, they must not overwrite existing rows
         if (generatedFields.size > 0 && !options.onConflictMergeFields) {
             options.onConflictExcludeFields = [...(options.onConflictExcludeFields ?? []), ...generatedFields];
         }
         if (em.eventManager.hasListeners(EventType.beforeUpsert, meta)) {
-            for (const dto of data) {
-                const entity = entitiesByData.get(dto) ?? dto;
+            for (const index of dataIndexes) {
+                const entity = data[index];
                 await em.eventManager.dispatchEvent(EventType.beforeUpsert, { entity, em, meta }, meta);
             }
-            for (const [idx, entity] of entitiesByAllDataIdx) {
-                allData[idx] = em.#comparator.prepareEntity(entity);
-            }
+            dataIndexes.forEach((index, idx) => {
+                if (Utils.isEntity(data[index])) {
+                    allData[idx] = em.#comparator.prepareEntity(data[index]);
+                }
+            });
         }
         const res = await em.withSessionContext(options.ctx ?? em.#transactionContext, ctx => em.driver.nativeUpdateMany(entityName, allWhere, allData, {
             upsert: true,
@@ -1207,15 +1223,16 @@ export class EntityManager {
             ...options,
             ctx,
         }));
-        entities.clear();
-        entitiesByData.clear();
         const loadPK = new Map();
         allData.forEach((row, i) => {
-            em.#unitOfWork.getChangeSetPersister().mapReturnedValues(Utils.isEntity(data[i]) ? data[i] : null, Utils.isEntity(data[i]) ? {} : data[i], 
+            // Managed inputs skipped by the SQL batch still occupy positions in `data`.
+            const index = dataIndexes[i];
+            const item = data[index];
+            em.#unitOfWork.getChangeSetPersister().mapReturnedValues(Utils.isEntity(item) ? item : null, Utils.isEntity(item) ? {} : item, 
             // A suppressed conflict omits its row; positional mapping would hydrate a different entity.
             res.rows?.length === allData.length ? res.rows[i] : undefined, meta, true);
-            const entity = Utils.isEntity(data[i])
-                ? data[i]
+            const entity = Utils.isEntity(item)
+                ? item
                 : em.#entityFactory.create(entityName, row, {
                     refresh: true,
                     initialized: true,
@@ -1226,18 +1243,19 @@ export class EntityManager {
             }
             entities.set(entity, row);
             entitiesByData.set(row, entity);
+            result[index] = entity;
         });
         // 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 platform = this.getPlatform();
-        const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options, platform);
+        const returning = getOnConflictReturningFields(meta, data[dataIndexes[0]], uniqueFields, options, platform);
         if (options.onConflictWhere && res.rows?.length !== allData.length) {
             returning.push(...meta.comparableProps.filter(p => !p.lazy && !p.embeddable).map(p => p.name));
         }
         const reloadFields = returning.length > 0 &&
-            !((platform.usesReturningStatement() || platform.usesOutputStatement()) && res.rows?.length === data.length);
+            !((platform.usesReturningStatement() || platform.usesOutputStatement()) && res.rows?.length === allData.length);
         if (options.onConflictAction === 'ignore' || (!res.rows?.length && loadPK.size > 0) || reloadFields) {
             const unique = meta.hydrateProps.filter(p => !p.lazy).map(p => p.name);
             const add = new Set(propIndex !== false && propIndex >= 0
@@ -1247,7 +1265,8 @@ export class EntityManager {
                 Utils.keys(cond).forEach(key => add.add(key));
             }
             const where = { $or: [] };
-            data.forEach((item, idx) => {
+            dataIndexes.forEach((index, idx) => {
+                const item = data[index];
                 where.$or[idx] = {};
                 const props = Array.isArray(uniqueFields) ? uniqueFields : Object.keys(item);
                 props.forEach(prop => {
@@ -1317,7 +1336,7 @@ export class EntityManager {
                 await em.eventManager.dispatchEvent(EventType.afterUpsert, { entity, em, meta }, meta);
             }
         }
-        return [...entities.keys()];
+        return [...new Set(result)];
     }
     /**
      * Runs your callback wrapped inside a database transaction.
@@ -1974,6 +1993,13 @@ export class EntityManager {
     isInTransaction() {
         return !!this.getContext(false).#transactionContext;
     }
+    /**
+     * Checks whether transactions are disabled for this EntityManager.
+     * @internal
+     */
+    isTransactionDisabled() {
+        return !!this.getContext(false).#disableTransactions;
+    }
     /**
      * Gets the transaction context (driver dependent object used to make sure queries are executed on same connection).
      */
@@ -2329,7 +2355,7 @@ export class EntityManager {
     /**
      * @internal
      */
-    async tryCache(entityName, config, key, refresh, merge) {
+    async tryCache(entityName, config, key, refresh, merge, schema) {
         config ??= this.config.get('resultCache').global;
         if (!config) {
             return undefined;
@@ -2351,6 +2377,7 @@ export class EntityManager {
             merge: true,
             convertCustomTypes: false,
             refresh,
+            schema,
             recomputeSnapshot: true,
         };
         if (Array.isArray(cached) && merge) {

package/entity/EntityFactory.d.ts

@@ -51,6 +51,7 @@ export declare class EntityFactory {
     assignDefaultValues<T extends object>(entity: T, meta: EntityMetadata<T>, onCreateOnly?: boolean): void;
     private hydrate;
     private findEntity;
+    private findEntityByPrimaryKey;
     private processDiscriminatorColumn;
     /**
      * denormalize PK to value required by driver (e.g. ObjectId)

package/entity/EntityFactory.js

@@ -55,6 +55,10 @@ export class EntityFactory {
             Utils.dropUndefinedProperties(data);
             this.mergeData(meta2, exists, data, options);
             wrapped.__processing = false;
+            // index a merged `targetKey` value, `getByKey` ignores the old one as stale
+            if (meta2.root.targetKeys) {
+                this.unitOfWork.getIdentityMap().store(exists);
+            }
             wrapped.__initialized ||= !!options.initialized;
             if (wrapped.isInitialized()) {
                 if (!wasInitialized) {
@@ -232,9 +236,9 @@ export class EntityFactory {
         options.convertCustomTypes ??= true;
         const meta = this.#metadata.get(entityName);
         const schema = this.#driver.getSchemaName(meta, options);
-        // Handle alternate key lookup
-        if (options.key) {
-            const value = '' + (Array.isArray(id) ? id[0] : Utils.isPlainObject(id) ? id[options.key] : id);
+        // Handle alternate key lookup, a `key` pointing at the single PK is a plain PK reference
+        if (options.key && !(meta.primaryKeys.length === 1 && meta.primaryKeys[0] === options.key)) {
+            const value = Array.isArray(id) ? id[0] : Utils.isPlainObject(id) ? id[options.key] : id;
             const exists = this.unitOfWork.getByKey(entityName, options.key, value, schema, options.convertCustomTypes);
             if (exists) {
                 return exists;
@@ -242,6 +246,8 @@ export class EntityFactory {
             // Create entity stub - storeByKey will set the alternate key property and store in identity map
             const entity = this.create(entityName, {}, { ...options, initialized: false });
             this.unitOfWork.storeByKey(entity, options.key, value, schema, options.convertCustomTypes);
+            // snapshot the stub like a PK reference, so flush treats it as existing instead of inserting it
+            helper(entity).__originalEntityData = this.#comparator.prepareEntity(entity);
             return entity;
         }
         if (meta.simplePK) {
@@ -310,6 +316,12 @@ export class EntityFactory {
         if (options.merge && !options.newEntity) {
             this.#hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, options.parentSchema);
             this.unitOfWork.register(entity);
+            // relations hydrated together with this entity (joined strategy) resolve it via `targetKey` before it is hydrated
+            for (const key of meta.root.targetKeys ?? []) {
+                if (data[key] != null) {
+                    this.unitOfWork.storeByKey(entity, key, data[key], schema, options.convertCustomTypes);
+                }
+            }
         }
         if (options.initialized) {
             EntityHelper.ensurePropagation(entity);
@@ -379,6 +391,23 @@ export class EntityFactory {
     }
     findEntity(data, meta, options) {
         const schema = this.#driver.getSchemaName(meta, options);
+        const exists = this.findEntityByPrimaryKey(data, meta, schema, options);
+        // a new entity must not adopt a reference stub, that one is never inserted
+        if (exists || Array.isArray(data) || options.newEntity) {
+            return exists;
+        }
+        // a reference created via `targetKey` is only known by that key until the entity is loaded
+        for (const key of meta.root.targetKeys ?? []) {
+            if (data[key] != null) {
+                const ref = this.unitOfWork.getByKey(meta.class, key, data[key], schema, options.convertCustomTypes);
+                if (ref && !helper(ref).__initialized) {
+                    return ref;
+                }
+            }
+        }
+        return undefined;
+    }
+    findEntityByPrimaryKey(data, meta, schema, options) {
         if (meta.simplePK) {
             return this.unitOfWork.getById(meta.class, data[meta.primaryKeys[0]], schema);
         }

package/entity/EntityLoader.js

@@ -197,9 +197,9 @@ export class EntityLoader {
         this.initializeCollections(filtered, prop, field, items, customOrder, isPartial, hasLimit);
         return items;
     }
-    async populateScalar(meta, filtered, options) {
-        const pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
-        const ids = Utils.unique(filtered.map(e => Utils.getPrimaryKeyValues(e, meta, true)));
+    async populateScalar(meta, filtered, options, key) {
+        const pk = (key ?? Utils.getPrimaryKeyHash(meta.primaryKeys));
+        const ids = Utils.unique(filtered.map(e => (key ? e[key] : 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.class, where, {
@@ -221,7 +221,8 @@ export class EntityLoader {
         const needsFkLoad = [];
         for (const entity of entities) {
             const refValue = entity[prop.name];
-            if (refValue && helper(refValue).hasPrimaryKey()) {
+            // a `targetKey` reference is identified by its key, it might not have the PK yet
+            if (refValue && helper(refValue).getTargetKeyValue(prop.targetKey) != null) {
                 if ((ref && !options.refresh) || // :ref hint - already have reference
                     (!ref && helper(refValue).__initialized && !options.refresh) // already loaded
                 ) {
@@ -246,7 +247,7 @@ export class EntityLoader {
             if (!ref) {
                 for (const entity of needsFkLoad) {
                     const refValue = entity[prop.name];
-                    if (refValue && helper(refValue).hasPrimaryKey()) {
+                    if (refValue && helper(refValue).getTargetKeyValue(prop.targetKey) != null) {
                         toPopulate.push(entity);
                     }
                 }
@@ -268,7 +269,7 @@ export class EntityLoader {
         const allItems = [];
         await Promise.all([...groups].map(async ([discriminator, children]) => {
             const targetMeta = this.#metadata.find(prop.discriminatorMap[discriminator]);
-            await this.populateScalar(targetMeta, children, options);
+            await this.populateScalar(targetMeta, children, options, prop.targetKey);
             allItems.push(...children);
         }));
         return allItems;

package/entity/WrappedEntity.js

@@ -83,7 +83,12 @@ export class WrappedEntity {
         if (!this.__em) {
             throw ValidationError.entityNotManaged(this.entity);
         }
-        return this.__em.findOne(this.entity.constructor, this.entity, {
+        // a reference known only by its `targetKey` has no PK, so look it up by the key instead
+        const key = this.hasPrimaryKey()
+            ? undefined
+            : this.__meta.root.targetKeys?.find(k => this.entity[k] != null);
+        const where = key ? { [key]: this.entity[key] } : this.entity;
+        return this.__em.findOne(this.entity.constructor, where, {
             ...options,
             refresh: true,
             schema: this.__schema,

package/errors.d.ts

@@ -10,6 +10,7 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     static fromWrongPropertyType(entity: AnyEntity, property: string, expectedType: string, givenType: string, givenValue: string): ValidationError;
     static fromWrongRepositoryType(entityName: string, repoType: string, method: string): ValidationError;
     static fromMergeWithoutPK(meta: EntityMetadata): ValidationError;
+    static referenceWithoutPK(entity: AnyEntity): ValidationError;
     static transactionRequired(): ValidationError;
     static entityNotManaged(entity: AnyEntity): ValidationError;
     static notEntity(owner: AnyEntity, prop: EntityProperty, data: any): ValidationError;

package/errors.js

@@ -28,6 +28,9 @@ export class ValidationError extends Error {
     static fromMergeWithoutPK(meta) {
         return new ValidationError(`You cannot merge entity '${meta.className}' without identifier!`);
     }
+    static referenceWithoutPK(entity) {
+        return new ValidationError(`Entity '${entity.constructor.name}' is only known by an alternate key and has no primary key, load it first`, entity);
+    }
     static transactionRequired() {
         return new ValidationError('An open transaction is required for this operation');
     }

package/hydration/ObjectHydrator.js

@@ -207,7 +207,7 @@ export class ObjectHydrator extends Hydrator {
             if (prop.customType?.ensureComparable(meta, prop)) {
                 registerCustomType(prop, this.safeKey(prop.name), 'convertToDatabaseValue', context);
                 ret.push(`  if (data${dataKey} != null && typeof data${dataKey} !== 'object' && convertCustomTypes) {`);
-                ret.push(`    data${dataKey} = convertToDatabaseValue_${this.safeKey(prop.name)}(entity${entityKey}.__helper.getPrimaryKey());`);
+                ret.push(`    data${dataKey} = convertToDatabaseValue_${this.safeKey(prop.name)}(entity${entityKey}.__helper.getTargetKeyValue(${prop.targetKey ? this.quote(prop.targetKey) : ''}));`);
                 ret.push(`  }`);
             }
             return ret;
@@ -407,7 +407,7 @@ export class ObjectHydrator extends Hydrator {
         const code = `// compiled hydrator for entity ${meta.className} (${type + normalizeAccessors ? ' normalized' : ''})\n` +
             `return function(entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema, normalizeAccessors) {\n` +
             `${lines.join('\n')}\n}`;
-        const fnKey = `hydrator-${meta.uniqueName}-${type}-${normalizeAccessors}`;
+        const fnKey = `hydrator-${meta.compiledName}-${type}-${normalizeAccessors}`;
         const hydrator = Utils.createFunction(context, code, this.config.get('compiledFunctions'), fnKey);
         this.#hydrators[key].set(meta.class, hydrator);
         return hydrator;

package/metadata/MetadataDiscovery.js

@@ -547,7 +547,7 @@ export class MetadataDiscovery {
             const fieldNames1 = prop.targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
             const idColumns = fieldNames1.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.discriminator, fieldName, fieldNames1.length > 1));
             prop.fieldNames ??= [prop.discriminatorColumn, ...idColumns];
-            prop.joinColumns ??= idColumns;
+            prop.joinColumns ??= prop.fieldNames.slice(1);
             prop.referencedColumnNames ??= fieldNames1;
             prop.referencedTableName ??= prop.targetMeta.tableName;
             return;
@@ -564,7 +564,10 @@ export class MetadataDiscovery {
         }
         Utils.defaultValue(prop, 'referencedTableName', meta2.tableName);
         if (!prop.joinColumns) {
-            prop.joinColumns = fieldNames.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.name, fieldName, fieldNames.length > 1));
+            // must match the real FK columns, which ignore `targetKey` naming for simple PK targets
+            prop.joinColumns = prop.targetKey
+                ? prop.fieldNames
+                : fieldNames.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.name, fieldName, fieldNames.length > 1));
         }
         if (!prop.referencedColumnNames) {
             prop.referencedColumnNames = fieldNames;
@@ -670,6 +673,12 @@ export class MetadataDiscovery {
                 if (prop2.kind !== ReferenceKind.SCALAR && prop2.type === meta.className) {
                     meta.referencingProperties.push({ meta: meta2, prop: prop2 });
                 }
+                if (prop2.targetKey &&
+                    (prop2.type === meta.className || prop2.polymorphTargets?.some(t => t.className === meta.className)) &&
+                    !(meta.primaryKeys.length === 1 && meta.primaryKeys[0] === prop2.targetKey) &&
+                    !meta.root.targetKeys?.includes(prop2.targetKey)) {
+                    (meta.root.targetKeys ??= []).push(prop2.targetKey);
+                }
             }
         }
     }
@@ -1174,12 +1183,24 @@ export class MetadataDiscovery {
         if (!prop.discriminator && !prop.discriminatorColumn && !prop.discriminatorMap && !Array.isArray(prop.target)) {
             return;
         }
+        const isToOne = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind);
+        const isUnionTargetMN = prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(prop.target);
         prop.polymorphic = true;
         prop.discriminator ??= prop.name;
+        // explicit `fieldNames` use the `[discriminatorColumn, ...fkIdColumns]` layout
+        if (isToOne && prop.fieldNames && prop.fieldNames.length > 1) {
+            prop.discriminatorColumn ??= prop.fieldNames[0];
+            // `EntitySchema` mirrors `fieldNames` into `joinColumns`, let `initManyToOneFields` derive them after embedded prefixing
+            if (Utils.equals(prop.joinColumns, prop.fieldNames)) {
+                delete prop.joinColumns;
+            }
+        }
         prop.discriminatorColumn ??= this.#namingStrategy.discriminatorColumnName(prop.discriminator);
         prop.createForeignKeyConstraint = false;
-        const isToOne = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind);
-        const isUnionTargetMN = prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(prop.target);
+        // a single field name can only be the FK column, e.g. mirrored from `joinColumn`
+        if (isToOne && prop.fieldNames?.length === 1) {
+            prop.fieldNames = [prop.discriminatorColumn, ...prop.fieldNames];
+        }
         if (isToOne || isUnionTargetMN) {
             const types = prop.type.split(/ ?\| ?/);
             prop.polymorphTargets = discovered.filter(m => types.includes(m.className) && !m.embeddable);
@@ -1439,7 +1460,8 @@ export class MetadataDiscovery {
                     }
                 }
                 rootProp.stiFieldNameMap[meta.discriminatorValue] = prop.fieldNames[0];
-                rootProp.stiFieldNames.push(...prop.fieldNames);
+                // subtypes that only differ in type share the column
+                rootProp.stiFieldNames = Utils.unique([...rootProp.stiFieldNames, ...prop.fieldNames]);
                 newProp.nullable = true;
                 newProp.name = name;
                 newProp.hydrate = false;

package/metadata/MetadataStorage.d.ts

@@ -32,6 +32,13 @@ export declare class MetadataStorage {
     getById<T>(id: number): EntityMetadata<T>;
     /** Returns metadata by class name, optionally throwing if not found. */
     getByClassName<T = any, V extends boolean = true>(className: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
+    /**
+     * Returns the first registered metadata with the given table name, in registration order (entities sharing
+     * a table, like STI children, resolve to the one registered first). The index is built on first use, as table
+     * names are only final once discovery has finished.
+     * @internal
+     */
+    getByTableName<T = any>(tableName: string): EntityMetadata<T> | undefined;
     /** Returns metadata by unique name, optionally throwing if not found. */
     getByUniqueName<T = any, V extends boolean = true>(uniqueName: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
     private validate;

package/metadata/MetadataStorage.js

@@ -18,6 +18,8 @@ export class MetadataStorage {
     #classNameMap;
     #uniqueNameMap;
     #ambiguousNames = new Set();
+    /** Built on first use by `getByTableName()`, dropped whenever an entity is registered or removed. */
+    #tableNameMap;
     constructor(metadata = {}) {
         this.#idMap = {};
         this.#uniqueNameMap = {};
@@ -102,6 +104,7 @@ export class MetadataStorage {
     /** Registers metadata for the given entity. */
     set(entityName, meta) {
         this.#metadataMap.set(entityName, meta);
+        this.#tableNameMap = undefined;
         this.#idMap[meta._id] = meta;
         this.#uniqueNameMap[meta.uniqueName] = meta;
         const className = Utils.className(entityName);
@@ -110,6 +113,12 @@ export class MetadataStorage {
         if (existing && existing !== meta && existing.class !== meta.class) {
             this.#ambiguousNames.add(className);
         }
+        // colliding names are numbered in storage order, which follows the discovery config, not module evaluation
+        const sameName = this.#ambiguousNames.has(className)
+            ? [...new Set(this.#metadataMap.values())].filter(m => m.className === meta.className)
+            : [meta];
+        const ordinal = sameName.indexOf(meta);
+        meta.compiledName = ordinal > 0 ? `${meta.className}#${ordinal}` : meta.className;
         this.#classNameMap[className] = meta;
         return meta;
     }
@@ -118,6 +127,7 @@ export class MetadataStorage {
         const meta = this.find(entityName);
         if (meta) {
             this.#metadataMap.delete(meta.class);
+            this.#tableNameMap = undefined;
             delete this.#idMap[meta._id];
             delete this.#uniqueNameMap[meta.uniqueName];
             delete this.#classNameMap[meta.className];
@@ -145,6 +155,23 @@ export class MetadataStorage {
     getByClassName(className, validate = true) {
         return this.validate(this.#classNameMap[className], className, validate);
     }
+    /**
+     * Returns the first registered metadata with the given table name, in registration order (entities sharing
+     * a table, like STI children, resolve to the one registered first). The index is built on first use, as table
+     * names are only final once discovery has finished.
+     * @internal
+     */
+    getByTableName(tableName) {
+        if (!this.#tableNameMap) {
+            this.#tableNameMap = new Map();
+            for (const meta of this.#metadataMap.values()) {
+                if (!this.#tableNameMap.has(meta.tableName)) {
+                    this.#tableNameMap.set(meta.tableName, meta);
+                }
+            }
+        }
+        return this.#tableNameMap.get(tableName);
+    }
     /** Returns metadata by unique name, optionally throwing if not found. */
     getByUniqueName(uniqueName, validate = true) {
         return this.validate(this.#uniqueNameMap[uniqueName], uniqueName, validate);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.2-dev.8",
+  "version": "7.2.2",
   "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.",
   "keywords": [
     "data-mapper",

package/typings.d.ts

@@ -1173,6 +1173,7 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
         meta: EntityMetadata<Entity>;
         prop: EntityProperty<Entity>;
     }[];
+    targetKeys?: EntityKey<Entity>[];
     comparableProps: EntityProperty<Entity>[];
     trackingProps: EntityProperty<Entity>[];
     hydrateProps: EntityProperty<Entity>[];
@@ -1254,6 +1255,8 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     orderBy?: QueryOrderMap<Entity> | QueryOrderMap<Entity>[];
     /** @internal can be used for computed numeric cache keys */
     readonly _id: number;
+    /** @internal name that does not depend on module evaluation order (unlike `_id`), used to key `compiledFunctions` */
+    compiledName?: string;
 }
 /** Options for `ISchemaGenerator.create()`. */
 export interface CreateSchemaOptions {

package/unit-of-work/ChangeSetComputer.js

@@ -7,6 +7,7 @@ import { Reference } from '../entity/Reference.js';
 import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { ReferenceKind } from '../enums.js';
 import { isRaw } from '../utils/RawQueryFragment.js';
+import { ValidationError } from '../errors.js';
 /** @internal Computes change sets by comparing entity state against original snapshots. */
 export class ChangeSetComputer {
     #comparator;
@@ -48,6 +49,10 @@ export class ChangeSetComputer {
             if (Utils.equals(data, wrapped.__originalEntityData)) {
                 return null;
             }
+            // a reference known only by its `targetKey` has no PK, so the update would have no condition
+            if (!wrapped.hasPrimaryKey()) {
+                throw ValidationError.referenceWithoutPK(entity);
+            }
         }
         const changeSet = new ChangeSet(entity, type, this.computePayload(entity), meta);
         changeSet.originalEntity = wrapped.__originalEntityData;
@@ -162,21 +167,30 @@ export class ChangeSetComputer {
             const target = Reference.unwrapReference(rawTarget);
             const needsProcessing = target != null && (prop.targetKey != null || !target.__helper.hasPrimaryKey());
             if (needsProcessing) {
+                // a reference known only by its `targetKey` has no PK, and is never inserted to generate one
+                if (!prop.targetKey && !target.__helper.__initialized) {
+                    throw ValidationError.referenceWithoutPK(target);
+                }
                 let value = prop.targetKey ? target[prop.targetKey] : target.__helper.__identifier;
-                /* v8 ignore next */
-                if (prop.targetKey && prop.targetMeta) {
-                    const targetProp = prop.targetMeta.properties[prop.targetKey];
+                // use the actual target's meta, a polymorphic relation has several
+                if (prop.targetKey) {
+                    const targetProp = target.__meta.properties[prop.targetKey];
                     if (targetProp?.customType) {
                         value = targetProp.customType.convertToDatabaseValue(value, this.#platform, { mode: 'serialization' });
                     }
                 }
                 if (prop.polymorphic) {
                     const discriminator = QueryHelper.findDiscriminatorValue(prop.discriminatorMap, target.constructor);
-                    Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, new PolymorphicRef(discriminator, value), idx);
+                    value = new PolymorphicRef(discriminator, value);
                 }
-                else {
-                    Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, value, idx);
+                // an unchanged `targetKey` FK is not part of the diff
+                if (prop.targetKey &&
+                    changeSet.type === ChangeSetType.UPDATE &&
+                    !(prop.name in changeSet.payload) &&
+                    Utils.equals(changeSet.originalEntity?.[prop.name], value)) {
+                    return;
                 }
+                Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, value, idx);
             }
         });
     }

package/unit-of-work/ChangeSetPersister.js

@@ -207,7 +207,7 @@ export class ChangeSetPersister {
         const keys = meta.getOwnConcurrencyCheckKeys();
         for (const key of keys) {
             cond[key] = changeSet.originalEntity[key];
-            if (changeSet.payload[key]) {
+            if (Object.hasOwn(changeSet.payload, key)) {
                 tmp.push(key);
             }
         }
@@ -322,17 +322,19 @@ export class ChangeSetPersister {
         }
         // skip entity references as they don't have version values loaded
         changeSets = changeSets.filter(cs => helper(cs.entity).__initialized);
-        const primaryKeys = meta.primaryKeys.concat(...concurrencyCheckKeys);
+        const fields = meta.primaryKeys.concat(...concurrencyCheckKeys);
         const $or = changeSets.map(cs => {
-            const cond = Utils.getPrimaryKeyCond(cs.originalEntity, primaryKeys);
+            const cond = Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys);
+            for (const key of concurrencyCheckKeys) {
+                cond[key] = cs.originalEntity[key];
+            }
             if (meta.ownsVersionProperty()) {
-                // @ts-ignore
                 cond[meta.versionProperty] = this.#platform.convertVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
             }
             return cond;
         });
         options = this.prepareOptions(meta, options, {
-            fields: primaryKeys,
+            fields,
             orderBy: meta.primaryKeys.reduce((o, pk) => {
                 o[pk] = 'asc';
                 return o;
@@ -344,8 +346,8 @@ export class ChangeSetPersister {
         if (res.length !== changeSets.length) {
             // a FK pointing to a composite PK is an array, so the values need to be compared deeply
             const compare = (a, b, keys) => keys.every(k => equals(a[k], b[k]));
-            const entity = changeSets.find(cs => {
-                return !res.some(row => compare(Utils.getPrimaryKeyCond(cs.entity, primaryKeys), row, primaryKeys));
+            const entity = changeSets.find((_, index) => {
+                return !res.some(row => compare($or[index], row, meta.primaryKeys));
             }).entity;
             throw OptimisticLockError.lockFailed(entity);
         }

package/unit-of-work/IdentityMap.d.ts

@@ -1,9 +1,9 @@
 import type { AnyEntity, EntityMetadata } from '../typings.js';
-/** @internal Stores managed entity instances keyed by their primary key hash, ensuring each row is loaded once. */
+/** @internal Stores managed entity instances keyed by their primary key hash (and `targetKey` values), ensuring each row is loaded once. */
 export declare class IdentityMap {
     #private;
     constructor(defaultSchema?: string);
-    /** Stores an entity in the identity map under its primary key hash. */
+    /** Stores an entity in the identity map under its primary key hash and the `targetKey` values referencing it. */
     store<T>(item: T): void;
     /**
      * Stores an entity under an alternate key (non-PK property).
@@ -25,6 +25,7 @@ export declare class IdentityMap {
     /** Returns all entities currently in the identity map. */
     values(): AnyEntity[];
     [Symbol.iterator](): IterableIterator<AnyEntity>;
+    private getEntities;
     /** Returns all hash keys currently in the identity map. */
     keys(): string[];
     /**

package/unit-of-work/IdentityMap.js

@@ -1,15 +1,29 @@
-/** @internal Stores managed entity instances keyed by their primary key hash, ensuring each row is loaded once. */
+/** @internal Stores managed entity instances keyed by their primary key hash (and `targetKey` values), ensuring each row is loaded once. */
 export class IdentityMap {
     #defaultSchema;
     #registry = new Map();
     /** Tracks alternate key hashes for each entity so we can clean them up on delete */
     #alternateKeys = new WeakMap();
+    #storesWithAlternateKeys = new WeakSet();
     constructor(defaultSchema) {
         this.#defaultSchema = defaultSchema;
     }
-    /** Stores an entity in the identity map under its primary key hash. */
+    /** Stores an entity in the identity map under its primary key hash and the `targetKey` values referencing it. */
     store(item) {
-        this.getStore(item.__meta.root).set(this.getPkHash(item), item);
+        const meta = item.__meta.root;
+        const wrapped = item.__helper;
+        // PK-less references (known only by a `targetKey`) would share one slot that outlives their later removal
+        if (!meta.targetKeys || wrapped.hasPrimaryKey()) {
+            this.getStore(meta).set(this.getPkHash(item), item);
+        }
+        // references resolved via `targetKey` look the entity up by that key instead of the PK
+        for (const key of meta.targetKeys ?? []) {
+            const value = item[key];
+            if (value != null) {
+                const schema = wrapped.__schema ?? meta.schema ?? this.#defaultSchema;
+                this.storeByKey(item, key, '' + value, schema);
+            }
+        }
     }
     /**
      * Stores an entity under an alternate key (non-PK property).
@@ -17,7 +31,9 @@ export class IdentityMap {
      */
     storeByKey(item, key, value, schema) {
         const hash = this.getKeyHash(key, value, schema);
-        this.getStore(item.__meta.root).set(hash, item);
+        const store = this.getStore(item.__meta.root);
+        store.set(hash, item);
+        this.#storesWithAlternateKeys.add(store);
         // Track this alternate key so we can clean it up when the entity is deleted
         let keys = this.#alternateKeys.get(item);
         if (!keys) {
@@ -35,7 +51,10 @@ export class IdentityMap {
         const altKeys = this.#alternateKeys.get(item);
         if (altKeys) {
             for (const hash of altKeys) {
-                store.delete(hash);
+                // the hash might be owned by another entity by now, e.g. after swapping unique values
+                if (store.get(hash) === item) {
+                    store.delete(hash);
+                }
             }
             this.#alternateKeys.delete(item);
         }
@@ -69,7 +88,7 @@ export class IdentityMap {
     values() {
         const ret = [];
         for (const store of this.#registry.values()) {
-            for (const item of store.values()) {
+            for (const item of this.getEntities(store)) {
                 ret.push(item);
             }
         }
@@ -77,11 +96,15 @@ export class IdentityMap {
     }
     *[Symbol.iterator]() {
         for (const store of this.#registry.values()) {
-            for (const item of store.values()) {
+            for (const item of this.getEntities(store)) {
                 yield item;
             }
         }
     }
+    getEntities(store) {
+        // an entity indexed by alternate keys occupies several slots of its store
+        return this.#storesWithAlternateKeys.has(store) ? new Set(store.values()) : store.values();
+    }
     /** Returns all hash keys currently in the identity map. */
     keys() {
         const ret = [];

package/unit-of-work/UnitOfWork.js

@@ -89,7 +89,10 @@ export class UnitOfWork {
                 Utils.isPlainObject(data[prop.name])) {
                 // Skip polymorphic relations - they use PolymorphicRef wrapper
                 if (!prop.polymorphic) {
-                    data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+                    // with `targetKey`, the FK holds that value instead of the PK
+                    data[prop.name] = prop.targetKey
+                        ? data[prop.name][prop.targetKey]
+                        : Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
             }
             else if (prop.kind === ReferenceKind.EMBEDDED && !prop.object && Utils.isPlainObject(data[prop.name])) {
@@ -205,7 +208,18 @@ export class UnitOfWork {
             value = prop.customType.convertToJSValue(value, this.#platform, { mode: 'hydration' });
         }
         const hash = this.#identityMap.getKeyHash(key, '' + value, schema);
-        return this.#identityMap.getByHash(meta, hash);
+        const entity = this.#identityMap.getByHash(meta, hash);
+        // the entry is stale when the key changed via refresh or merge, unless only the unflushed value differs
+        if (entity && '' + entity[key] !== '' + value) {
+            // the snapshot holds the database value
+            const dbValue = prop?.customType
+                ? prop.customType.convertToDatabaseValue(value, this.#platform, { mode: 'serialization' })
+                : value;
+            if ('' + helper(entity).__originalEntityData?.[key] !== '' + dbValue) {
+                return undefined;
+            }
+        }
+        return entity;
     }
     /**
      * Stores an entity in the identity map under an alternate key (non-PK property).
@@ -368,6 +382,10 @@ export class UnitOfWork {
     }
     /** Marks an entity for removal, cascading to related entities. */
     remove(entity, visited, options = {}) {
+        // a reference known only by its `targetKey` has no PK, so the delete would match nothing
+        if (!helper(entity).__initialized && !helper(entity).hasPrimaryKey()) {
+            throw ValidationError.referenceWithoutPK(entity);
+        }
         // allow removing not managed entities if they are not part of the persist stack
         if (helper(entity).__managed || !this.#persistStack.has(entity)) {
             this.#removeStack.add(entity);
@@ -467,7 +485,10 @@ export class UnitOfWork {
             }
             const groups = this.getChangeSetGroups();
             const platform = this.#em.getPlatform();
-            const runInTransaction = !this.#em.isInTransaction() && platform.supportsTransactions() && this.#em.config.get('implicitTransactions');
+            const runInTransaction = !this.#em.isInTransaction() &&
+                !this.#em.isTransactionDisabled() &&
+                platform.supportsTransactions() &&
+                this.#em.config.get('implicitTransactions');
             if (runInTransaction) {
                 const loggerContext = Utils.merge({ id: this.#em._id }, this.#em.getLoggerContext({ disableContextResolution: true }));
                 await this.#em.getConnection('write').transactional(trx => this.persistToDatabase(groups, trx), {
@@ -1115,6 +1136,11 @@ export class UnitOfWork {
         for (const changeSet of changeSets) {
             const wrapped = helper(changeSet.entity);
             wrapped.__originalEntityData = this.#comparator.prepareEntity(changeSet.entity);
+            // re-index so the entity is found by its new `targetKey` values instead of the old ones
+            if (changeSet.meta.root.targetKeys?.some(key => key in changeSet.payload)) {
+                this.#identityMap.delete(changeSet.entity);
+                this.#identityMap.store(changeSet.entity);
+            }
             if (!wrapped.__initialized) {
                 for (const prop of changeSet.meta.relations) {
                     if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) &&

package/utils/EntityComparator.js

@@ -95,7 +95,7 @@ export class EntityComparator {
             lines.push(`  return entity${this.wrap(pk)};`);
         }
         const code = `// compiled pk getter for entity ${meta.className}\n` + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const fnKey = `pkGetter-${meta.uniqueName}`;
+        const fnKey = `pkGetter-${meta.compiledName}`;
         const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#pkGetters.set(meta, pkSerializer);
         return pkSerializer;
@@ -147,7 +147,7 @@ export class EntityComparator {
         }
         const code = `// compiled pk getter (with converted custom types) for entity ${meta.className}\n` +
             `return function(entity) {\n${lines.join('\n')}\n}`;
-        const fnKey = `pkGetterConverted-${meta.uniqueName}`;
+        const fnKey = `pkGetterConverted-${meta.compiledName}`;
         const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#pkGettersConverted.set(meta, pkSerializer);
         return pkSerializer;
@@ -206,7 +206,7 @@ export class EntityComparator {
             }
         }
         const code = `// compiled pk serializer for entity ${meta.className}\n` + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const fnKey = `pkSerializer-${meta.uniqueName}`;
+        const fnKey = `pkSerializer-${meta.compiledName}`;
         const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#pkSerializers.set(meta, pkSerializer);
         return pkSerializer;
@@ -236,7 +236,7 @@ export class EntityComparator {
         })
             .forEach(prop => lines.push(this.getPropertySnapshot(meta, prop, context, this.wrap(prop.name), this.wrap(prop.name), [prop.name])));
         const code = `return function(entity) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
-        const fnKey = `snapshotGenerator-${meta.uniqueName}`;
+        const fnKey = `snapshotGenerator-${meta.compiledName}`;
         const snapshotGenerator = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#snapshotGenerators.set(meta, snapshotGenerator);
         return snapshotGenerator;
@@ -350,14 +350,27 @@ export class EntityComparator {
                 if (prop.embedded && (meta.embeddable || meta.properties[prop.embedded[0]].object)) {
                     continue;
                 }
+                let defined = `typeof ${this.propName(prop.fieldNames[0])} !== 'undefined'`;
+                // STI subtypes with conflicting columns share the property, so another subtype's null column must not override it
+                if (prop.renamedFrom) {
+                    lines.push(`${padding}  ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
+                    defined = `${this.propName(prop.fieldNames[0])} != null`;
+                    // a column shared with a differently typed subtype is left for each subtype's hydrator to convert
+                    if (meta.props.some(p => p !== prop && p.name === prop.name && p.fieldNames?.[0] === prop.fieldNames[0])) {
+                        lines.push(`${padding}  if (${defined}) {`);
+                        lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])};`);
+                        lines.push(`${padding}  }`);
+                        continue;
+                    }
+                }
                 if (prop.runtimeType === 'boolean') {
-                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    lines.push(`${padding}  if (${defined}) {`);
                     lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} == null ? ${this.propName(prop.fieldNames[0])} : !!${this.propName(prop.fieldNames[0])};`);
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
                 }
                 else if (prop.runtimeType === 'Date' && !this.#platform.isNumericProperty(prop)) {
-                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    lines.push(`${padding}  if (${defined}) {`);
                     context.set('parseDate', (value) => this.#platform.parseDate(value));
                     parseDate('ret' + this.wrap(prop.name), this.propName(prop.fieldNames[0]), padding);
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
@@ -372,13 +385,13 @@ export class EntityComparator {
                         }
                         return item == null ? item : this.getResultMapper(prop.targetMeta)(item);
                     });
-                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    lines.push(`${padding}  if (${defined}) {`);
                     lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} == null ? ${this.propName(prop.fieldNames[0])} : mapEmbeddedResult_${idx}(${this.propName(prop.fieldNames[0])});`);
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
                 }
                 else if (prop.kind !== ReferenceKind.EMBEDDED) {
-                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    lines.push(`${padding}  if (${defined}) {`);
                     lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])};`);
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
@@ -420,7 +433,7 @@ export class EntityComparator {
         lines.push(`  for (let k in result) { if (Object.hasOwn(result, k) && !mapped[k] && ret[k] === undefined${knownKeysGuard}) ret[k] = result[k]; }`);
         const code = `// compiled mapper for entity ${meta.className}\n` +
             `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
-        const fnKey = `resultMapper-${meta.uniqueName}`;
+        const fnKey = `resultMapper-${meta.compiledName}`;
         const resultMapper = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#mappers.set(meta, resultMapper);
         return resultMapper;
@@ -608,9 +621,24 @@ export class EntityComparator {
                 ret += `        if (discriminator !== undefined) break;\n`;
                 ret += `        __cls${level} = Object.getPrototypeOf(__cls${level});\n`;
                 ret += `      }\n`;
-                ret += `      const pk = val${level}?.__helper?.__identifier && !val${level}?.__helper?.hasPrimaryKey()\n`;
-                ret += `        ? val${level}.__helper.__identifier\n`;
-                ret += `        : toArray(val${level}?.__helper?.getPrimaryKey(true));\n`;
+                if (prop.targetKey) {
+                    // the FK holds the `targetKey` value in the format of the actual target's column
+                    const targetKey = prop.targetKey;
+                    const targetKeyValueKey = `targetKeyValue_${this.safeKey(prop.name)}`;
+                    context.set(targetKeyValueKey, (val) => {
+                        const customType = val.__meta.properties[targetKey]?.customType;
+                        const value = val[targetKey];
+                        return customType
+                            ? customType.convertToDatabaseValue(value, this.#platform, { mode: 'serialization' })
+                            : value;
+                    });
+                    ret += `      const pk = ${targetKeyValueKey}(val${level});\n`;
+                }
+                else {
+                    ret += `      const pk = val${level}?.__helper?.__identifier && !val${level}?.__helper?.hasPrimaryKey()\n`;
+                    ret += `        ? val${level}.__helper.__identifier\n`;
+                    ret += `        : toArray(val${level}?.__helper?.getPrimaryKey(true));\n`;
+                }
                 ret += `      ret${dataKey} = new PolymorphicRef(discriminator, pk);\n`;
                 ret += `    }\n`;
             }
@@ -624,8 +652,8 @@ export class EntityComparator {
                 ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
                 ret += `      const val${level} = entity${entityKey}${unwrap};\n`;
                 if (targetProp?.customType) {
-                    // If targetKey property has a custom type, convert to database value
-                    const convertorKey = this.registerCustomType(targetProp, context);
+                    // keyed by the relation name to avoid clashing with a same-named owner prop, the relation itself lacks the custom type with an explicit `columnType`
+                    const convertorKey = this.registerCustomType({ ...prop, customType: targetProp.customType }, context);
                     ret += `      ret${dataKey} = convertToDatabaseValue_${convertorKey}(val${level}${targetAccess});\n`;
                 }
                 else {
@@ -688,7 +716,7 @@ export class EntityComparator {
         lines.push(`}`);
         const code = `// compiled comparator for entity ${meta.className}\n` +
             `return function(last, current, options) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
-        const fnKey = `comparator-${meta.uniqueName}`;
+        const fnKey = `comparator-${meta.compiledName}`;
         const comparator = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#comparators.set(meta, comparator);
         return comparator;

package/utils/QueryHelper.d.ts

@@ -35,6 +35,12 @@ export declare class QueryHelper {
      */
     static liftGroupOperators<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): string | undefined;
     static inlinePrimaryKeyObjects<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): boolean;
+    /**
+     * A bare value on a polymorphic relation would be compared to the discriminator column, so PK values are turned
+     * into a PK condition instead, e.g. `1` becomes `{ id: 1 }` and `[{ id: 1 }, { id: 2 }]` becomes `{ id: { $in: [1, 2] } }`.
+     * Null checks and `[type, id]` tuples keep their meaning.
+     */
+    private static inlinePolymorphicPrimaryKeys;
     /** Copies the plain object and array structure of the condition, keeping the leaf values (e.g. entities) by reference. */
     private static cloneWhere;
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;

package/utils/QueryHelper.js

@@ -4,7 +4,7 @@ import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, ReferenceKind } fro
 import { JsonType } from '../types/JsonType.js';
 import { helper } from '../entity/wrap.js';
 import { isRaw, Raw } from './RawQueryFragment.js';
-import { MetadataError } from '../errors.js';
+import { MetadataError, ValidationError } from '../errors.js';
 /** @internal */
 export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
@@ -102,18 +102,23 @@ export class QueryHelper {
         for (const k of keys) {
             const value = where[k];
             const prop = meta.properties[k];
-            // Polymorphic relations use multiple columns (discriminator + FK), so they cannot
-            // participate in the standard single-column FK expansion. Query by discriminator
-            // column directly instead, e.g. { likeableType: 'post', likeableId: 1 }.
-            if (!prop || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || prop.polymorphic) {
+            if (!prop || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                 continue;
             }
             const op = this.liftGroupOperators(value, prop.targetMeta, metadata, k);
             if (op) {
                 delete where[k];
-                where[op] = value[op].map((v) => {
+                const group = value[op].map((v) => {
                     return { [k]: v };
                 });
+                if (op in where) {
+                    // Sibling groups are conjunctive, even when both use `$or`.
+                    where.$and ??= [];
+                    where.$and.push({ [op]: group });
+                }
+                else {
+                    where[op] = group;
+                }
             }
         }
         return undefined;
@@ -122,7 +127,7 @@ export class QueryHelper {
         if (Array.isArray(where)) {
             where.forEach((item, i) => {
                 if (this.inlinePrimaryKeyObjects(item, meta, metadata, key)) {
-                    where[i] = Utils.getPrimaryKeyValues(item, meta, false);
+                    where[i] = Utils.getPrimaryKeyValues(item, meta, true);
                 }
             });
         }
@@ -152,15 +157,19 @@ export class QueryHelper {
         Object.keys(where).forEach(k => {
             const prop = meta.properties[k];
             const meta2 = metadata.find(prop?.targetMeta?.class) || meta;
+            if (prop?.polymorphic) {
+                where[k] = this.inlinePolymorphicPrimaryKeys(where[k], meta2, prop);
+            }
             if (this.inlinePrimaryKeyObjects(where[k], meta2, metadata, k)) {
                 // Skip the PK collapse when an owning M:1/1:1 relation's FK column count does not match
                 // the target's PK column count (e.g. FK references target PK + an extra unique column).
                 // The criteria layer would otherwise emit a malformed predicate such as
                 // `(joinCol1, joinCol2) = scalar`. Limited to owning relations — `joinColumns` on the
                 // inverse side (1:m) describes the owning entity's FK columns, not the LHS tuple.
+                // Polymorphic relations are skipped too, a scalar would be compared to the discriminator column.
                 if (prop?.owner &&
                     [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
-                    prop.joinColumns.length !== meta2.primaryKeys.length) {
+                    (prop.polymorphic || prop.joinColumns.length !== meta2.primaryKeys.length)) {
                     return;
                 }
                 where[k] = Utils.getPrimaryKeyValues(where[k], meta2, true);
@@ -168,6 +177,37 @@ export class QueryHelper {
         });
         return false;
     }
+    /**
+     * A bare value on a polymorphic relation would be compared to the discriminator column, so PK values are turned
+     * into a PK condition instead, e.g. `1` becomes `{ id: 1 }` and `[{ id: 1 }, { id: 2 }]` becomes `{ id: { $in: [1, 2] } }`.
+     * Null checks and `[type, id]` tuples keep their meaning.
+     */
+    static inlinePolymorphicPrimaryKeys(value, meta, prop) {
+        const pk = meta.primaryKeys[0];
+        const isScalar = (v) => v != null && !Array.isArray(v) && Utils.isPrimaryKey(v);
+        const isPrimaryKeyObject = (v) => Utils.isPlainObject(v) && Utils.getObjectKeysSize(v) === 1 && pk in v;
+        // lists of plain values are how `[type, id]` tuples get normalized (`{ $in: [type, id] }`), so only PK objects are inlined
+        const isList = (v) => Array.isArray(v) && v.length > 0 && v.every(isPrimaryKeyObject);
+        let cond;
+        if (isScalar(value)) {
+            cond = value;
+        }
+        else if (isList(value)) {
+            cond = { $in: value.map(v => v[pk]) };
+        }
+        else if (Utils.isPlainObject(value) &&
+            Utils.hasObjectKeys(value) &&
+            Object.entries(value).every(([op, v]) => Utils.isOperator(op) && !(op in GroupOperator) && op !== '$not' && (isScalar(v) || isList(v)))) {
+            cond = Object.fromEntries(Object.entries(value).map(([op, v]) => [op, isList(v) ? v.map(i => i[pk]) : v]));
+        }
+        else {
+            return value;
+        }
+        if (meta.compositePK) {
+            throw new ValidationError(`Polymorphic relation ${prop.name} targets entities with a composite primary key, use PK objects or entity references in the condition instead.`);
+        }
+        return { [pk]: cond };
+    }
     /** Copies the plain object and array structure of the condition, keeping the leaf values (e.g. entities) by reference. */
     static cloneWhere(where) {
         if (Array.isArray(where)) {
@@ -486,6 +526,9 @@ export class QueryHelper {
             if (expanded !== w) {
                 where[k] = expanded;
             }
+            else if (Array.isArray(w)) {
+                where[k] = w.map(expandItem);
+            }
             else if (Utils.isPlainObject(w)) {
                 for (const op of Object.keys(w)) {
                     if (!Utils.isOperator(op, false)) {

package/utils/TransactionContext.d.ts

@@ -1,6 +1,7 @@
 import type { EntityManager } from '../EntityManager.js';
 /** Uses `AsyncLocalStorage` to maintain a transaction-scoped EntityManager context across async operations. */
 export declare class TransactionContext {
+    #private;
     readonly em: EntityManager;
     private static storage;
     readonly id: number;

package/utils/TransactionContext.js

@@ -1,8 +1,10 @@
+var _a;
 import { createAsyncContext } from './AsyncContext.js';
 /** Uses `AsyncLocalStorage` to maintain a transaction-scoped EntityManager context across async operations. */
 export class TransactionContext {
     em;
     static storage = createAsyncContext();
+    #parent = _a.currentTransactionContext();
     id;
     constructor(em) {
         this.em = em;
@@ -12,7 +14,7 @@ export class TransactionContext {
      * Creates new TransactionContext instance and runs the code inside its domain.
      */
     static create(em, next) {
-        const context = new TransactionContext(em);
+        const context = new _a(em);
         return this.storage.run(context, next);
     }
     /**
@@ -25,7 +27,11 @@ export class TransactionContext {
      * Returns current EntityManager (if available).
      */
     static getEntityManager(name = 'default') {
-        const context = TransactionContext.currentTransactionContext();
-        return context?.em.name === name ? context.em : undefined;
+        let context = _a.currentTransactionContext();
+        while (context && context.em.name !== name) {
+            context = context.#parent;
+        }
+        return context?.em;
     }
 }
+_a = TransactionContext;

package/utils/TransactionManager.js

@@ -81,10 +81,10 @@ export class TransactionManager {
      */
     async executeWithoutTransaction(em, cb, options) {
         const suspended = this.suspendTransaction(em);
-        const fork = this.createFork(em, { ...options, disableTransactions: true });
+        const fork = this.createFork(em, options);
         const propagateToUpperContext = this.shouldPropagateToUpperContext(em);
         try {
-            return await this.executeTransactionFlow(fork, cb, propagateToUpperContext, em);
+            return await TransactionContext.create(fork, () => this.executeTransactionFlow(fork, cb, propagateToUpperContext, em));
         }
         finally {
             this.resumeTransaction(em, suspended);
@@ -189,6 +189,10 @@ export class TransactionManager {
                 if (wrapped.__originalEntityData) {
                     parentWrapped.__originalEntityData = originalEntityData;
                 }
+                // index a merged `targetKey` value, `getByKey` ignores the old one as stale
+                if (meta.root.targetKeys) {
+                    parentUoW.getIdentityMap().store(parentEntity);
+                }
             }
             else {
                 parentUoW.merge(entity, new Set([entity]));

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.2.2-dev.8';
+    static #ORM_VERSION = '7.2.2';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;