@mikro-orm/sql 7.1.0-dev.6 → 7.1.0-dev.7

package/AbstractSqlDriver.d.ts

@@ -83,11 +83,22 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      * 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[]>>;
+    /**
+     * Load a union-target polymorphic M:N pivot (e.g. Post.attachments -> Image | Video).
+     * Each pivot row's discriminator column selects which target table to hydrate.
+     */
+    protected loadFromUnionTargetPolymorphicPivotTable<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[]>>;
     /**
      * Build a map from owner PKs to their related entities from pivot table results.
      */
     private buildPivotResultMap;
     private wrapPopulateFilter;
+    /**
+     * The pivot query builder doesn't convert custom types — manually convert owner PKs to the DB
+     * representation. Returns `needsConversion` + `pkProp` so the caller can convert result FKs back
+     * to JS format for consistent key hashing in `buildPivotResultMap`.
+     */
+    private convertOwnerPksForPivotQuery;
     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

@@ -1106,8 +1106,29 @@ export class AbstractSqlDriver extends DatabaseDriver {
             const pks = wrapped.getPrimaryKeys(true);
             const snap = coll.getSnapshot();
             const includes = (arr, item) => !!arr.find(i => this.comparePrimaryKeyArrays(i, item));
-            const snapshot = snap ? snap.map(item => helper(item).getPrimaryKeys(true)) : [];
-            const current = coll.getItems(false).map(item => helper(item).getPrimaryKeys(true));
+            // For union-target polymorphic M:N, prepend the per-row discriminator value so the pivot
+            // persister can write it alongside the FK id. Memoized per sync-run because a collection can
+            // hold hundreds of items of the same few types, and findDiscriminatorValue walks the prototype
+            // chain + re-scans Object.entries each call.
+            const isUnionTargetMN = QueryHelper.isUnionTargetPolymorphic(coll.property);
+            const classToDisc = new Map();
+            const toDiff = (item) => {
+                const keys = helper(item).getPrimaryKeys(true);
+                if (!isUnionTargetMN) {
+                    return keys;
+                }
+                let disc = classToDisc.get(item.constructor);
+                if (!classToDisc.has(item.constructor)) {
+                    disc = QueryHelper.findDiscriminatorValue(coll.property.discriminatorMap, item.constructor);
+                    if (disc === undefined) {
+                        throw new Error(`Cannot resolve discriminator value for ${item.constructor.name} in ${coll.property.name}; the class is not part of the union target list.`);
+                    }
+                    classToDisc.set(item.constructor, disc);
+                }
+                return [disc, ...keys];
+            };
+            const snapshot = snap ? snap.map(toDiff) : [];
+            const current = coll.getItems(false).map(toDiff);
             const deleteDiff = snap ? snapshot.filter(item => !includes(current, item)) : true;
             const insertDiff = current.filter(item => !includes(snapshot, item));
             const target = snapshot.filter(item => includes(current, item)).concat(...insertDiff);
@@ -1179,21 +1200,16 @@ export class AbstractSqlDriver extends DatabaseDriver {
             return {};
         }
         const pivotMeta = this.metadata.get(prop.pivotEntity);
+        if (prop.discriminatorColumn && QueryHelper.isUnionTargetPolymorphic(prop)) {
+            return this.loadFromUnionTargetPolymorphicPivotTable(prop, owners, where, orderBy, ctx, options, pivotJoin);
+        }
         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;
-        // The pivot query builder doesn't convert custom types, so we need to manually
-        // convert owner PKs to DB format for the query and convert result FKs back to
-        // JS format for consistent key hashing in buildPivotResultMap.
-        const pkProp = ownerMeta.properties[ownerMeta.primaryKeys[0]];
-        const needsConversion = pkProp?.customType?.ensureComparable(ownerMeta, pkProp) && !ownerMeta.compositePK;
-        let ownerPks = ownerMeta.compositePK ? owners : owners.map(o => o[0]);
-        if (needsConversion) {
-            ownerPks = ownerPks.map(v => pkProp.customType.convertToDatabaseValue(v, this.platform, { mode: 'query' }));
-        }
+        const { ownerPks, needsConversion, pkProp } = this.convertOwnerPksForPivotQuery(owners, ownerMeta);
         const cond = {
             [pivotProp2.name]: { $in: ownerPks },
         };
@@ -1347,6 +1363,102 @@ export class AbstractSqlDriver extends DatabaseDriver {
         });
         return this.buildPivotResultMap(owners, res, tagProp.name, ownerRelationName);
     }
+    /**
+     * Load a union-target polymorphic M:N pivot (e.g. Post.attachments -> Image | Video).
+     * Each pivot row's discriminator column selects which target table to hydrate.
+     */
+    async loadFromUnionTargetPolymorphicPivotTable(prop, owners, where = {}, orderBy, ctx, options = {}, pivotJoin) {
+        // :ref hints cannot be honored for union-target — EntityLoader.getReference needs a concrete
+        // class per item, but the ref-mode map only carries flat PK values and would hydrate every
+        // row as the first polymorph target. Fail loudly instead of silently corrupting the collection.
+        if (pivotJoin) {
+            throw new Error(`The ':ref' populate hint is not supported for union-target polymorphic M:N on ${prop.name}. Use a regular populate hint instead.`);
+        }
+        const pivotMeta = this.metadata.get(prop.pivotEntity);
+        const targets = prop.polymorphTargets;
+        const ownerProp = pivotMeta.relations.find(r => r.persist !== false && !r.polymorphic);
+        const discriminatorColumn = prop.discriminatorColumn;
+        const ownerMeta = ownerProp.targetMeta;
+        const { ownerPks, needsConversion, pkProp } = this.convertOwnerPksForPivotQuery(owners, ownerMeta);
+        const pivotRows = (await this.find(pivotMeta.class, { [ownerProp.name]: { $in: ownerPks } }, {
+            ctx,
+            orderBy: this.getPivotOrderBy(prop, ownerProp, orderBy, options?.orderBy),
+            fields: [ownerProp.name, discriminatorColumn, prop.discriminator],
+            populateWhere: undefined,
+            // @ts-ignore
+            _populateWhere: 'infer',
+        }));
+        /* v8 ignore next 7 - custom-type PK conversion, tested via loadFromPivotTable path */
+        if (needsConversion) {
+            for (const item of pivotRows) {
+                const fk = item[ownerProp.name];
+                if (fk != null) {
+                    item[ownerProp.name] = pkProp.customType.convertToJSValue(fk, this.platform);
+                }
+            }
+        }
+        const classMeta = new Map(targets.map(t => [t.class, t]));
+        const rowsByTarget = new Map();
+        for (const row of pivotRows) {
+            const discValue = row[discriminatorColumn];
+            const targetClass = prop.discriminatorMap[discValue];
+            const targetMeta = classMeta.get(targetClass);
+            /* v8 ignore next 3 - defensive: unknown discriminator value */
+            if (!targetMeta) {
+                continue;
+            }
+            const list = rowsByTarget.get(targetMeta) ?? [];
+            list.push(row);
+            rowsByTarget.set(targetMeta, list);
+        }
+        // Strip the outer find's orderBy/fields/exclude before bulk-loading targets by PK — those apply
+        // to the owner query, not each polymorph target (Image and Video wouldn't share an orderBy field).
+        // populateFilter is a filter on the populated collection; since union-target splits the pivot
+        // and target queries, we merge it into the target-level `where` instead of wrapping it on the
+        // pivot query (where joins to target tables aren't available).
+        // Hoisted above the loop since `options` doesn't change per target.
+        const { orderBy: _o, fields: _f, exclude: _e, populateFilter, ...childOptions } = options;
+        const populate = options.populate ?? [];
+        const orphanedRows = new Set();
+        for (const [targetMeta, rows] of rowsByTarget) {
+            const targetIds = rows.map(r => r[prop.discriminator]);
+            // Union-target pivot stores one scalar FK per row; composite-PK targets are rejected at
+            // metadata validation time, so a single primary key column is guaranteed here.
+            const pkCol = targetMeta.primaryKeys[0];
+            let cond = { [pkCol]: { $in: targetIds } };
+            if (!Utils.isEmpty(where)) {
+                cond = { $and: [cond, where] };
+            }
+            if (!Utils.isEmpty(populateFilter)) {
+                cond = { $and: [cond, populateFilter] };
+            }
+            const results = (await this.find(targetMeta.class, cond, {
+                ctx,
+                ...childOptions,
+                populate: populate,
+            }));
+            const byPk = new Map();
+            for (const row of results) {
+                Object.defineProperty(row, 'constructor', {
+                    value: targetMeta.class,
+                    enumerable: false,
+                    configurable: true,
+                });
+                byPk.set(Utils.getPrimaryKeyHash([row[pkCol]]), row);
+            }
+            for (const row of rows) {
+                const pkHash = Utils.getPrimaryKeyHash([row[prop.discriminator]]);
+                const entity = byPk.get(pkHash);
+                if (entity == null) {
+                    orphanedRows.add(row);
+                    continue;
+                }
+                row[prop.discriminator] = entity;
+            }
+        }
+        const result = orphanedRows.size > 0 ? pivotRows.filter(r => !orphanedRows.has(r)) : pivotRows;
+        return this.buildPivotResultMap(owners, result, ownerProp.name, prop.discriminator);
+    }
     /**
      * Build a map from owner PKs to their related entities from pivot table results.
      */
@@ -1371,6 +1483,21 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return undefined;
     }
+    /**
+     * The pivot query builder doesn't convert custom types — manually convert owner PKs to the DB
+     * representation. Returns `needsConversion` + `pkProp` so the caller can convert result FKs back
+     * to JS format for consistent key hashing in `buildPivotResultMap`.
+     */
+    convertOwnerPksForPivotQuery(owners, ownerMeta) {
+        const pkProp = ownerMeta.properties[ownerMeta.primaryKeys[0]];
+        const needsConversion = !!pkProp?.customType?.ensureComparable(ownerMeta, pkProp) && !ownerMeta.compositePK;
+        let ownerPks = ownerMeta.compositePK ? owners : owners.map(o => o[0]);
+        /* v8 ignore next 4 - custom-type PK conversion, tested via loadFromPivotTable path */
+        if (needsConversion) {
+            ownerPks = ownerPks.map(v => pkProp.customType.convertToDatabaseValue(v, this.platform, { mode: 'query' }));
+        }
+        return { ownerPks, needsConversion, pkProp };
+    }
     getPivotOrderBy(prop, pivotProp, orderBy, parentOrderBy) {
         if (!Utils.isEmpty(orderBy) || RawQueryFragment.hasObjectFragments(orderBy)) {
             return Utils.asArray(orderBy).map(o => ({ [pivotProp.name]: o }));
@@ -1437,6 +1564,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (ref && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
                 return true;
             }
+            // Union-target polymorphic M:N cannot be loaded via a single JOIN because rows span multiple
+            // target tables; fall through to SELECT_IN which dispatches through `loadFromPivotTable`.
+            // Polymorphic M:1 (to-one with target_type discriminator) is handled via LEFT JOINs elsewhere.
+            if (prop.kind === ReferenceKind.MANY_TO_MANY && QueryHelper.isUnionTargetPolymorphic(prop) && prop.owner) {
+                return false;
+            }
             // skip redundant joins for 1:1 owner population hints when using `mapToPk`
             if (prop.kind === ReferenceKind.ONE_TO_ONE && prop.mapToPk && prop.owner) {
                 return false;

package/PivotCollectionPersister.js

@@ -1,3 +1,4 @@
+import { QueryHelper, } from '@mikro-orm/core';
 class InsertStatement {
     order;
     #keys;
@@ -106,6 +107,16 @@ export class PivotCollectionPersister {
     buildPivotKeysAndData(prop, fks, pks, deleteAll = false) {
         let data;
         let keys;
+        // Union-target polymorphic M:N prepends the per-row discriminator to `fks` in syncCollections;
+        // Rails-style polymorphic M:N uses a static discriminatorValue on the prop. Normalize to a single
+        // "current row's discriminator" value so the prepend block below handles both cases uniformly.
+        let rowDiscriminator;
+        if (QueryHelper.isUnionTargetPolymorphic(prop) && !deleteAll && fks.length > 0) {
+            [rowDiscriminator, ...fks] = fks;
+        }
+        else if (prop.polymorphic && prop.discriminatorColumn && prop.discriminatorValue) {
+            rowDiscriminator = prop.discriminatorValue;
+        }
         if (deleteAll) {
             data = pks;
             keys = prop.joinColumns;
@@ -116,8 +127,8 @@ export class PivotCollectionPersister {
                 ? [...prop.inverseJoinColumns, ...prop.joinColumns]
                 : [...prop.joinColumns, ...prop.inverseJoinColumns];
         }
-        if (prop.polymorphic && prop.discriminatorColumn && prop.discriminatorValue) {
-            data = [prop.discriminatorValue, ...data];
+        if (rowDiscriminator !== undefined) {
+            data = [rowDiscriminator, ...data];
             keys = [prop.discriminatorColumn, ...keys];
         }
         return { data, keys };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.6",
+  "version": "7.1.0-dev.7",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.11"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.6"
+    "@mikro-orm/core": "7.1.0-dev.7"
   },
   "engines": {
     "node": ">= 22.17.0"