@mikro-orm/sql 7.2.0-dev.1 → 7.2.0-dev.10

package/schema/SqlSchemaGenerator.js

@@ -308,22 +308,6 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const newTable of Object.values(schemaDiff.newTables)) {
             this.append(ret, this.helper.createTable(newTable, true), true);
         }
-        if (this.helper.supportsSchemaConstraints()) {
-            for (const newTable of Object.values(schemaDiff.newTables)) {
-                const sql = [];
-                if (this.options.createForeignKeyConstraints) {
-                    const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
-                    this.append(sql, fks);
-                }
-                for (const check of newTable.getChecks()) {
-                    this.append(sql, this.helper.createCheck(newTable, check));
-                }
-                for (const trigger of newTable.getTriggers()) {
-                    this.append(sql, this.helper.createTrigger(newTable, trigger));
-                }
-                this.append(ret, sql, true);
-            }
-        }
         if (options.dropTables && !options.safe) {
             for (const table of Object.values(schemaDiff.removedTables)) {
                 // Drop triggers before the table so driver-specific cleanup runs (e.g. PostgreSQL function removal)
@@ -353,6 +337,23 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const changedTable of alteredTables) {
             this.append(ret, this.helper.getPostAlterTable(changedTable, options.safe), true);
         }
+        // after the alters, so a new table's FK can reference a unique constraint an existing table gains in the same diff
+        if (this.helper.supportsSchemaConstraints()) {
+            for (const newTable of Object.values(schemaDiff.newTables)) {
+                const sql = [];
+                if (this.options.createForeignKeyConstraints) {
+                    const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
+                    this.append(sql, fks);
+                }
+                for (const check of newTable.getChecks()) {
+                    this.append(sql, this.helper.createCheck(newTable, check));
+                }
+                for (const trigger of newTable.getTriggers()) {
+                    this.append(sql, this.helper.createTrigger(newTable, trigger));
+                }
+                this.append(ret, sql, true);
+            }
+        }
         if (!options.safe && this.platform.supportsNativeEnums()) {
             for (const removedNativeEnum of schemaDiff.removedNativeEnums) {
                 this.append(ret, this.helper.getDropNativeEnumSQL(removedNativeEnum.name, removedNativeEnum.schema));
@@ -439,18 +440,23 @@ 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) {
-            if (line.trim() === '') {
+            const stmt = line.trim();
+            if (stmt === '') {
                 if (groups[i]?.length > 0) {
                     i++;
                 }
                 continue;
             }
+            // same boundary an empty line creates, for statements that have to start their own batch
+            if (groups[i]?.length > 0 && this.startsBatch(stmt)) {
+                i++;
+            }
             groups[i] ??= [];
-            groups[i].push(line.trim());
+            groups[i].push(stmt);
         }
         if (groups.length === 0) {
             return;
@@ -463,14 +469,37 @@ 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;
+    }
     async dropTableIfExists(name, schema) {
         const sql = this.helper.dropTableIfExists(name, schema);
         return this.execute(sql);

package/typings.d.ts

@@ -368,9 +368,9 @@ type MaybeGenerated<TValue, TOptions, TProcessOnCreate extends boolean> = TOptio
 } ? TValue | null : TOptions extends {
     autoincrement: true;
 } ? Generated<TValue> : TOptions extends {
-    default: true;
+    default: unknown;
 } ? Generated<TValue> : TOptions extends {
-    defaultRaw: true;
+    defaultRaw: unknown;
 } ? Generated<TValue> : TProcessOnCreate extends false ? TValue : TOptions extends {
     onCreate: Function;
 } ? Generated<TValue> : TValue;