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

package/metadata/MetadataDiscovery.js

@@ -1,5 +1,6 @@
 import { EntityMetadata, } from '../typings.js';
 import { compareArrays, Utils } from '../utils/Utils.js';
+import { QueryHelper } from '../utils/QueryHelper.js';
 import { MetadataValidator } from './MetadataValidator.js';
 import { MetadataProvider } from './MetadataProvider.js';
 import { MetadataStorage } from './MetadataStorage.js';
@@ -131,6 +132,7 @@ export class MetadataDiscovery {
             filtered.forEach(meta => Object.values(meta.properties).forEach(prop => cb(meta, prop)));
         };
         forEachProp((m, p) => this.initFactoryField(m, p));
+        forEachProp((m, p) => this.initPolymorphicRelation(m, p, filtered));
         forEachProp((_m, p) => this.initRelation(p));
         forEachProp((m, p) => this.initEmbeddables(m, p));
         forEachProp((_m, p) => this.initFieldName(p));
@@ -351,6 +353,12 @@ export class MetadataDiscovery {
             if (!prop.joinColumns || !prop.columnTypes || prop.ownColumns || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                 continue;
             }
+            // For polymorphic relations, ownColumns should include all fieldNames
+            // (discriminator + ID columns) since they are all owned by this relation
+            if (prop.polymorphic) {
+                prop.ownColumns = prop.fieldNames;
+                continue;
+            }
             if (prop.joinColumns.length > 1) {
                 prop.ownColumns = prop.joinColumns.filter(col => {
                     return !meta.props.find(p => p.name !== prop.name && (!p.fieldNames || p.fieldNames.includes(col)));
@@ -381,7 +389,7 @@ export class MetadataDiscovery {
         if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED) {
             prop.fieldNames = [this.namingStrategy.propertyToColumnName(prop.name, object)];
         }
-        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.polymorphic) {
             prop.fieldNames = this.initManyToOneFieldName(prop, prop.name);
         }
         else if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner) {
@@ -436,17 +444,36 @@ export class MetadataDiscovery {
             prop.fixedOrderColumn = prop2.fixedOrderColumn;
             prop.joinColumns = prop2.inverseJoinColumns;
             prop.inverseJoinColumns = prop2.joinColumns;
+            prop.polymorphic = prop2.polymorphic;
+            prop.discriminator = prop2.discriminator;
+            prop.discriminatorColumn = prop2.discriminatorColumn;
+            prop.discriminatorValue = prop2.discriminatorValue;
         }
         prop.referencedColumnNames ??= Utils.flatten(meta.primaryKeys.map(primaryKey => meta.properties[primaryKey].fieldNames));
-        const ownerTableName = this.isExplicitTableName(meta.root) ? meta.root.tableName : undefined;
+        // For polymorphic M:N, use discriminator base name for FK column (e.g., taggable_id instead of post_id)
+        if (prop.polymorphic && prop.discriminator) {
+            prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.namingStrategy.joinKeyColumnName(prop.discriminator, referencedColumnName, prop.referencedColumnNames.length > 1));
+        }
+        else {
+            const ownerTableName = this.isExplicitTableName(meta.root) ? meta.root.tableName : undefined;
+            prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK, ownerTableName));
+        }
         const inverseTableName = this.isExplicitTableName(meta2.root) ? meta2.root.tableName : undefined;
-        prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK, ownerTableName));
         prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className, inverseTableName);
     }
     isExplicitTableName(meta) {
         return meta.tableName !== this.namingStrategy.classToTableName(meta.className);
     }
     initManyToOneFields(prop) {
+        if (prop.polymorphic && prop.polymorphTargets) {
+            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.referencedColumnNames ??= fieldNames1;
+            prop.referencedTableName ??= prop.targetMeta.tableName;
+            return;
+        }
         const meta2 = prop.targetMeta;
         let fieldNames;
         // If targetKey is specified, use that property's field names instead of PKs
@@ -605,6 +632,18 @@ export class MetadataDiscovery {
         if (pivotMeta) {
             prop.pivotEntity = pivotMeta.class;
             this.ensureCorrectFKOrderInPivotEntity(pivotMeta, prop);
+            if (prop.polymorphic && prop.discriminatorValue) {
+                pivotMeta.polymorphicDiscriminatorMap ??= {};
+                pivotMeta.polymorphicDiscriminatorMap[prop.discriminatorValue] = meta.class;
+                // For composite PK entities sharing a polymorphic pivot table,
+                // we need to add columns for each entity type's PKs
+                this.addPolymorphicPivotColumns(pivotMeta, meta, prop);
+                // Add virtual M:1 relation for this polymorphic owner (for join loading)
+                const ownerRelationName = `${prop.discriminator}_${meta.tableName}`;
+                if (!pivotMeta.properties[ownerRelationName]) {
+                    pivotMeta.properties[ownerRelationName] = this.definePolymorphicOwnerRelation(prop, ownerRelationName, meta);
+                }
+            }
             return pivotMeta;
         }
         let tableName = prop.pivotTable;
@@ -650,10 +689,127 @@ export class MetadataDiscovery {
                 }
             }
         }
-        pivotMeta2.properties[meta.name + '_owner'] = this.definePivotProperty(prop, meta.name + '_owner', meta.class, targetType + '_inverse', true, meta.className === targetType);
-        pivotMeta2.properties[targetType + '_inverse'] = this.definePivotProperty(prop, targetType + '_inverse', targetMeta.class, meta.name + '_owner', false, meta.className === targetType);
+        // For polymorphic M:N, create discriminator column and polymorphic FK
+        if (prop.polymorphic && prop.discriminatorColumn) {
+            this.definePolymorphicPivotProperties(pivotMeta2, meta, prop, targetMeta);
+        }
+        else {
+            pivotMeta2.properties[meta.name + '_owner'] = this.definePivotProperty(prop, meta.name + '_owner', meta.class, targetType + '_inverse', true, meta.className === targetType);
+            pivotMeta2.properties[targetType + '_inverse'] = this.definePivotProperty(prop, targetType + '_inverse', targetMeta.class, meta.name + '_owner', false, meta.className === targetType);
+        }
         return this.metadata.set(pivotMeta2.class, EntitySchema.fromMetadata(pivotMeta2).init().meta);
     }
+    /**
+     * Create a scalar property for a pivot table column.
+     */
+    createPivotScalarProperty(name, columnTypes, fieldNames = [name], options = {}) {
+        return {
+            name,
+            fieldNames,
+            columnTypes,
+            type: options.type ?? 'number',
+            kind: ReferenceKind.SCALAR,
+            primary: options.primary ?? false,
+            nullable: options.nullable ?? true,
+            ...(options.persist !== undefined && { persist: options.persist }),
+        };
+    }
+    /**
+     * Get column types for an entity's primary keys, initializing them if needed.
+     */
+    getPrimaryKeyColumnTypes(meta) {
+        const columnTypes = [];
+        for (const pk of meta.primaryKeys) {
+            const pkProp = meta.properties[pk];
+            this.initCustomType(meta, pkProp);
+            this.initColumnType(pkProp);
+            columnTypes.push(...pkProp.columnTypes);
+        }
+        return columnTypes;
+    }
+    /**
+     * Add missing FK columns for a polymorphic entity to an existing pivot table.
+     */
+    addPolymorphicPivotColumns(pivotMeta, meta, prop) {
+        const existingFieldNames = new Set(Object.values(pivotMeta.properties).flatMap(p => p.fieldNames ?? []));
+        const columnTypes = this.getPrimaryKeyColumnTypes(meta);
+        for (let i = 0; i < prop.joinColumns.length; i++) {
+            const joinColumn = prop.joinColumns[i];
+            if (!existingFieldNames.has(joinColumn)) {
+                pivotMeta.properties[joinColumn] = this.createPivotScalarProperty(joinColumn, [columnTypes[i]]);
+            }
+        }
+    }
+    /**
+     * Define properties for a polymorphic pivot table.
+     */
+    definePolymorphicPivotProperties(pivotMeta, meta, prop, targetMeta) {
+        const discriminatorColumn = prop.discriminatorColumn;
+        const isCompositePK = meta.compositePK;
+        // For composite PK polymorphic M:N, we need fixedOrder (auto-increment PK)
+        if (isCompositePK && !prop.fixedOrder) {
+            prop.fixedOrder = true;
+            const primaryProp = this.defineFixedOrderProperty(prop, targetMeta);
+            pivotMeta.properties[primaryProp.name] = primaryProp;
+            pivotMeta.compositePK = false;
+        }
+        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: !isCompositePK, nullable: false });
+        this.initFieldName(discriminatorProp);
+        pivotMeta.properties[discriminatorColumn] = discriminatorProp;
+        const columnTypes = this.getPrimaryKeyColumnTypes(meta);
+        if (isCompositePK) {
+            // Create separate properties for each PK column (nullable for other entity types)
+            for (let i = 0; i < prop.joinColumns.length; i++) {
+                pivotMeta.properties[prop.joinColumns[i]] = this.createPivotScalarProperty(prop.joinColumns[i], [columnTypes[i]]);
+            }
+            // Virtual property combining all columns (for compatibility)
+            pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, persist: false });
+        }
+        else {
+            pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, primary: true, nullable: false });
+        }
+        pivotMeta.properties[targetMeta.className + '_inverse'] = this.definePivotProperty(prop, targetMeta.className + '_inverse', targetMeta.class, prop.discriminator, false, false);
+        // Create virtual M:1 relation to the polymorphic owner for single-query join loading
+        const ownerRelationName = `${prop.discriminator}_${meta.tableName}`;
+        pivotMeta.properties[ownerRelationName] = this.definePolymorphicOwnerRelation(prop, ownerRelationName, meta);
+        pivotMeta.polymorphicDiscriminatorMap ??= {};
+        pivotMeta.polymorphicDiscriminatorMap[prop.discriminatorValue] = meta.class;
+    }
+    /**
+     * Create a virtual M:1 relation from pivot to a polymorphic owner entity.
+     * This enables single-query join loading for inverse-side polymorphic M:N.
+     */
+    definePolymorphicOwnerRelation(prop, name, targetMeta) {
+        const ret = {
+            name,
+            type: targetMeta.className,
+            target: targetMeta.class,
+            kind: ReferenceKind.MANY_TO_ONE,
+            nullable: true,
+            owner: true,
+            primary: false,
+            createForeignKeyConstraint: false,
+            persist: false,
+            index: false,
+        };
+        ret.targetMeta = targetMeta;
+        ret.fieldNames = ret.joinColumns = ret.ownColumns = [...prop.joinColumns];
+        ret.referencedColumnNames = [];
+        ret.inverseJoinColumns = [];
+        for (const primaryKey of targetMeta.primaryKeys) {
+            const pkProp = targetMeta.properties[primaryKey];
+            ret.referencedColumnNames.push(...pkProp.fieldNames);
+            ret.inverseJoinColumns.push(...pkProp.fieldNames);
+            ret.length = pkProp.length;
+            ret.precision = pkProp.precision;
+            ret.scale = pkProp.scale;
+        }
+        const schema = targetMeta.schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
+        ret.referencedTableName = schema && schema !== '*' ? schema + '.' + targetMeta.tableName : targetMeta.tableName;
+        this.initColumnType(ret);
+        this.initRelation(ret);
+        return ret;
+    }
     defineFixedOrderProperty(prop, targetMeta) {
         const pk = prop.fixedOrderColumn || this.namingStrategy.referenceColumnName();
         const primaryProp = {
@@ -833,6 +989,54 @@ export class MetadataDiscovery {
             polymorphs.forEach(meta => meta.root = embeddable);
         }
     }
+    initPolymorphicRelation(meta, prop, discovered) {
+        if (!prop.discriminator && !prop.discriminatorColumn && !prop.discriminatorMap && !Array.isArray(prop.target)) {
+            return;
+        }
+        prop.polymorphic = true;
+        prop.discriminator ??= prop.name;
+        prop.discriminatorColumn ??= this.namingStrategy.discriminatorColumnName(prop.discriminator);
+        prop.createForeignKeyConstraint = false;
+        const isToOne = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind);
+        if (isToOne) {
+            const types = prop.type.split(/ ?\| ?/);
+            prop.polymorphTargets = discovered.filter(m => types.includes(m.className) && !m.embeddable);
+            prop.targetMeta = prop.polymorphTargets[0];
+            prop.referencedPKs = prop.targetMeta?.primaryKeys;
+        }
+        if (prop.discriminatorMap) {
+            const normalizedMap = {};
+            for (const [key, value] of Object.entries(prop.discriminatorMap)) {
+                const targetMeta = this.metadata.getByClassName(value, false);
+                if (!targetMeta) {
+                    throw MetadataError.fromUnknownEntity(value, `${meta.className}.${prop.name} discriminatorMap`);
+                }
+                normalizedMap[key] = targetMeta.class;
+                if (targetMeta.class === meta.class) {
+                    prop.discriminatorValue = key;
+                }
+            }
+            prop.discriminatorMap = normalizedMap;
+        }
+        else if (isToOne) {
+            prop.discriminatorMap = {};
+            const tableNameToTarget = new Map();
+            for (const target of prop.polymorphTargets) {
+                const existing = tableNameToTarget.get(target.tableName);
+                if (existing) {
+                    throw MetadataError.incompatiblePolymorphicTargets(meta, prop, existing, target, `both use table '${target.tableName}'. Use separate properties instead of a single polymorphic relation.`);
+                }
+                tableNameToTarget.set(target.tableName, target);
+                prop.discriminatorMap[target.tableName] = target.class;
+            }
+        }
+        else {
+            prop.discriminatorValue ??= meta.tableName;
+            if (!prop.discriminatorMap) {
+                prop.discriminatorMap = { [prop.discriminatorValue]: meta.class };
+            }
+        }
+    }
     initEmbeddables(meta, embeddedProp, visited = new Set()) {
         if (embeddedProp.kind !== ReferenceKind.EMBEDDED || visited.has(embeddedProp)) {
             return;
@@ -963,7 +1167,7 @@ export class MetadataDiscovery {
                 meta.root.discriminatorMap[name] = m.class;
             }
         }
-        meta.discriminatorValue = Object.entries(meta.root.discriminatorMap).find(([, cls]) => cls === meta.class)?.[0];
+        meta.discriminatorValue = QueryHelper.findDiscriminatorValue(meta.root.discriminatorMap, meta.class);
         if (!meta.root.properties[meta.root.discriminatorColumn]) {
             this.createDiscriminatorProperty(meta.root);
         }
@@ -1245,7 +1449,7 @@ export class MetadataDiscovery {
         if (Type.isMappedType(prop.customType) && prop.kind === ReferenceKind.SCALAR && !isArray) {
             prop.type = prop.customType.name;
         }
-        if (!prop.customType && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && prop.targetMeta.compositePK) {
+        if (!prop.customType && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && !prop.polymorphic && prop.targetMeta.compositePK) {
             prop.customTypes = [];
             for (const pk of prop.targetMeta.getPrimaryProps()) {
                 if (pk.customType) {
@@ -1274,7 +1478,7 @@ export class MetadataDiscovery {
         }
     }
     initRelation(prop) {
-        if (prop.kind === ReferenceKind.SCALAR) {
+        if (prop.kind === ReferenceKind.SCALAR || prop.polymorphTargets) {
             return;
         }
         // when the target is a polymorphic embedded entity, `prop.target` is an array of classes, we need to get the metadata by the type name instead
@@ -1285,8 +1489,13 @@ export class MetadataDiscovery {
         if (meta2.view) {
             prop.createForeignKeyConstraint = false;
         }
+        // Auto-generate formula for persist: false relations, but only for single-column FKs
+        // Composite FK relations need standard JOIN conditions, not formula-based
         if (!prop.formula && prop.persist === false && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.embedded) {
-            prop.formula = table => `${table}.${this.platform.quoteIdentifier(prop.fieldNames[0])}`;
+            this.initFieldName(prop);
+            if (prop.fieldNames?.length === 1) {
+                prop.formula = table => `${table}.${this.platform.quoteIdentifier(prop.fieldNames[0])}`;
+            }
         }
     }
     initColumnType(prop) {
@@ -1335,6 +1544,9 @@ export class MetadataDiscovery {
         const referencedProps = prop.targetKey
             ? [targetMeta.properties[prop.targetKey]]
             : targetMeta.getPrimaryProps();
+        if (prop.polymorphic && prop.polymorphTargets) {
+            prop.columnTypes.push(this.platform.getVarcharTypeDeclarationSQL(prop));
+        }
         for (const referencedProp of referencedProps) {
             this.initCustomType(targetMeta, referencedProp);
             this.initColumnType(referencedProp);
@@ -1383,8 +1595,7 @@ export class MetadataDiscovery {
             return;
         }
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-            const meta2 = prop.targetMeta;
-            prop.unsigned = meta2.getPrimaryProps().some(pk => {
+            prop.unsigned = prop.targetMeta.getPrimaryProps().some(pk => {
                 this.initUnsigned(pk);
                 return pk.unsigned;
             });

package/metadata/MetadataValidator.d.ts

@@ -9,6 +9,12 @@ export declare class MetadataValidator {
     validateDiscovered(discovered: EntityMetadata[], options: MetadataDiscoveryOptions): void;
     private validateReference;
     private validateTargetKey;
+    /**
+     * Checks if a property has a unique constraint (either via `unique: true` or single-property `@Unique` decorator).
+     * Composite unique constraints are not sufficient for targetKey.
+     */
+    private isPropertyUnique;
+    private validatePolymorphicTargets;
     private validateBidirectional;
     private validateOwningSide;
     private validateInverseSide;

package/metadata/MetadataValidator.js

@@ -107,6 +107,11 @@ export class MetadataValidator {
         if (!prop.type) {
             throw MetadataError.fromWrongTypeDefinition(meta, prop);
         }
+        // Polymorphic relations have multiple targets, validate PK compatibility
+        if (prop.polymorphic && prop.polymorphTargets) {
+            this.validatePolymorphicTargets(meta, prop);
+            return;
+        }
         const targetMeta = prop.targetMeta;
         // references do have type of known entity
         if (!targetMeta) {
@@ -133,11 +138,56 @@ export class MetadataValidator {
         if (!targetProp) {
             throw MetadataError.targetKeyNotFound(meta, prop);
         }
-        // targetKey must point to a unique property
-        if (!targetProp.unique && !targetMeta.uniques?.some(u => u.properties?.includes(prop.targetKey))) {
+        // targetKey must point to a unique property (composite unique is not sufficient)
+        if (!this.isPropertyUnique(targetProp, targetMeta)) {
             throw MetadataError.targetKeyNotUnique(meta, prop);
         }
     }
+    /**
+     * Checks if a property has a unique constraint (either via `unique: true` or single-property `@Unique` decorator).
+     * Composite unique constraints are not sufficient for targetKey.
+     */
+    isPropertyUnique(prop, meta) {
+        if (prop.unique) {
+            return true;
+        }
+        // Check for single-property unique constraint via @Unique decorator
+        return !!meta.uniques?.some(u => {
+            const props = Utils.asArray(u.properties);
+            return props.length === 1 && props[0] === prop.name && !u.options;
+        });
+    }
+    validatePolymorphicTargets(meta, prop) {
+        const targets = prop.polymorphTargets;
+        // Validate targetKey exists and is compatible across all targets
+        if (prop.targetKey) {
+            for (const target of targets) {
+                const targetProp = target.properties[prop.targetKey];
+                if (!targetProp) {
+                    throw MetadataError.targetKeyNotFound(meta, prop, target);
+                }
+                // targetKey must point to a unique property (composite unique is not sufficient)
+                if (!this.isPropertyUnique(targetProp, target)) {
+                    throw MetadataError.targetKeyNotUnique(meta, prop, target);
+                }
+            }
+        }
+        const firstPKs = targets[0].getPrimaryProps();
+        for (let i = 1; i < targets.length; i++) {
+            const target = targets[i];
+            const targetPKs = target.getPrimaryProps();
+            if (targetPKs.length !== firstPKs.length) {
+                throw MetadataError.incompatiblePolymorphicTargets(meta, prop, targets[0], target, 'different number of primary keys');
+            }
+            for (let j = 0; j < firstPKs.length; j++) {
+                const firstPK = firstPKs[j];
+                const targetPK = targetPKs[j];
+                if (firstPK.runtimeType !== targetPK.runtimeType) {
+                    throw MetadataError.incompatiblePolymorphicTargets(meta, prop, targets[0], target, `incompatible primary key types: ${firstPK.name} (${firstPK.runtimeType}) vs ${targetPK.name} (${targetPK.runtimeType})`);
+                }
+            }
+        }
+    }
     validateBidirectional(meta, prop) {
         if (prop.inversedBy) {
             this.validateOwningSide(meta, prop);
@@ -151,6 +201,27 @@ export class MetadataValidator {
         }
     }
     validateOwningSide(meta, prop) {
+        // For polymorphic relations, inversedBy may point to multiple entity types
+        if (prop.polymorphic && prop.polymorphTargets?.length) {
+            // For polymorphic relations, validate inversedBy against each target
+            // The inverse property should exist on the target entities and reference back to this property
+            for (const targetMeta of prop.polymorphTargets) {
+                const inverse = targetMeta.properties[prop.inversedBy];
+                // The inverse property is optional - some targets may not have it
+                if (!inverse) {
+                    continue;
+                }
+                // Validate the inverse property
+                if (inverse.targetMeta?.root.class !== meta.root.class) {
+                    throw MetadataError.fromWrongReference(meta, prop, 'inversedBy', inverse);
+                }
+                // inverse side is not defined as owner
+                if (inverse.inversedBy || inverse.owner) {
+                    throw MetadataError.fromWrongOwnership(meta, prop, 'inversedBy');
+                }
+            }
+            return;
+        }
         const inverse = prop.targetMeta.properties[prop.inversedBy];
         // has correct `inversedBy` on owning side
         if (!inverse) {
@@ -173,7 +244,9 @@ export class MetadataValidator {
             throw MetadataError.fromWrongReference(meta, prop, 'mappedBy');
         }
         // has correct `mappedBy` reference type
-        if (owner.type !== meta.className && owner.targetMeta?.root.class !== meta.root.class) {
+        // For polymorphic relations, check if this entity is one of the polymorphic targets
+        const isValidPolymorphicInverse = owner.polymorphic && owner.polymorphTargets?.some(target => target.class === meta.root.class);
+        if (!isValidPolymorphicInverse && owner.type !== meta.className && owner.targetMeta?.root.class !== meta.root.class) {
             throw MetadataError.fromWrongReference(meta, prop, 'mappedBy', owner);
         }
         // owning side is not defined as inverse

package/metadata/types.d.ts

@@ -321,8 +321,8 @@ export interface PropertyOptions<Owner> {
     ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
 }
 export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner> {
-    /** Set target entity type. */
-    entity?: () => EntityName<Target>;
+    /** Set target entity type. For polymorphic relations, pass an array of entity types. */
+    entity?: () => EntityName<Target> | EntityName<Target>[];
     /** Set what actions on owning entity should be cascaded to the relationship. Defaults to [Cascade.PERSIST, Cascade.MERGE] (see {@doclink cascading}). */
     cascade?: Cascade[];
     /** Always load the relationship. Discouraged for use with to-many relations for performance reasons. */
@@ -337,7 +337,20 @@ export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner>
  * @ignore
  */
 export type ColumnType = 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' | 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' | 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'boolean' | 'bool' | 'bit' | 'enum' | 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' | 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' | 'tsvector' | 'tsquery' | 'json' | 'jsonb';
-export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
+interface PolymorphicOptions {
+    /**
+     * For polymorphic relations. Specifies the property name that stores the entity type discriminator.
+     * Defaults to the property name. Only used when `entity` returns an array of types.
+     * For M:N relations, this is the column name in the pivot table.
+     */
+    discriminator?: string;
+    /**
+     * For polymorphic relations. Custom mapping of discriminator values to entity class names.
+     * If not provided, table names are used as discriminator values.
+     */
+    discriminatorMap?: Dictionary<string>;
+}
+export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target>, PolymorphicOptions {
     /** Point to the inverse side property name. */
     inversedBy?: (string & keyof Target) | ((e: Target) => any);
     /** Wrap the entity in {@apilink Reference} wrapper. */
@@ -391,7 +404,7 @@ export interface OneToManyOptions<Owner, Target> extends ReferenceOptions<Owner,
     /** Point to the owning side property name. */
     mappedBy: (string & keyof Target) | ((e: Target) => any);
 }
-export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>> {
+export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>>, PolymorphicOptions {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;
     /** Point to the inverse side property name. */
@@ -417,7 +430,7 @@ export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOp
     /** Enable/disable foreign key constraint creation on this relation */
     createForeignKeyConstraint?: boolean;
 }
-export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
+export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target>, PolymorphicOptions {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;
     /** Point to the inverse side property name. */
@@ -465,6 +478,9 @@ export interface EmbeddedOptions<Owner, Target> extends PropertyOptions<Owner> {
 export interface EmbeddableOptions<Owner> {
     /** Specify constructor parameters to be used in `em.create` or when `forceConstructor` is enabled. Those should be names of declared entity properties in the same order as your constructor uses them. The ORM tries to infer those automatically, use this option in case the inference fails. */
     constructorParams?: (Owner extends EntityClass<infer P> ? keyof P : string)[];
+    /** For polymorphic embeddables. Specify the property name that stores the discriminator value. Alias for `discriminatorColumn`. */
+    discriminator?: (Owner extends EntityClass<infer P> ? keyof P : string) | AnyString;
+    /** For polymorphic embeddables. @deprecated Use `discriminator` instead. */
     discriminatorColumn?: (Owner extends EntityClass<infer P> ? keyof P : string) | AnyString;
     discriminatorMap?: Dictionary<string>;
     discriminatorValue?: number | string;

package/naming-strategy/AbstractNamingStrategy.d.ts

@@ -30,6 +30,10 @@ export declare abstract class AbstractNamingStrategy implements NamingStrategy {
      * @inheritDoc
      */
     manyToManyPropertyName(ownerEntityName: string, targetEntityName: string, pivotTableName: string, ownerTableName: string, schemaName?: string): string;
+    /**
+     * @inheritDoc
+     */
+    discriminatorColumnName(baseName: string): string;
     abstract classToTableName(entityName: string, tableName?: string): string;
     abstract joinColumnName(propertyName: string): string;
     abstract joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;

package/naming-strategy/AbstractNamingStrategy.js

@@ -85,4 +85,10 @@ export class AbstractNamingStrategy {
     manyToManyPropertyName(ownerEntityName, targetEntityName, pivotTableName, ownerTableName, schemaName) {
         return this.columnNameToProperty(pivotTableName.replace(new RegExp('^' + ownerTableName + '_'), ''));
     }
+    /**
+     * @inheritDoc
+     */
+    discriminatorColumnName(baseName) {
+        return this.propertyToColumnName(baseName + 'Type');
+    }
 }

package/naming-strategy/NamingStrategy.d.ts

@@ -95,4 +95,8 @@ export interface NamingStrategy {
      * @param schemaName - The schema name (if any)
      */
     manyToManyPropertyName(ownerEntityName: string, targetEntityName: string, pivotTableName: string, ownerTableName: string, schemaName?: string): string;
+    /**
+     * Returns the discriminator column name for polymorphic relations.
+     */
+    discriminatorColumnName(baseName: string): string;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.225",
+  "version": "7.0.0-dev.227",
   "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.",
   "exports": {
     "./package.json": "./package.json",

package/typings.d.ts

@@ -295,7 +295,14 @@ export type EntityName<T = any> = EntityClass<T> | EntityCtor<T> | EntitySchema<
 export type GetRepository<Entity extends {
     [k: PropertyKey]: any;
 }, Fallback> = Entity[typeof EntityRepositoryType] extends EntityRepository<any> | undefined ? NonNullable<Entity[typeof EntityRepositoryType]> : Fallback;
-export type EntityDataPropValue<T> = T | Primary<T>;
+type PolymorphicPrimaryInner<T> = T extends object ? Primary<T> extends readonly [infer First, infer Second, ...infer Rest] ? readonly [string, First, Second, ...Rest] | [string, First, Second, ...Rest] : readonly [string, Primary<T>] | [string, Primary<T>] : never;
+/**
+ * Tuple format for polymorphic FK values: [discriminator, ...pkValues]
+ * Distributes over unions, so `Post | Comment` becomes `['post', number] | ['comment', number]`
+ * For composite keys like [tenantId, orgId], becomes ['discriminator', tenantId, orgId]
+ */
+export type PolymorphicPrimary<T> = true extends IsUnion<T> ? PolymorphicPrimaryInner<T> : never;
+export type EntityDataPropValue<T> = T | Primary<T> | PolymorphicPrimary<T>;
 type ExpandEntityProp<T, C extends boolean = false> = T extends Record<string, any> ? {
     [K in keyof T as CleanKeys<T, K>]?: EntityDataProp<ExpandProperty<T[K]>, C> | EntityDataPropValue<ExpandProperty<T[K]>> | null;
 } | EntityDataPropValue<ExpandProperty<T>> : T;
@@ -339,9 +346,9 @@ export type EntityData<T, C extends boolean = false> = {
     [K in EntityKey<T>]?: EntityDataItem<T[K] & {}, C>;
 };
 export type RequiredEntityData<T, I = never, C extends boolean = false> = {
-    [K in keyof T as RequiredKeys<T, K, I>]: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | Raw;
+    [K in keyof T as RequiredKeys<T, K, I>]: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | PolymorphicPrimary<T[K]> | Raw;
 } & {
-    [K in keyof T as OptionalKeys<T, K, I>]?: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | Raw | null;
+    [K in keyof T as OptionalKeys<T, K, I>]?: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | PolymorphicPrimary<T[K]> | Raw | null;
 };
 export type EntityDictionary<T> = EntityData<T> & Record<any, any>;
 type ExtractEagerProps<T> = T extends {
@@ -453,6 +460,11 @@ export interface EntityProperty<Owner = any, Target = any> {
     embeddable: EntityClass<Owner>;
     embeddedProps: Dictionary<EntityProperty>;
     discriminatorColumn?: string;
+    discriminator?: string;
+    polymorphic?: boolean;
+    polymorphTargets?: EntityMetadata[];
+    discriminatorMap?: Dictionary<EntityClass<Target>>;
+    discriminatorValue?: string;
     object?: boolean;
     index?: boolean | string;
     unique?: boolean | string;
@@ -614,6 +626,8 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     polymorphs?: EntityMetadata[];
     root: EntityMetadata<Entity>;
     definedProperties: Dictionary;
+    /** For polymorphic M:N pivot tables, maps discriminator values to entity classes */
+    polymorphicDiscriminatorMap?: Dictionary<EntityClass>;
     hasTriggers?: boolean;
     /** @internal can be used for computed numeric cache keys */
     readonly _id: number;
@@ -853,10 +867,10 @@ type ExtractStringKeys<T> = {
 type StringKeys<T, E extends string = never> = T extends object ? ExtractStringKeys<ExtractType<T>> | E : never;
 type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : (K extends E ? keyof T : never);
 type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-type CollectionKeys<T> = T extends object ? {
-    [K in keyof T]-?: T[K] extends CollectionShape ? IsAny<T[K]> extends true ? never : K & string : never;
+type RelationKeys<T> = T extends object ? {
+    [K in keyof T]-?: CleanKeys<T, K, true>;
 }[keyof T] & {} : never;
-export type AutoPath<O, P extends string | boolean, E extends string = never, D extends Prev[number] = 9> = P extends boolean ? P : [D] extends [never] ? never : P extends any ? P extends string ? P extends `${infer A}.${infer B}` ? A extends StringKeys<O, E> ? `${A}.${AutoPath<NonNullable<GetStringKey<O, A, E>>, B, E, Prev[D]>}` : never : P extends StringKeys<O, E> ? (NonNullable<GetStringKey<O, P & StringKeys<O, E>, E>> extends unknown ? Exclude<P, `${string}.`> : never) | (StringKeys<NonNullable<GetStringKey<O, P & StringKeys<O, E>, E>>, E> extends never ? never : `${P & string}.`) : StringKeys<O, E> | `${CollectionKeys<O>}:ref` : never : never;
+export type AutoPath<O, P extends string | boolean, E extends string = never, D extends Prev[number] = 9> = P extends boolean ? P : [D] extends [never] ? never : P extends any ? P extends string ? P extends `${infer A}.${infer B}` ? A extends StringKeys<O, E> ? `${A}.${AutoPath<NonNullable<GetStringKey<O, A, E>>, B, E, Prev[D]>}` : never : P extends StringKeys<O, E> ? (NonNullable<GetStringKey<O, P & StringKeys<O, E>, E>> extends unknown ? Exclude<P, `${string}.`> : never) | (StringKeys<NonNullable<GetStringKey<O, P & StringKeys<O, E>, E>>, E> extends never ? never : `${P & string}.`) : StringKeys<O, E> | `${RelationKeys<O>}:ref` : never : never;
 export type UnboxArray<T> = T extends any[] ? ArrayElement<T> : T;
 export type ArrayElement<ArrayType extends unknown[]> = ArrayType extends (infer ElementType)[] ? ElementType : never;
 export type ExpandProperty<T> = T extends ReferenceShape<infer U> ? NonNullable<U> : T extends CollectionShape<infer U> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;