@mikro-orm/sql 7.1.9-dev.22 → 7.1.9-dev.24

package/AbstractSqlDriver.js

@@ -1316,7 +1316,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 }
             }
         }
-        return this.buildPivotResultMap(owners, res, pivotProp2.name, pivotProp1.name);
+        return this.buildPivotResultMap(owners, res, pivotProp2.name, pivotProp1.name, ownerMeta);
     }
     /**
      * Load from a polymorphic M:N pivot table.
@@ -1337,10 +1337,15 @@ export class AbstractSqlDriver extends DatabaseDriver {
     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 (...)
+        // `prop.discriminator` spans all owner FK columns but carries no target metadata, so a composite
+        // owner PK neither expands to a tuple condition nor gets mapped back; the virtual M:1 relation
+        // to this discriminator's owner describes the same columns as an actual relation
+        const ownerMeta = this.metadata.get(pivotMeta.polymorphicDiscriminatorMap[prop.discriminatorValue]);
+        const ownerProp = pivotMeta.properties[`${prop.discriminator}_${ownerMeta.tableName}`];
+        // Build condition: discriminator = 'post' AND {owner} IN (...)
         const cond = {
             [prop.discriminatorColumn]: prop.discriminatorValue,
-            [prop.discriminator]: { $in: owners.length === 1 && owners[0].length === 1 ? owners.map(o => o[0]) : owners },
+            [ownerProp.name]: { $in: owners.length === 1 && owners[0].length === 1 ? owners.map(o => o[0]) : owners },
         };
         if (!Utils.isEmpty(where)) {
             cond[inverseProp.name] = { ...where };
@@ -1351,9 +1356,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const childExclude = !Utils.isEmpty(options?.exclude)
             ? options.exclude.map(f => `${inverseProp.name}.${f}`)
             : [];
+        // the owner relation is virtual, so the FK columns have to be selected via the per-column pivot
+        // props a composite owner PK gets; a single column owner PK is covered by the flat prop itself
+        const ownerFields = ownerMeta.compositePK ? prop.joinColumns : [prop.discriminator];
         const fields = pivotJoin
-            ? [inverseProp.name, prop.discriminator, prop.discriminatorColumn]
-            : [inverseProp.name, prop.discriminator, prop.discriminatorColumn, ...childFields];
+            ? [inverseProp.name, ...ownerFields, prop.discriminatorColumn]
+            : [inverseProp.name, ...ownerFields, prop.discriminatorColumn, ...childFields];
         const res = await this.find(pivotMeta.class, cond, {
             ctx,
             ...options,
@@ -1374,7 +1382,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             _populateWhere: 'infer',
             populateFilter: this.wrapPopulateFilter(options, inverseProp.name),
         });
-        return this.buildPivotResultMap(owners, res, prop.discriminator, inverseProp.name);
+        return this.buildPivotResultMap(owners, res, ownerProp.name, inverseProp.name, ownerMeta);
     }
     /**
      * Load from inverse side of polymorphic M:N (e.g., Tag -> Posts)
@@ -1423,7 +1431,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             _populateWhere: 'infer',
             populateFilter: this.wrapPopulateFilter(options, ownerRelationName),
         });
-        return this.buildPivotResultMap(owners, res, tagProp.name, ownerRelationName);
+        return this.buildPivotResultMap(owners, res, tagProp.name, ownerRelationName, tagProp.targetMeta);
     }
     /**
      * Load a union-target polymorphic M:N pivot (e.g. Post.attachments -> Image | Video).
@@ -1519,19 +1527,23 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
         }
         const result = orphanedRows.size > 0 ? pivotRows.filter(r => !orphanedRows.has(r)) : pivotRows;
-        return this.buildPivotResultMap(owners, result, ownerProp.name, prop.discriminator);
+        return this.buildPivotResultMap(owners, result, ownerProp.name, prop.discriminator, ownerMeta);
     }
     /**
      * Build a map from owner PKs to their related entities from pivot table results.
      */
-    buildPivotResultMap(owners, results, keyProp, valueProp) {
+    buildPivotResultMap(owners, results, keyProp, valueProp, ownerMeta) {
         const map = {};
         for (const owner of owners) {
             const key = Utils.getPrimaryKeyHash(owner);
             map[key] = [];
         }
         for (const item of results) {
-            const key = Utils.getPrimaryKeyHash(Utils.asArray(item[keyProp]));
+            const fk = item[keyProp];
+            // the owner PKs are always flat, while the pivot FK follows the owner PK structure,
+            // so a PK built from a relation to another composite PK entity needs flattening too
+            const pks = ownerMeta && fk != null ? Utils.getOrderedPrimaryKeys(fk, ownerMeta) : Utils.asArray(fk);
+            const key = Utils.getPrimaryKeyHash(pks);
             const entity = item[valueProp];
             if (map[key]) {
                 map[key].push(entity);
@@ -1657,8 +1669,23 @@ export class AbstractSqlDriver extends DatabaseDriver {
             const [propName, ref] = hint.field.split(':', 2);
             return { propName, ref, children: hint.children };
         });
+        // with `fixedOrder` the pivot PK is the order column, which is not guaranteed to be unique when the
+        // pivot table is managed externally, so we disambiguate the rows by their FKs on top of the PK
+        const pivotRelations = meta.pivotTable && !meta.compositePK
+            ? meta.relations.filter(p => p.kind === ReferenceKind.MANY_TO_ONE && p.persist !== false)
+            : [];
         for (const item of rawResults) {
-            const pk = Utils.getCompositeKeyHash(item, meta);
+            let pk = Utils.getCompositeKeyHash(item, meta);
+            if (pivotRelations.length > 0) {
+                pk = Utils.getPrimaryKeyHash([
+                    pk,
+                    ...pivotRelations.flatMap(p => {
+                        const value = item[p.name];
+                        // composite FKs are mapped to an array of values, which `extractPK` does not accept
+                        return (Array.isArray(value) ? value : Utils.extractPK(value, p.targetMeta));
+                    }),
+                ]);
+            }
             if (map[pk]) {
                 for (const { propName } of hints) {
                     if (!item[propName]) {
@@ -2087,7 +2114,20 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const ret = {};
         for (const prop of meta.relations) {
             if (prop.kind === ReferenceKind.MANY_TO_MANY && data[prop.name]) {
-                ret[prop.name] = data[prop.name].map((item) => Utils.asArray(item));
+                // union targets are validated to have a single PK column, so a pivot row is always keyed
+                // by exactly `[discriminator, pk]` - anything else cannot address a target table
+                const discriminators = QueryHelper.isUnionTargetPolymorphic(prop)
+                    ? Object.keys(prop.discriminatorMap)
+                    : undefined;
+                ret[prop.name] = data[prop.name].map((item) => {
+                    const values = Utils.asArray(item);
+                    if (discriminators && !(values.length === 2 && discriminators.includes('' + values[0]))) {
+                        throw new Error(`Cannot resolve the discriminator value of ${meta.className}.${prop.name} from '${values.join(', ')}', ` +
+                            `as the same primary key can exist in any of the target tables. ` +
+                            `Pass the target as a [discriminator, ...primaryKey] tuple, e.g. ${JSON.stringify([discriminators[0], ...values])}.`);
+                    }
+                    return values;
+                });
                 delete data[prop.name];
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.9-dev.22",
+  "version": "7.1.9-dev.24",
   "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.1.8"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.9-dev.22"
+    "@mikro-orm/core": "7.1.9-dev.24"
   },
   "engines": {
     "node": ">= 22.17.0"