@mikro-orm/sql 7.0.0-dev.224 → 7.0.0-dev.226

package/AbstractSqlDriver.d.ts

@@ -26,6 +26,11 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected wrapVirtualExpressionInSubqueryStream<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>, type: QueryType.SELECT): AsyncIterableIterator<T>;
     mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T, any, any, any>, map?: Dictionary): EntityData<T> | null;
     private mapJoinedProps;
+    /**
+     * Maps a single property from a joined result row into the relation pojo.
+     * Handles polymorphic FKs, composite keys, Date parsing, and embedded objects.
+     */
+    private mapJoinedProp;
     count<T extends object>(entityName: EntityName<T>, where: any, options?: CountOptions<T>): Promise<number>;
     nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
@@ -40,6 +45,24 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     private comparePrimaryKeyArrays;
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
+    /**
+     * Load from a polymorphic M:N pivot table.
+     */
+    protected loadFromPolymorphicPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
+    /**
+     * Load from owner side of polymorphic M:N (e.g., Post -> Tags)
+     */
+    protected loadPolymorphicPivotOwnerSide<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean, inverseProp?: EntityProperty): Promise<Dictionary<T[]>>;
+    /**
+     * Load from inverse side of polymorphic M:N (e.g., Tag -> Posts)
+     * Uses single query with join via virtual relation on pivot.
+     */
+    protected loadPolymorphicPivotInverseSide<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>): Promise<Dictionary<T[]>>;
+    /**
+     * Build a map from owner PKs to their related entities from pivot table results.
+     */
+    private buildPivotResultMap;
+    private wrapPopulateFilter;
     private getPivotOrderBy;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any, any, any>): AsyncIterableIterator<T>;

package/AbstractSqlDriver.js

@@ -1,4 +1,4 @@
-import { ALIAS_REPLACEMENT_RE, DatabaseDriver, EntityManagerType, getLoadingStrategy, getOnConflictFields, getOnConflictReturningFields, helper, isRaw, LoadStrategy, parseJsonSafe, QueryFlag, QueryHelper, QueryOrder, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ALIAS_REPLACEMENT_RE, DatabaseDriver, EntityManagerType, getLoadingStrategy, getOnConflictFields, getOnConflictReturningFields, helper, isRaw, LoadStrategy, parseJsonSafe, PolymorphicRef, QueryFlag, QueryHelper, QueryOrder, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
 import { QueryBuilder } from './query/QueryBuilder.js';
 import { JoinType, QueryType } from './query/enums.js';
 import { SqlEntityManager } from './SqlEntityManager.js';
@@ -216,6 +216,43 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (!prop) {
                 return;
             }
+            // Polymorphic to-one: iterate targets, find the matching one, build entity from its columns.
+            // Skip :ref hints — no JOINs were created, so the FK reference is already set by the result mapper.
+            if (prop.polymorphic && prop.polymorphTargets?.length && !ref && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                const basePath = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
+                const pathPrefix = !parentJoinPath ? '[populate]' : '';
+                let matched = false;
+                for (const targetMeta of prop.polymorphTargets) {
+                    const targetPath = `${pathPrefix}${basePath}[${targetMeta.className}]`;
+                    const relationAlias = qb.getAliasForJoinPath(targetPath, { matchPopulateJoins: true });
+                    const meta2 = targetMeta;
+                    const targetProps = meta2.props.filter(p => this.platform.shouldHaveColumn(p, hint.children || []));
+                    const hasPK = meta2.getPrimaryProps().every(pk => pk.fieldNames.every(name => root[`${relationAlias}__${name}`] != null));
+                    if (hasPK && !matched) {
+                        matched = true;
+                        let relationPojo = {};
+                        const tz = this.platform.getTimezone();
+                        for (const p of targetProps) {
+                            this.mapJoinedProp(relationPojo, p, relationAlias, root, tz, meta2);
+                        }
+                        // Inject the entity class constructor so that the factory creates the correct type
+                        Object.defineProperty(relationPojo, 'constructor', { value: meta2.class, enumerable: false, configurable: true });
+                        result[prop.name] = relationPojo;
+                        const populateChildren = hint.children || [];
+                        this.mapJoinedProps(relationPojo, meta2, populateChildren, qb, root, map, targetPath);
+                    }
+                    // Clean up aliased columns for ALL targets (even non-matching ones)
+                    for (const p of targetProps) {
+                        for (const name of p.fieldNames) {
+                            delete root[`${relationAlias}__${name}`];
+                        }
+                    }
+                }
+                if (!matched) {
+                    result[prop.name] = null;
+                }
+                return;
+            }
             const pivotRefJoin = prop.kind === ReferenceKind.MANY_TO_MANY && ref;
             const meta2 = prop.targetMeta;
             let path = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
@@ -286,41 +323,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             });
             const tz = this.platform.getTimezone();
             for (const prop of targetProps) {
-                if (prop.fieldNames.every(name => typeof root[`${relationAlias}__${name}`] === 'undefined')) {
-                    continue;
-                }
-                if (prop.fieldNames.length > 1) {
-                    // composite keys
-                    const fk = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
-                    const pk = Utils.mapFlatCompositePrimaryKey(fk, prop);
-                    relationPojo[prop.name] = pk.every(val => val != null) ? pk : null;
-                }
-                else if (prop.runtimeType === 'Date') {
-                    const alias = `${relationAlias}__${prop.fieldNames[0]}`;
-                    const value = root[alias];
-                    if (tz && tz !== 'local' && typeof value === 'string' && !value.includes('+') && value.lastIndexOf('-') < 11 && !value.endsWith('Z')) {
-                        relationPojo[prop.name] = this.platform.parseDate(value + tz);
-                    }
-                    else if (['string', 'number'].includes(typeof value)) {
-                        relationPojo[prop.name] = this.platform.parseDate(value);
-                    }
-                    else {
-                        relationPojo[prop.name] = value;
-                    }
-                }
-                else {
-                    const alias = `${relationAlias}__${prop.fieldNames[0]}`;
-                    relationPojo[prop.name] = root[alias];
-                    if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
-                        const item = parseJsonSafe(relationPojo[prop.name]);
-                        if (Array.isArray(item)) {
-                            relationPojo[prop.name] = item.map(row => (row == null ? row : this.comparator.mapResult(prop.targetMeta, row)));
-                        }
-                        else {
-                            relationPojo[prop.name] = item == null ? item : this.comparator.mapResult(prop.targetMeta, item);
-                        }
-                    }
-                }
+                this.mapJoinedProp(relationPojo, prop, relationAlias, root, tz, meta2);
             }
             // properties can be mapped to multiple places, e.g. when sharing a column in multiple FKs,
             // so we need to delete them after everything is mapped from given level
@@ -345,6 +348,60 @@ export class AbstractSqlDriver extends DatabaseDriver {
             this.mapJoinedProps(relationPojo, meta2, populateChildren, qb, root, map, path);
         });
     }
+    /**
+     * Maps a single property from a joined result row into the relation pojo.
+     * Handles polymorphic FKs, composite keys, Date parsing, and embedded objects.
+     */
+    mapJoinedProp(relationPojo, prop, relationAlias, root, tz, meta) {
+        if (prop.fieldNames.every(name => typeof root[`${relationAlias}__${name}`] === 'undefined')) {
+            return;
+        }
+        if (prop.polymorphic) {
+            const discriminatorAlias = `${relationAlias}__${prop.fieldNames[0]}`;
+            const discriminatorValue = root[discriminatorAlias];
+            const pkFieldNames = prop.fieldNames.slice(1);
+            const pkValues = pkFieldNames.map(name => root[`${relationAlias}__${name}`]);
+            const pkValue = pkValues.length === 1 ? pkValues[0] : pkValues;
+            if (discriminatorValue != null && pkValue != null) {
+                relationPojo[prop.name] = new PolymorphicRef(discriminatorValue, pkValue);
+            }
+            else {
+                relationPojo[prop.name] = null;
+            }
+        }
+        else if (prop.fieldNames.length > 1) {
+            // composite keys
+            const fk = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
+            const pk = Utils.mapFlatCompositePrimaryKey(fk, prop);
+            relationPojo[prop.name] = pk.every(val => val != null) ? pk : null;
+        }
+        else if (prop.runtimeType === 'Date') {
+            const alias = `${relationAlias}__${prop.fieldNames[0]}`;
+            const value = root[alias];
+            if (tz && tz !== 'local' && typeof value === 'string' && !value.includes('+') && value.lastIndexOf('-') < 11 && !value.endsWith('Z')) {
+                relationPojo[prop.name] = this.platform.parseDate(value + tz);
+            }
+            else if (['string', 'number'].includes(typeof value)) {
+                relationPojo[prop.name] = this.platform.parseDate(value);
+            }
+            else {
+                relationPojo[prop.name] = value;
+            }
+        }
+        else {
+            const alias = `${relationAlias}__${prop.fieldNames[0]}`;
+            relationPojo[prop.name] = root[alias];
+            if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
+                const item = parseJsonSafe(relationPojo[prop.name]);
+                if (Array.isArray(item)) {
+                    relationPojo[prop.name] = item.map(row => (row == null ? row : this.comparator.mapResult(prop.targetMeta, row)));
+                }
+                else {
+                    relationPojo[prop.name] = item == null ? item : this.comparator.mapResult(prop.targetMeta, item);
+                }
+            }
+        }
+    }
     async count(entityName, where, options = {}) {
         const meta = this.metadata.get(entityName);
         if (meta.virtual) {
@@ -471,7 +528,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     }
                     if (prop.fieldNames.length > 1) {
                         const newFields = [];
-                        const rawParam = Utils.asArray(row[prop.name]) ?? prop.fieldNames.map(() => null);
+                        let rawParam;
+                        const target = row[prop.name];
+                        if (prop.polymorphic && target instanceof PolymorphicRef) {
+                            rawParam = target.toTuple();
+                        }
+                        else {
+                            rawParam = Utils.asArray(target) ?? prop.fieldNames.map(() => null);
+                        }
                         // Deep flatten nested arrays when needed (for deeply nested composite keys like Tag -> Comment -> Post -> User)
                         const needsFlatten = rawParam.length !== prop.fieldNames.length && rawParam.some(v => Array.isArray(v));
                         const allParam = needsFlatten ? Utils.flatten(rawParam, true) : rawParam;
@@ -644,6 +708,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
         };
         for (const key of keys) {
             const prop = meta.properties[key] ?? meta.root.properties[key];
+            if (prop.polymorphic && prop.fieldNames.length > 1) {
+                for (let idx = 0; idx < data.length; idx++) {
+                    const rowValue = data[idx][key];
+                    if (rowValue instanceof PolymorphicRef) {
+                        data[idx][key] = rowValue.toTuple();
+                    }
+                }
+            }
             prop.fieldNames.forEach((fieldName, fieldNameIdx) => {
                 if (fields.has(fieldName) || (prop.ownColumns && !prop.ownColumns.includes(fieldName))) {
                     return;
@@ -814,10 +886,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
     }
     async loadFromPivotTable(prop, owners, where = {}, orderBy, ctx, options, pivotJoin) {
+        /* v8 ignore next */
         if (owners.length === 0) {
             return {};
         }
         const pivotMeta = this.metadata.get(prop.pivotEntity);
+        if (prop.polymorphic && prop.discriminatorColumn && prop.discriminatorValue) {
+            return this.loadFromPolymorphicPivotTable(prop, owners, where, orderBy, ctx, options, pivotJoin);
+        }
         const pivotProp1 = pivotMeta.relations[prop.owner ? 1 : 0];
         const pivotProp2 = pivotMeta.relations[prop.owner ? 0 : 1];
         const ownerMeta = pivotProp2.targetMeta;
@@ -851,21 +927,122 @@ export class AbstractSqlDriver extends DatabaseDriver {
             populateWhere: undefined,
             // @ts-ignore
             _populateWhere: 'infer',
-            populateFilter: !Utils.isEmpty(options?.populateFilter) || RawQueryFragment.hasObjectFragments(options?.populateFilter)
-                ? { [pivotProp2.name]: options?.populateFilter }
-                : undefined,
+            populateFilter: this.wrapPopulateFilter(options, pivotProp2.name),
+        });
+        return this.buildPivotResultMap(owners, res, pivotProp2.name, pivotProp1.name);
+    }
+    /**
+     * Load from a polymorphic M:N pivot table.
+     */
+    async loadFromPolymorphicPivotTable(prop, owners, where = {}, orderBy, ctx, options, pivotJoin) {
+        const pivotMeta = this.metadata.get(prop.pivotEntity);
+        // Find the M:1 relation on the pivot pointing to the target entity.
+        // We exclude virtual polymorphic owner relations (persist: false) and non-M:1 relations.
+        const inverseProp = pivotMeta.relations.find(r => r.kind === ReferenceKind.MANY_TO_ONE && r.persist !== false && r.targetMeta === prop.targetMeta);
+        if (inverseProp) {
+            return this.loadPolymorphicPivotOwnerSide(prop, owners, where, orderBy, ctx, options, pivotJoin, inverseProp);
+        }
+        return this.loadPolymorphicPivotInverseSide(prop, owners, where, orderBy, ctx, options);
+    }
+    /**
+     * Load from owner side of polymorphic M:N (e.g., Post -> Tags)
+     */
+    async loadPolymorphicPivotOwnerSide(prop, owners, where, orderBy, ctx, options, pivotJoin, inverseProp) {
+        const pivotMeta = this.metadata.get(prop.pivotEntity);
+        const targetMeta = prop.targetMeta;
+        // Build condition: discriminator = 'post' AND {discriminator} IN (...)
+        const cond = {
+            [prop.discriminatorColumn]: prop.discriminatorValue,
+            [prop.discriminator]: { $in: owners.length === 1 && owners[0].length === 1 ? owners.map(o => o[0]) : owners },
+        };
+        if (!Utils.isEmpty(where)) {
+            cond[inverseProp.name] = { ...where };
+        }
+        const populateField = pivotJoin ? `${inverseProp.name}:ref` : inverseProp.name;
+        const populate = this.autoJoinOneToOneOwner(targetMeta, options?.populate ?? [], options?.fields);
+        const childFields = !Utils.isEmpty(options?.fields) ? options.fields.map(f => `${inverseProp.name}.${f}`) : [];
+        const childExclude = !Utils.isEmpty(options?.exclude) ? options.exclude.map(f => `${inverseProp.name}.${f}`) : [];
+        const fields = pivotJoin
+            ? [inverseProp.name, prop.discriminator, prop.discriminatorColumn]
+            : [inverseProp.name, prop.discriminator, prop.discriminatorColumn, ...childFields];
+        const res = await this.find(pivotMeta.class, cond, {
+            ctx,
+            ...options,
+            fields,
+            exclude: childExclude,
+            orderBy: this.getPivotOrderBy(prop, inverseProp, orderBy, options?.orderBy),
+            populate: [{ field: populateField, strategy: LoadStrategy.JOINED, joinType: JoinType.innerJoin, children: populate, dataOnly: inverseProp.mapToPk && !pivotJoin }],
+            populateWhere: undefined,
+            // @ts-ignore
+            _populateWhere: 'infer',
+            populateFilter: this.wrapPopulateFilter(options, inverseProp.name),
         });
+        return this.buildPivotResultMap(owners, res, prop.discriminator, inverseProp.name);
+    }
+    /**
+     * Load from inverse side of polymorphic M:N (e.g., Tag -> Posts)
+     * Uses single query with join via virtual relation on pivot.
+     */
+    async loadPolymorphicPivotInverseSide(prop, owners, where, orderBy, ctx, options) {
+        const pivotMeta = this.metadata.get(prop.pivotEntity);
+        const targetMeta = prop.targetMeta;
+        // Find the relation to the entity we're starting from (e.g., Tag_inverse -> Tag)
+        // Exclude virtual polymorphic owner relations (persist: false) - we want the actual M:N inverse relation
+        const tagProp = pivotMeta.relations.find(r => r.persist !== false && r.targetMeta !== targetMeta);
+        // Find the virtual relation to the polymorphic owner (e.g., taggable_Post -> Post)
+        const ownerRelationName = `${prop.discriminator}_${targetMeta.tableName}`;
+        const ownerProp = pivotMeta.properties[ownerRelationName];
+        // Build condition: discriminator = 'post' AND Tag_inverse IN (tagIds)
+        const cond = {
+            [prop.discriminatorColumn]: prop.discriminatorValue,
+            [tagProp.name]: { $in: owners.length === 1 && owners[0].length === 1 ? owners.map(o => o[0]) : owners },
+        };
+        if (!Utils.isEmpty(where)) {
+            cond[ownerRelationName] = { ...where };
+        }
+        const populateField = ownerRelationName;
+        const populate = this.autoJoinOneToOneOwner(targetMeta, options?.populate ?? [], options?.fields);
+        const childFields = !Utils.isEmpty(options?.fields) ? options.fields.map(f => `${ownerRelationName}.${f}`) : [];
+        const childExclude = !Utils.isEmpty(options?.exclude) ? options.exclude.map(f => `${ownerRelationName}.${f}`) : [];
+        const fields = [ownerRelationName, tagProp.name, prop.discriminatorColumn, ...childFields];
+        const res = await this.find(pivotMeta.class, cond, {
+            ctx,
+            ...options,
+            fields,
+            exclude: childExclude,
+            orderBy: this.getPivotOrderBy(prop, ownerProp, orderBy, options?.orderBy),
+            populate: [{ field: populateField, strategy: LoadStrategy.JOINED, joinType: JoinType.innerJoin, children: populate }],
+            populateWhere: undefined,
+            // @ts-ignore
+            _populateWhere: 'infer',
+            populateFilter: this.wrapPopulateFilter(options, ownerRelationName),
+        });
+        return this.buildPivotResultMap(owners, res, tagProp.name, ownerRelationName);
+    }
+    /**
+     * Build a map from owner PKs to their related entities from pivot table results.
+     */
+    buildPivotResultMap(owners, results, keyProp, valueProp) {
         const map = {};
         for (const owner of owners) {
             const key = Utils.getPrimaryKeyHash(owner);
             map[key] = [];
         }
-        for (const item of res) {
-            const key = Utils.getPrimaryKeyHash(Utils.asArray(item[pivotProp2.name]));
-            map[key].push(item[pivotProp1.name]);
+        for (const item of results) {
+            const key = Utils.getPrimaryKeyHash(Utils.asArray(item[keyProp]));
+            const entity = item[valueProp];
+            if (map[key]) {
+                map[key].push(entity);
+            }
         }
         return map;
     }
+    wrapPopulateFilter(options, propName) {
+        if (!Utils.isEmpty(options?.populateFilter) || RawQueryFragment.hasObjectFragments(options?.populateFilter)) {
+            return { [propName]: options?.populateFilter };
+        }
+        return undefined;
+    }
     getPivotOrderBy(prop, pivotProp, orderBy, parentOrderBy) {
         if (!Utils.isEmpty(orderBy) || RawQueryFragment.hasObjectFragments(orderBy)) {
             return Utils.asArray(orderBy).map(o => ({ [pivotProp.name]: o }));
@@ -1022,6 +1199,26 @@ export class AbstractSqlDriver extends DatabaseDriver {
         for (const hint of joinedProps) {
             const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
+            // Polymorphic to-one: create a LEFT JOIN per target type
+            // Skip :ref hints — polymorphic to-one already has FK + discriminator in the row
+            if (prop.polymorphic && prop.polymorphTargets?.length && !ref && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                const basePath = options.parentJoinPath ? `${options.parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
+                const pathPrefix = !options.parentJoinPath && populateWhereAll && !basePath.startsWith('[populate]') ? '[populate]' : '';
+                for (const targetMeta of prop.polymorphTargets) {
+                    const tableAlias = qb.getNextAlias(targetMeta.className);
+                    const targetPath = `${pathPrefix}${basePath}[${targetMeta.className}]`;
+                    const schema = targetMeta.schema === '*' ? (options?.schema ?? this.config.get('schema')) : targetMeta.schema;
+                    qb.addPolymorphicJoin(prop, targetMeta, options.parentTableAlias, tableAlias, JoinType.leftJoin, targetPath, schema);
+                    // Select fields from each target table
+                    fields.push(...this.getFieldsForJoinedLoad(qb, targetMeta, {
+                        ...options,
+                        populate: hint.children,
+                        parentTableAlias: tableAlias,
+                        parentJoinPath: targetPath,
+                    }));
+                }
+                continue;
+            }
             // ignore ref joins of known FKs unless it's a filter hint
             if (ref && !hint.filter && (prop.kind === ReferenceKind.MANY_TO_ONE || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
                 continue;
@@ -1186,10 +1383,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 where[prop.name] = Utils.copy(prop.where);
             }
             if (hint.children) {
-                const inner = this.buildPopulateWhere(prop.targetMeta, hint.children, {});
-                if (!Utils.isEmpty(inner) || RawQueryFragment.hasObjectFragments(inner)) {
-                    where[prop.name] ??= {};
-                    Object.assign(where[prop.name], inner);
+                const targetMeta = prop.targetMeta;
+                if (targetMeta) {
+                    const inner = this.buildPopulateWhere(targetMeta, hint.children, {});
+                    if (!Utils.isEmpty(inner) || RawQueryFragment.hasObjectFragments(inner)) {
+                        where[prop.name] ??= {};
+                        Object.assign(where[prop.name], inner);
+                    }
                 }
             }
         }
@@ -1280,7 +1480,6 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
             const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true });
-            const meta2 = prop.targetMeta;
             if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
                 const alias = ref ? propAlias : join.ownerAlias;
                 orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: QueryOrder.ASC });
@@ -1301,7 +1500,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 }
             }
             if (hint.children) {
-                const buildJoinedPropsOrderBy = this.buildJoinedPropsOrderBy(qb, meta2, hint.children, options, path);
+                const buildJoinedPropsOrderBy = this.buildJoinedPropsOrderBy(qb, prop.targetMeta, hint.children, options, path);
                 orderBy.push(...buildJoinedPropsOrderBy);
             }
         }

package/PivotCollectionPersister.d.ts

@@ -17,6 +17,11 @@ export declare class PivotCollectionPersister<Entity extends object> {
     private enqueueUpsert;
     private createInsertStatement;
     private enqueueDelete;
+    /**
+     * Build the keys and data arrays for pivot table operations.
+     * Handles polymorphic M:N by prepending the discriminator column/value.
+     */
+    private buildPivotKeysAndData;
     private collectStatements;
     execute(): Promise<void>;
 }

package/PivotCollectionPersister.js

@@ -83,27 +83,45 @@ export class PivotCollectionPersister {
         }
     }
     createInsertStatement(prop, fks, pks) {
-        const data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
-        const keys = prop.owner
-            ? [...prop.inverseJoinColumns, ...prop.joinColumns]
-            : [...prop.joinColumns, ...prop.inverseJoinColumns];
+        const { data, keys } = this.buildPivotKeysAndData(prop, fks, pks);
         return new InsertStatement(keys, data, this.order++);
     }
     enqueueDelete(prop, deleteDiff, pks) {
         if (deleteDiff === true) {
-            const statement = new DeleteStatement(prop.joinColumns, pks);
+            const { data, keys } = this.buildPivotKeysAndData(prop, [], pks, true);
+            const statement = new DeleteStatement(keys, data);
             this.deletes.set(statement.getHash(), statement);
             return;
         }
         for (const fks of deleteDiff) {
-            const data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
-            const keys = prop.owner
-                ? [...prop.inverseJoinColumns, ...prop.joinColumns]
-                : [...prop.joinColumns, ...prop.inverseJoinColumns];
+            const { data, keys } = this.buildPivotKeysAndData(prop, fks, pks);
             const statement = new DeleteStatement(keys, data);
             this.deletes.set(statement.getHash(), statement);
         }
     }
+    /**
+     * Build the keys and data arrays for pivot table operations.
+     * Handles polymorphic M:N by prepending the discriminator column/value.
+     */
+    buildPivotKeysAndData(prop, fks, pks, deleteAll = false) {
+        let data;
+        let keys;
+        if (deleteAll) {
+            data = pks;
+            keys = prop.joinColumns;
+        }
+        else {
+            data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
+            keys = prop.owner
+                ? [...prop.inverseJoinColumns, ...prop.joinColumns]
+                : [...prop.joinColumns, ...prop.inverseJoinColumns];
+        }
+        if (prop.polymorphic && prop.discriminatorColumn && prop.discriminatorValue) {
+            data = [prop.discriminatorValue, ...data];
+            keys = [prop.discriminatorColumn, ...keys];
+        }
+        return { data, keys };
+    }
     collectStatements(statements) {
         const items = [];
         for (const statement of statements.values()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.224",
+  "version": "7.0.0-dev.226",
   "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.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.224"
+    "@mikro-orm/core": "7.0.0-dev.226"
   }
 }

package/query/QueryBuilder.d.ts

@@ -662,6 +662,12 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * @internal
      */
     getNextAlias(entityName?: string | EntityName): string;
+    /**
+     * Registers a join for a specific polymorphic target type.
+     * Used by the driver to create per-target LEFT JOINs for JOINED loading.
+     * @internal
+     */
+    addPolymorphicJoin(prop: EntityProperty, targetMeta: EntityMetadata, ownerAlias: string, alias: string, type: JoinType, path: string, schema?: string): void;
     /**
      * @internal
      */

package/query/QueryBuilder.js

@@ -784,6 +784,21 @@ export class QueryBuilder {
         entityName = Utils.className(entityName);
         return this.driver.config.getNamingStrategy().aliasName(entityName, this.aliasCounter++);
     }
+    /**
+     * Registers a join for a specific polymorphic target type.
+     * Used by the driver to create per-target LEFT JOINs for JOINED loading.
+     * @internal
+     */
+    addPolymorphicJoin(prop, targetMeta, ownerAlias, alias, type, path, schema) {
+        // Override referencedColumnNames to use the specific target's PK columns
+        // (polymorphic targets may have different PK column names, e.g. org_id vs user_id)
+        const referencedColumnNames = targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
+        const targetProp = { ...prop, targetMeta, referencedColumnNames };
+        const aliasedName = `${ownerAlias}.${prop.name}[${targetMeta.className}]#${alias}`;
+        this._joins[aliasedName] = this.helper.joinManyToOneReference(targetProp, ownerAlias, alias, type, {}, schema);
+        this._joins[aliasedName].path = path;
+        this.createAlias(targetMeta.class, alias);
+    }
     /**
      * @internal
      */

package/query/QueryBuilderHelper.js

@@ -1,4 +1,4 @@
-import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, inspect, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, Raw, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
+import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, inspect, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, Raw, QueryHelper, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
@@ -133,6 +133,14 @@ export class QueryBuilderHelper {
         const primaryKeys = prop.owner ? prop.joinColumns : prop2.referencedColumnNames;
         schema ??= prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta);
         cond = Utils.merge(cond, prop.where);
+        // For inverse side of polymorphic relations, add discriminator condition
+        if (!prop.owner && prop2.polymorphic && prop2.discriminatorColumn && prop2.discriminatorMap) {
+            const ownerMeta = this.aliasMap[ownerAlias]?.meta ?? this.metadata.get(this.entityName);
+            const discriminatorValue = QueryHelper.findDiscriminatorValue(prop2.discriminatorMap, ownerMeta.class);
+            if (discriminatorValue) {
+                cond[`${alias}.${prop2.discriminatorColumn}`] = discriminatorValue;
+            }
+        }
         return {
             prop, type, cond, ownerAlias, alias, table, schema,
             joinColumns, inverseJoinColumns, primaryKeys,
@@ -144,7 +152,9 @@ export class QueryBuilderHelper {
             table: this.getTableName(prop.targetMeta.class),
             schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta, { schema }),
             joinColumns: prop.referencedColumnNames,
-            primaryKeys: prop.fieldNames,
+            // For polymorphic relations, fieldNames includes the discriminator column which is not
+            // part of the join condition - use joinColumns (the FK columns only) instead
+            primaryKeys: prop.polymorphic ? prop.joinColumns : prop.fieldNames,
         };
     }
     joinManyToManyReference(prop, ownerAlias, alias, pivotAlias, type, cond, path, schema) {
@@ -218,6 +228,15 @@ export class QueryBuilderHelper {
             const alias = join.inverseAlias ?? join.alias;
             join.cond[`${alias}.${typeProperty}`] = join.prop.targetMeta.discriminatorValue;
         }
+        // For polymorphic relations, add discriminator condition to filter by target entity type
+        if (join.prop.polymorphic && join.prop.discriminatorColumn && join.prop.discriminatorMap) {
+            const discriminatorValue = QueryHelper.findDiscriminatorValue(join.prop.discriminatorMap, join.prop.targetMeta.class);
+            if (discriminatorValue) {
+                const discriminatorCol = this.platform.quoteIdentifier(`${join.ownerAlias}.${join.prop.discriminatorColumn}`);
+                conditions.push(`${discriminatorCol} = ?`);
+                params.push(discriminatorValue);
+            }
+        }
         let sql = method + ' ';
         if (join.nested) {
             sql += `(${this.platform.quoteIdentifier(table)} as ${this.platform.quoteIdentifier(join.alias)}`;

package/schema/DatabaseTable.js

@@ -103,7 +103,7 @@ export class DatabaseTable {
             const defaultValue = this.platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
             this.columns[field].default = defaultValue;
         });
-        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.polymorphic) {
             const constraintName = this.getIndexName(prop.foreignKeyName ?? true, prop.fieldNames, 'foreign');
             let schema = prop.targetMeta.root.schema === '*' ? this.schema : (prop.targetMeta.root.schema ?? config.get('schema', this.platform.getDefaultSchemaName()));
             if (prop.referencedTableName.includes('.')) {

package/schema/SqlSchemaGenerator.js

@@ -406,7 +406,10 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
             }
             return;
         }
-        await Utils.runSerial(groups.flat(), line => this.driver.execute(line));
+        const statements = groups.flatMap(group => {
+            return group.join('\n').split(';\n').map(s => s.trim()).filter(s => s);
+        });
+        await Utils.runSerial(statements, stmt => this.driver.execute(stmt));
     }
     async dropTableIfExists(name, schema) {
         const sql = this.helper.dropTableIfExists(name, schema);