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

package/AbstractSqlDriver.js

@@ -1356,9 +1356,10 @@ 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];
+        // 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, ...ownerFields, prop.discriminatorColumn]
             : [inverseProp.name, ...ownerFields, prop.discriminatorColumn, ...childFields];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.9-dev.24",
+  "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.24"
+    "@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;