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

package/AbstractSqlDriver.js

@@ -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,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const childExclude = !Utils.isEmpty(options?.exclude)
             ? options.exclude.map(f => `${inverseProp.name}.${f}`)
             : [];
+        // the owner relation is virtual, so its FK columns have to be selected via the pivot props that
+        // cover them; only the first owner of a shared pivot gets the flat prop named after the
+        // discriminator, and it keeps that owner's columns, so later owners get per-column props instead
+        const ownerFields = Utils.unique(prop.joinColumns.map(col => (pivotMeta.properties[col] ? col : 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 +1383,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)
@@ -1671,7 +1680,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (pivotRelations.length > 0) {
                 pk = Utils.getPrimaryKeyHash([
                     pk,
-                    ...pivotRelations.map(p => Utils.extractPK(item[p.name], p.targetMeta)),
+                    ...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]) {

package/package.json

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

package/schema/SqlSchemaGenerator.d.ts

@@ -54,6 +54,8 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         wrap?: boolean;
         ctx?: Transaction;
     }): Promise<void>;
+    /** Splits the SQL on the separator, keeping the separators that fall inside a string literal. */
+    private splitOutsideLiterals;
     /** Whether the statement has to be the first one in a query batch, e.g. `create trigger` on MSSQL. */
     protected startsBatch(_statement: string): boolean;
     dropTableIfExists(name: string, schema?: string): Promise<void>;

package/schema/SqlSchemaGenerator.js

@@ -439,7 +439,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     }
     async execute(sql, options = {}) {
         options.wrap ??= false;
-        const lines = this.wrapSchema(sql, options).split('\n');
+        const lines = this.splitOutsideLiterals(this.wrapSchema(sql, options), '\n');
         const groups = [];
         let i = 0;
         for (const line of lines) {
@@ -468,14 +468,33 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
             return;
         }
         const statements = groups.flatMap(group => {
-            return group
-                .join('\n')
-                .split(';\n')
+            return this.splitOutsideLiterals(group.join('\n'), ';\n')
                 .map(s => s.trim())
                 .filter(s => s);
         });
         await Utils.runSerial(statements, stmt => this.driver.execute(stmt));
     }
+    /** Splits the SQL on the separator, keeping the separators that fall inside a string literal. */
+    splitOutsideLiterals(sql, separator) {
+        const [idOpen, idClose] = this.platform.quoteIdentifier('');
+        // mysql escapes quotes as `\'`, the other dialects double them, which pairs up on its own
+        const esc = this.platform.quoteValue(`'`).includes(`\\'`) ? '\\\\.|' : '';
+        // complete literals, quoted identifiers and `--` comments, so that an apostrophe inside an
+        // identifier or a comment is not mistaken for one opening a literal
+        const tokens = new RegExp(`'(?:${esc}[^'])*'|\\${idOpen}[^\\${idClose}]*\\${idClose}|--[^\n]*`, 'g');
+        const parts = [];
+        for (const chunk of sql.split(separator)) {
+            const prev = parts.at(-1);
+            // whatever quote is left once the complete tokens are gone opened a literal we are still inside of
+            if (prev?.replace(tokens, '').includes(`'`)) {
+                parts[parts.length - 1] = prev + separator + chunk;
+            }
+            else {
+                parts.push(chunk);
+            }
+        }
+        return parts;
+    }
     /** Whether the statement has to be the first one in a query batch, e.g. `create trigger` on MSSQL. */
     startsBatch(_statement) {
         return false;