@mikro-orm/sql 7.1.9-dev.21 → 7.1.9-dev.23

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.
@@ -1423,7 +1423,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 +1519,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 +1661,19 @@ 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.map(p => Utils.extractPK(item[p.name], p.targetMeta)),
+                ]);
+            }
             if (map[pk]) {
                 for (const { propName } of hints) {
                     if (!item[propName]) {
@@ -2087,7 +2102,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/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -53,6 +53,7 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
+    protected hasInlineColumnComment(): boolean;
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
     alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
     private getColumnDeclarationSQL;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -540,6 +540,9 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const keyName = this.quote(index.keyName);
         return [`alter table ${tableName} rename index ${oldIndexName} to ${keyName}`];
     }
+    hasInlineColumnComment() {
+        return true;
+    }
     getChangeColumnCommentSQL(tableName, to, schemaName) {
         tableName = this.quote(tableName);
         const columnName = this.quote(to.name);

package/package.json

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

package/schema/SchemaHelper.d.ts

@@ -143,6 +143,8 @@ export declare abstract class SchemaHelper {
         }[];
     }[], safe: boolean): string[];
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
+    /** Whether the column comment is part of the column declaration, as opposed to a separate statement. */
+    protected hasInlineColumnComment(): boolean;
     getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
     protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;

package/schema/SchemaHelper.js

@@ -446,7 +446,8 @@ export class SchemaHelper {
             this.append(ret, this.alterTableColumn(column, diff.fromTable, changedProperties));
         }
         for (const { column, changedProperties } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('comment'))) {
-            if (['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems', 'collation'].some(t => changedProperties.has(t))) {
+            if (this.hasInlineColumnComment() &&
+                ['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems', 'collation'].some(t => changedProperties.has(t))) {
                 continue; // will be handled via column update
             }
             ret.push(this.getChangeColumnCommentSQL(tableName, column, schemaName));
@@ -499,7 +500,13 @@ export class SchemaHelper {
             return `add ${this.createTableColumn(column, table)}`;
         })
             .join(', ');
-        return [`alter table ${table.getQuotedName()} ${adds}`];
+        const ret = [`alter table ${table.getQuotedName()} ${adds}`];
+        if (!this.hasInlineColumnComment()) {
+            for (const column of columns.filter(column => column.comment)) {
+                ret.push(this.getChangeColumnCommentSQL(table.name, column, table.schema));
+            }
+        }
+        return ret;
     }
     getDropColumnsSQL(tableName, columns, schemaName) {
         const name = this.quote(this.getTableName(tableName, schemaName));
@@ -618,6 +625,10 @@ export class SchemaHelper {
     getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }
+    /** Whether the column comment is part of the column declaration, as opposed to a separate statement. */
+    hasInlineColumnComment() {
+        return false;
+    }
     async getNamespaces(connection, ctx) {
         return [];
     }