@mikro-orm/core 7.3.0-dev.3 → 7.3.0-dev.4

package/EntityManager.js

@@ -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) {

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;

package/metadata/MetadataDiscovery.js

@@ -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);
+                }
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.3.0-dev.3",
+  "version": "7.3.0-dev.4",
   "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

@@ -1175,6 +1175,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>[];

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/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);
@@ -1118,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

@@ -608,9 +608,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 +639,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 {

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,10 +102,7 @@ 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);
@@ -130,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);
                 }
             });
         }
@@ -160,6 +157,9 @@ export class QueryHelper {
         Object.keys(where).forEach(k => {
             const prop = meta.properties[QueryHelper.splitPolymorphicKey(k)[0]];
             const meta2 = metadata.find(QueryHelper.findTargetMeta(prop, k)?.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).
@@ -177,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)) {
@@ -555,6 +586,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/TransactionManager.js

@@ -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.3.0-dev.3';
+    static #ORM_VERSION = '7.3.0-dev.4';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;