@mikro-orm/core 7.0.0-dev.225 → 7.0.0-dev.227

package/typings.js

@@ -1,6 +1,7 @@
 import { ReferenceKind, } from './enums.js';
 import { Reference } from './entity/Reference.js';
 import { EntityHelper } from './entity/EntityHelper.js';
+import { helper } from './entity/wrap.js';
 import { Utils } from './utils/Utils.js';
 import { EntityComparator } from './utils/EntityComparator.js';
 import { BaseEntity } from './entity/BaseEntity.js';
@@ -167,7 +168,10 @@ export class EntityMetadata {
                         wrapped.__data[prop.name] = Reference.wrapReference(val, prop);
                         // when propagation from inside hydration, we set the FK to the entity data immediately
                         if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                            wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(val, prop.targetMeta, true);
+                            const targetMeta = prop.targetMeta ?? helper(entity)?.__meta;
+                            if (targetMeta) {
+                                wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(val, targetMeta, true);
+                            }
                         }
                         EntityHelper.propagate(meta, entity, this, prop, Reference.unwrapReference(val), old);
                     },

package/unit-of-work/ChangeSetComputer.js

@@ -1,7 +1,10 @@
 import { Utils } from '../utils/Utils.js';
+import { QueryHelper } from '../utils/QueryHelper.js';
 import { ChangeSet, ChangeSetType } from './ChangeSet.js';
 import { helper } from '../entity/wrap.js';
 import { validateEntity } from '../entity/validators.js';
+import { Reference } from '../entity/Reference.js';
+import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { ReferenceKind } from '../enums.js';
 export class ChangeSetComputer {
     collectionUpdates;
@@ -130,9 +133,10 @@ export class ChangeSetComputer {
             return;
         }
         const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
-        targets.forEach(([target, idx]) => {
-            if (!target.__helper.hasPrimaryKey()) {
-                // When targetKey is set, use that property value instead of the PK identifier
+        targets.forEach(([rawTarget, idx]) => {
+            const target = Reference.unwrapReference(rawTarget);
+            const needsProcessing = target != null && (prop.targetKey != null || !target.__helper.hasPrimaryKey());
+            if (needsProcessing) {
                 let value = prop.targetKey ? target[prop.targetKey] : target.__helper.__identifier;
                 /* v8 ignore next */
                 if (prop.targetKey && prop.targetMeta) {
@@ -141,7 +145,13 @@ export class ChangeSetComputer {
                         value = targetProp.customType.convertToDatabaseValue(value, this.platform, { mode: 'serialization' });
                     }
                 }
-                Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, value, idx);
+                if (prop.polymorphic) {
+                    const discriminator = QueryHelper.findDiscriminatorValue(prop.discriminatorMap, target.constructor);
+                    Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, new PolymorphicRef(discriminator, value), idx);
+                }
+                else {
+                    Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, value, idx);
+                }
             }
         });
     }

package/unit-of-work/ChangeSetPersister.js

@@ -1,4 +1,5 @@
 import { EntityIdentifier } from '../entity/EntityIdentifier.js';
+import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { helper } from '../entity/wrap.js';
 import { ChangeSetType } from './ChangeSet.js';
 import { isRaw } from '../utils/RawQueryFragment.js';
@@ -376,6 +377,12 @@ export class ChangeSetPersister {
             changeSet.payload[prop.name] = value.getValue();
             return;
         }
+        if (value instanceof PolymorphicRef) {
+            if (value.id instanceof EntityIdentifier) {
+                value.id = value.id.getValue();
+            }
+            return;
+        }
         if (Array.isArray(value) && value.every(item => item instanceof EntityIdentifier)) {
             changeSet.payload[prop.name] = value.map(item => item.getValue());
             return;

package/unit-of-work/UnitOfWork.js

@@ -77,7 +77,10 @@ export class UnitOfWork {
                 continue;
             }
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
-                data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+                // Skip polymorphic relations - they use PolymorphicRef wrapper
+                if (!prop.polymorphic) {
+                    data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+                }
             }
             else if (prop.kind === ReferenceKind.EMBEDDED && !prop.object && Utils.isPlainObject(data[prop.name])) {
                 for (const p of prop.targetMeta.props) {
@@ -262,6 +265,7 @@ export class UnitOfWork {
         if (!cs || this.checkUniqueProps(cs)) {
             return;
         }
+        /* v8 ignore next */
         if (type) {
             cs.type = type;
         }
@@ -1013,7 +1017,14 @@ export class UnitOfWork {
         set.forEach(meta => calc.addNode(meta._id));
         for (const meta of set) {
             for (const prop of meta.relations) {
-                calc.discoverProperty(prop, meta._id);
+                if (prop.polymorphTargets) {
+                    for (const targetMeta of prop.polymorphTargets) {
+                        calc.discoverProperty({ ...prop, targetMeta }, meta._id);
+                    }
+                }
+                else {
+                    calc.discoverProperty(prop, meta._id);
+                }
             }
         }
         return calc.sort().map(id => this.metadata.getById(id));

package/utils/EntityComparator.d.ts

@@ -85,6 +85,11 @@ export declare class EntityComparator {
     private getPropertyComparator;
     private wrap;
     private safeKey;
+    /**
+     * Sets the toArray helper in the context if not already set.
+     * Used for converting composite PKs to arrays.
+     */
+    private setToArrayHelper;
     /**
      * perf: used to generate list of comparable properties during discovery, so we speed up the runtime comparison
      */

package/utils/EntityComparator.js

@@ -4,6 +4,7 @@ import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals,
 import { JsonType } from '../types/JsonType.js';
 import { Raw } from './RawQueryFragment.js';
 import { EntityIdentifier } from '../entity/EntityIdentifier.js';
+import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 export class EntityComparator {
     metadata;
     platform;
@@ -285,6 +286,7 @@ export class EntityComparator {
         }
         const lines = [];
         const context = new Map();
+        context.set('PolymorphicRef', PolymorphicRef);
         const tz = this.platform.getTimezone();
         const parseDate = (key, value, padding = '') => {
             lines.push(`${padding}    if (${value} == null || ${value} instanceof Date) {`);
@@ -311,12 +313,28 @@ export class EntityComparator {
                 if (!prop.fieldNames) {
                     continue;
                 }
+                if (prop.polymorphic && prop.fieldNames.length >= 2) {
+                    const discriminatorField = prop.fieldNames[0];
+                    const idFields = prop.fieldNames.slice(1);
+                    lines.push(`${padding}  if (${prop.fieldNames.map(field => `typeof ${this.propName(field)} === 'undefined'`).join(' && ')}) {`);
+                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} != null`).join(' && ')}) {`);
+                    if (idFields.length === 1) {
+                        lines.push(`${padding}    ret${this.wrap(prop.name)} = new PolymorphicRef(${this.propName(discriminatorField)}, ${this.propName(idFields[0])});`);
+                    }
+                    else {
+                        lines.push(`${padding}    ret${this.wrap(prop.name)} = new PolymorphicRef(${this.propName(discriminatorField)}, [${idFields.map(f => this.propName(f)).join(', ')}]);`);
+                    }
+                    lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`));
+                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} == null`).join(' && ')}) {\n${padding}    ret${this.wrap(prop.name)} = null;`);
+                    lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`), '  }');
+                    continue;
+                }
                 if (prop.targetMeta && prop.fieldNames.length > 1) {
                     lines.push(`${padding}  if (${prop.fieldNames.map(field => `typeof ${this.propName(field)} === 'undefined'`).join(' && ')}) {`);
                     lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} != null`).join(' && ')}) {`);
                     lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.createCompositeKeyArray(prop)};`);
                     lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`));
-                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} == null`).join(' && ')}) {\n    ret${this.wrap(prop.name)} = null;`);
+                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} == null`).join(' && ')}) {\n${padding}    ret${this.wrap(prop.name)} = null;`);
                     lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`), '  }');
                     continue;
                 }
@@ -517,6 +535,27 @@ export class EntityComparator {
                     ret += `    ret${dataKey} = entity${entityKey};\n`;
                 }
             }
+            else if (prop.polymorphic) {
+                const discriminatorMapKey = `discriminatorMapReverse_${prop.name}`;
+                const reverseMap = new Map();
+                for (const [key, value] of Object.entries(prop.discriminatorMap)) {
+                    reverseMap.set(value, key);
+                }
+                context.set(discriminatorMapKey, reverseMap);
+                this.setToArrayHelper(context);
+                context.set('EntityIdentifier', EntityIdentifier);
+                context.set('PolymorphicRef', PolymorphicRef);
+                ret += `    if (entity${entityKey} === null) {\n`;
+                ret += `      ret${dataKey} = null;\n`;
+                ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
+                ret += `      const val${level} = entity${entityKey}${unwrap};\n`;
+                ret += `      const discriminator = ${discriminatorMapKey}.get(val${level}?.constructor);\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`;
+                ret += `      ret${dataKey} = new PolymorphicRef(discriminator, pk);\n`;
+                ret += `    }\n`;
+            }
             else if (prop.targetKey) {
                 // When targetKey is set, extract that property value instead of the PK
                 const targetProp = prop.targetMeta?.properties[prop.targetKey];
@@ -535,13 +574,7 @@ export class EntityComparator {
                 ret += `    }\n`;
             }
             else {
-                const toArray = (val) => {
-                    if (Utils.isPlainObject(val)) {
-                        return Object.values(val).map(v => toArray(v));
-                    }
-                    return val;
-                };
-                context.set('toArray', toArray);
+                this.setToArrayHelper(context);
                 context.set('EntityIdentifier', EntityIdentifier);
                 ret += `    if (entity${entityKey} === null) {\n`;
                 ret += `      ret${dataKey} = null;\n`;
@@ -613,12 +646,17 @@ export class EntityComparator {
     getPropertyComparator(prop, context) {
         let type = prop.type.toLowerCase();
         if (prop.kind !== ReferenceKind.SCALAR && prop.kind !== ReferenceKind.EMBEDDED) {
-            const meta2 = prop.targetMeta;
-            if (meta2.primaryKeys.length > 1) {
-                type = 'array';
+            if (prop.polymorphic) {
+                type = 'object';
             }
             else {
-                type = meta2.getPrimaryProp().type.toLowerCase();
+                const meta2 = prop.targetMeta;
+                if (meta2.primaryKeys.length > 1) {
+                    type = 'array';
+                }
+                else {
+                    type = meta2.getPrimaryProp().type.toLowerCase();
+                }
             }
         }
         if (prop.customType) {
@@ -670,6 +708,22 @@ export class EntityComparator {
     safeKey(key) {
         return key.replace(/\W/g, '_');
     }
+    /**
+     * Sets the toArray helper in the context if not already set.
+     * Used for converting composite PKs to arrays.
+     */
+    setToArrayHelper(context) {
+        if (context.has('toArray')) {
+            return;
+        }
+        const toArray = (val) => {
+            if (Utils.isPlainObject(val)) {
+                return Object.values(val).map(v => toArray(v));
+            }
+            return val;
+        };
+        context.set('toArray', toArray);
+    }
     /**
      * perf: used to generate list of comparable properties during discovery, so we speed up the runtime comparison
      */

package/utils/QueryHelper.d.ts

@@ -5,6 +5,10 @@ import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
 /** @internal */
 export declare class QueryHelper {
     static readonly SUPPORTED_OPERATORS: string[];
+    /**
+     * Finds the discriminator value (key) for a given entity class in a discriminator map.
+     */
+    static findDiscriminatorValue<T>(discriminatorMap: Dictionary<T>, targetClass: T): string | undefined;
     static processParams(params: unknown): any;
     static processObjectParams<T extends Dictionary>(params?: T): T;
     /**

package/utils/QueryHelper.js

@@ -7,6 +7,12 @@ import { isRaw, Raw } from './RawQueryFragment.js';
 /** @internal */
 export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
+    /**
+     * Finds the discriminator value (key) for a given entity class in a discriminator map.
+     */
+    static findDiscriminatorValue(discriminatorMap, targetClass) {
+        return Object.entries(discriminatorMap).find(([, cls]) => cls === targetClass)?.[0];
+    }
     static processParams(params) {
         if (Reference.isReference(params)) {
             params = params.unwrap();
@@ -62,7 +68,10 @@ export class QueryHelper {
         for (const k of keys) {
             const value = where[k];
             const prop = meta.properties[k];
-            if (!prop || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+            // 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) {
                 continue;
             }
             const op = this.liftGroupOperators(value, prop.targetMeta, metadata, k);

package/utils/Utils.d.ts

@@ -1,7 +1,7 @@
 import type { CompiledFunctions, Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, Primary } from '../typings.js';
 import type { Collection } from '../entity/Collection.js';
 import type { Platform } from '../platforms/Platform.js';
-import type { ScalarReference } from '../entity/Reference.js';
+import { type ScalarReference } from '../entity/Reference.js';
 import { type RawQueryFragmentSymbol } from './RawQueryFragment.js';
 export declare function compareObjects(a: any, b: any): boolean;
 export declare function compareArrays(a: any[] | string, b: any[] | string): boolean;

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.225';
+    static #ORM_VERSION = '7.0.0-dev.227';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */