@mikro-orm/sql 7.1.9-dev.8 → 7.1.9

package/AbstractSqlConnection.d.ts

@@ -56,6 +56,15 @@ export declare abstract class AbstractSqlConnection extends Connection {
     commit(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
     /** Rolls back the transaction or rolls back to the savepoint. */
     rollback(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
+    /**
+     * Waits until the transaction's connection has no query in flight. Kysely runs `rollback` straight
+     * on that connection instead of going through its connection provider, so a rollback caused by an
+     * aborted query would otherwise be sent while the aborted query is still running. That not only
+     * queues the rollback behind it on the server, it also overwrites the query id Kysely compares
+     * against before firing the `'cancel query'`/`'kill session'` control statement — the control
+     * statement is then discarded as stale and the abort never reaches the database.
+     */
+    private waitForIdleTransaction;
     private prepareQuery;
     /** Executes a SQL query and returns the result based on the method: `'all'` for rows, `'get'` for single row, `'run'` for affected count. */
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;

package/AbstractSqlConnection.js

@@ -110,7 +110,15 @@ export class AbstractSqlConnection extends Connection {
             return ret;
         }
         catch (error) {
-            await this.rollback(trx, options.eventBroadcaster, options.loggerContext);
+            // A failing rollback must not mask why the transaction failed in the first place — the
+            // `'kill session'` abort strategy tears the connection down, so the rollback that follows can
+            // only ever report the dead connection.
+            try {
+                await this.rollback(trx, options.eventBroadcaster, options.loggerContext);
+            }
+            catch (rollbackError) {
+                this.logger.warn('query', `Failed to roll back transaction: ${rollbackError.message}`);
+            }
             throw error;
         }
     }
@@ -138,18 +146,8 @@ export class AbstractSqlConnection extends Connection {
             trxBuilder = trxBuilder.setAccessMode('read only');
         }
         const trx = await trxBuilder.execute();
-        if (options.ctx) {
-            const ctx = options.ctx;
-            ctx.index ??= 0;
-            const savepointName = `trx${ctx.index + 1}`;
-            Reflect.defineProperty(trx, 'index', { value: ctx.index + 1 });
-            Reflect.defineProperty(trx, 'savepointName', { value: savepointName });
-            this.logQuery(this.platform.getSavepointSQL(savepointName), options.loggerContext);
-        }
-        else {
-            for (const query of this.platform.getBeginTransactionSQL(options)) {
-                this.logQuery(query, options.loggerContext);
-            }
+        for (const query of this.platform.getBeginTransactionSQL(options)) {
+            this.logQuery(query, options.loggerContext);
         }
         await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
         return trx;
@@ -173,6 +171,7 @@ export class AbstractSqlConnection extends Connection {
     /** Rolls back the transaction or rolls back to the savepoint. */
     async rollback(ctx, eventBroadcaster, loggerContext) {
         await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionRollback, ctx);
+        await this.waitForIdleTransaction(ctx);
         if ('savepointName' in ctx) {
             await ctx.rollbackToSavepoint(ctx.savepointName).execute();
             this.logQuery(this.platform.getRollbackToSavepointSQL(ctx.savepointName), loggerContext);
@@ -183,6 +182,17 @@ export class AbstractSqlConnection extends Connection {
         }
         await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
     }
+    /**
+     * Waits until the transaction's connection has no query in flight. Kysely runs `rollback` straight
+     * on that connection instead of going through its connection provider, so a rollback caused by an
+     * aborted query would otherwise be sent while the aborted query is still running. That not only
+     * queues the rollback behind it on the server, it also overwrites the query id Kysely compares
+     * against before firing the `'cancel query'`/`'kill session'` control statement — the control
+     * statement is then discarded as stale and the abort never reaches the database.
+     */
+    async waitForIdleTransaction(ctx) {
+        await ctx.getExecutor().provideConnection(async () => undefined);
+    }
     prepareQuery(query, params = []) {
         if (query instanceof NativeQueryBuilder) {
             query = query.toRaw();

package/AbstractSqlDriver.js

@@ -604,7 +604,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         let pk;
         if (meta.primaryKeys.length > 1) {
             // owner has composite pk
-            pk = Utils.getPrimaryKeyCond(data, meta.primaryKeys);
+            pk = Utils.getOrderedPrimaryKeys(data, meta);
         }
         else {
             /* v8 ignore next */
@@ -887,10 +887,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         const res = await this.execute(sql, params, 'run', options.ctx, withAbortContext(options.loggerContext, options));
         let pk;
-        /* v8 ignore next */
         if (pks.length > 1) {
             // owner has composite pk
-            pk = data.map(d => Utils.getPrimaryKeyCond(d, pks));
+            pk = data.map(d => Utils.getOrderedPrimaryKeys(d, meta));
         }
         else {
             res.row ??= {};
@@ -949,8 +948,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             res = await this.rethrow(qb.execute('run', false));
         }
-        /* v8 ignore next */
-        const pk = pks.map(pk => Utils.extractPK(data[pk] || where, meta));
+        const pk = Utils.getOrderedPrimaryKeys({ ...where, ...data }, meta);
         await this.processManyToMany(meta, pk, collections, true, options);
         return res;
     }
@@ -1072,7 +1070,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
             ? `(${pks.map(() => '?').join(', ')})`
             : `(${pks.map(pk => `${this.platform.quoteIdentifier(pk)} = ?`).join(' and ')})`;
         const conds = where.map(cond => {
-            if (Utils.isPlainObject(cond) && Utils.getObjectKeysSize(cond) === 1) {
+            // with multiple PK columns the condition is looked up by property name, so it needs to stay an object
+            if (pks.length === 1 && Utils.isPlainObject(cond) && Utils.getObjectKeysSize(cond) === 1) {
                 cond = Object.values(cond)[0];
             }
             if (pks.length > 1) {
@@ -1100,7 +1099,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             sql += conds.join(' or ');
         }
         if (this.platform.usesReturningStatement() && returning.size > 0) {
-            const returningFields = Utils.flatten([...returning].map(prop => meta.properties[prop].fieldNames));
+            const returningFields = Utils.flatten([...returning].map(prop => (meta.properties[prop] ?? meta.root.properties[prop]).fieldNames));
             /* v8 ignore next */
             sql +=
                 returningFields.length > 0
@@ -1112,7 +1111,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         const res = await this.rethrow(this.execute(sql, params, 'run', options.ctx, withAbortContext(options.loggerContext, options)));
         for (let i = 0; i < collections.length; i++) {
-            await this.processManyToMany(meta, where[i], collections[i], false, options);
+            const pk = Utils.getOrderedPrimaryKeys(where[i], meta);
+            await this.processManyToMany(meta, pk, collections[i], false, options);
         }
         return res;
     }
@@ -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,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)
@@ -1423,7 +1432,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 +1528,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 +1670,22 @@ 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
+        // (including virtual ones, as the owner FK of a polymorphic pivot is only mapped via non-persisted relations)
+        const pivotRelations = meta.pivotTable && !meta.compositePK ? meta.relations.filter(p => p.kind === ReferenceKind.MANY_TO_ONE) : [];
         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/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -168,7 +168,7 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
             const fields = this.options.groupBy.map(field => this.quote(field));
             this.parts.push(`group by ${fields.join(', ')}`);
         }
-        if (this.options.having) {
+        if (this.options.having?.sql.trim()) {
             this.parts.push(`having ${this.options.having.sql}`);
             this.params.push(...this.options.having.params);
         }

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

@@ -322,7 +322,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const ret = [];
         for (const event of trigger.events) {
             const name = trigger.events.length > 1 ? `${trigger.name}_${event}` : trigger.name;
-            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ROW begin ${trigger.body}; end`);
+            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ROW begin ${this.normalizeTriggerBody(trigger.body)} end`);
         }
         return ret.join(';\n');
     }
@@ -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/dialects/oracledb/OracleNativeQueryBuilder.js

@@ -234,7 +234,7 @@ export class OracleNativeQueryBuilder extends NativeQueryBuilder {
             const fields = this.options.groupBy.map(field => this.quote(field));
             this.parts.push(`group by ${fields.join(', ')}`);
         }
-        if (this.options.having) {
+        if (this.options.having?.sql.trim()) {
             this.parts.push(`having ${this.options.having.sql}`);
             this.params.push(...this.options.having.params);
         }

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -513,7 +513,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const when = trigger.when ? `\n  when (${trigger.when})` : '';
         const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
         const triggerName = this.platform.quoteIdentifier(trigger.name);
-        const fnSql = `create or replace function ${fnName}() returns trigger as $$ begin ${trigger.body}; end; $$ language plpgsql`;
+        const fnSql = `create or replace function ${fnName}() returns trigger as $$ begin ${this.normalizeTriggerBody(trigger.body)} end; $$ language plpgsql`;
         const triggerSql = `create trigger ${triggerName} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} execute function ${fnName}()`;
         return `${fnSql};\n${triggerSql}`;
     }

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -561,7 +561,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
         for (const event of trigger.events) {
             const name = trigger.events.length > 1 ? `${trigger.name}_${event}` : trigger.name;
             const when = trigger.when ? `\n  when ${trigger.when}` : '';
-            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ${forEach}${when} begin ${trigger.body}; end`);
+            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ${forEach}${when} begin ${this.normalizeTriggerBody(trigger.body)} end`);
         }
         return ret.join(';\n');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.9-dev.8",
+  "version": "7.1.9",
   "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",
@@ -50,10 +50,10 @@
     "kysely": "0.29.4"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.1.8"
+    "@mikro-orm/core": "^7.1.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.9-dev.8"
+    "@mikro-orm/core": "7.1.9"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/NativeQueryBuilder.js

@@ -308,7 +308,7 @@ export class NativeQueryBuilder {
             const fields = this.options.groupBy.map(field => this.quote(field));
             this.parts.push(`group by ${fields.join(', ')}`);
         }
-        if (this.options.having) {
+        if (this.options.having?.sql.trim()) {
             this.parts.push(`having ${this.options.having.sql}`);
             this.params.push(...this.options.having.params);
         }

package/query/QueryBuilderHelper.js

@@ -414,7 +414,8 @@ export class QueryBuilderHelper {
             }
             if (k === '$not') {
                 const res = this._appendQueryCondition(type, cond[k]);
-                parts.push(`not (${res.sql})`);
+                // negating a vacuously true condition (e.g. an empty `$and`) matches nothing
+                parts.push(res.sql ? `not (${res.sql})` : '1 = 0');
                 res.params.forEach(p => params.push(p));
                 continue;
             }

package/schema/SchemaComparator.js

@@ -897,9 +897,13 @@ export class SchemaComparator {
                 // lookbehind: only strip a real charset introducer, never an underscore inside a literal like 'a_b'
                 ?.replace(/(?<![\w'])_\w+'(.*?)'/g, '$1')
                 .replace(/!=/g, '<>')
-                .replace(/in\s*\((.*?)\)/gi, '= any (array[$1])')
+                // `\b` keeps this from firing inside identifiers like `min(...)`
+                .replace(/\bin\s*\((.*?)\)/gi, '= any (array[$1])')
                 // MySQL normalizes count(*) to count(0)
                 .replace(/\bcount\s*\(\s*0\s*\)/gi, 'count(*)')
+                // multi word type names in casts, the generic `::\w+` below only covers single word ones
+                // the precision is kept, so `timestamptz(3)` and `timestamp(3) with time zone` leave the same residue
+                .replace(/::\s*(?:character\s+varying|bit\s+varying|double\s+precision|(?:timestamp|time)\b(\s*\(\d+\))?(?:\s+with(?:out)?\s+time\s+zone)?)/gi, '$1')
                 // Remove quotes first so we can process identifiers
                 .replace(/['"`]/g, '')
                 // MySQL adds table/alias prefixes to columns (e.g., a.name or table_name.column vs just column)
@@ -907,12 +911,18 @@ export class SchemaComparator {
                 .replace(/\b\w+\.(\w+)/g, '$1')
                 // Normalize JOIN syntax: inner join -> join (equivalent in SQL)
                 .replace(/\binner\s+join\b/gi, 'join')
+                // PostgreSQL names an unaliased bare function call after the function itself,
+                // so `max(created_at)` comes back as `max(created_at) AS max`
+                // the lookahead skips table function column alias lists like `unnest(a) AS unnest(c)`, which are meaningful
+                .replace(/\b(\w+)\s*\(((?:[^()]|\([^()]*\))*)\)\s+as\s+\1\b(?!\s*\()/gi, '$1($2)')
                 // Remove redundant column aliases like `title AS title` -> `title`
                 .replace(/\b(\w+)\s+as\s+\1\b/gi, '$1')
                 // Remove AS keyword (optional in SQL, MySQL may add/remove it)
                 .replace(/\bas\b/gi, '')
                 // Remove remaining special chars, parentheses, type casts, asterisks, and normalize whitespace
-                .replace(/[()\n[\]*]|::\w+| +/g, '')
+                // tabs and CRs included — the schema generator trims every line before executing the DDL,
+                // so indentation and CRLF endings can never come back from introspection
+                .replace(/[()\n\r\t[\]*]|::\w+| +/g, '')
                 .replace(/anyarray\[(.*)]/gi, '$1')
                 .toLowerCase()
                 // PostgreSQL adds default aliases to aggregate functions (e.g., count(*) AS count)

package/schema/SchemaHelper.d.ts

@@ -4,7 +4,13 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef, SqlRoutineDef } from '../typings.js';
 import type { DatabaseSchema } from './DatabaseSchema.js';
 import type { DatabaseTable } from './DatabaseTable.js';
-/** Flattens `;\n` boundaries so the schema-generator's statement splitter doesn't break the routine DDL apart. Other whitespace is preserved. */
+/**
+ * Flattens `;\n` boundaries and drops blank lines so the schema-generator's statement splitter
+ * doesn't break the routine or trigger DDL apart — it treats both as statement/group separators.
+ * Blank lines go first, otherwise a `;` followed by one would keep its newline. Like
+ * `normalizeViewDefinition`, this is not string-literal aware, so a blank line inside a multi-line
+ * literal is dropped too. Other whitespace is preserved.
+ */
 export declare function stripStatementNewlines(body: string): string;
 /**
  * Strips SQL line comments and blank lines from a view definition. Comments are dropped by the
@@ -137,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;
@@ -176,6 +184,8 @@ export declare abstract class SchemaHelper {
     createRoutine(_routine: SqlRoutineDef): string;
     dropRoutine(_routine: SqlRoutineDef): string;
     getAllRoutines(_connection: AbstractSqlConnection, _schemas?: string[]): Promise<SqlRoutineDef[]>;
+    /** Flattens internal `;\n` so the statement splitter doesn't tear the DDL, and ensures exactly one trailing `;` for the enclosing `begin ... end` block. */
+    protected normalizeTriggerBody(body: string): string;
     /** Wraps the body in `BEGIN ... END` if not already, and flattens internal `;\n` so the schema-generator's statement splitter doesn't tear the DDL. */
     protected wrapRoutineBody(body: string): string;
     protected stripRoutineBody(body: string): string;

package/schema/SchemaHelper.js

@@ -1,7 +1,17 @@
 import { isRaw, Utils, } from '@mikro-orm/core';
-/** Flattens `;\n` boundaries so the schema-generator's statement splitter doesn't break the routine DDL apart. Other whitespace is preserved. */
+/**
+ * Flattens `;\n` boundaries and drops blank lines so the schema-generator's statement splitter
+ * doesn't break the routine or trigger DDL apart — it treats both as statement/group separators.
+ * Blank lines go first, otherwise a `;` followed by one would keep its newline. Like
+ * `normalizeViewDefinition`, this is not string-literal aware, so a blank line inside a multi-line
+ * literal is dropped too. Other whitespace is preserved.
+ */
 export function stripStatementNewlines(body) {
-    return body.replace(/;[\t ]*\r?\n/g, '; ');
+    return body
+        .split('\n')
+        .filter(line => line.trim() !== '')
+        .join('\n')
+        .replace(/;[\t ]*\r?\n/g, '; ');
 }
 /**
  * Strips SQL line comments and blank lines from a view definition. Comments are dropped by the
@@ -436,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));
@@ -489,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));
@@ -608,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 [];
     }
@@ -861,7 +882,7 @@ export class SchemaHelper {
         const events = trigger.events.map(e => e.toUpperCase()).join(' OR ');
         const forEach = trigger.forEach === 'statement' ? 'STATEMENT' : 'ROW';
         const when = trigger.when ? ` when (${trigger.when})` : '';
-        return `create trigger ${this.quote(trigger.name)} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} begin ${trigger.body}; end`;
+        return `create trigger ${this.quote(trigger.name)} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} begin ${this.normalizeTriggerBody(trigger.body)} end`;
     }
     /**
      * Generates SQL to drop a database trigger from a table.
@@ -885,6 +906,11 @@ export class SchemaHelper {
     async getAllRoutines(_connection, _schemas = []) {
         return [];
     }
+    /** Flattens internal `;\n` so the statement splitter doesn't tear the DDL, and ensures exactly one trailing `;` for the enclosing `begin ... end` block. */
+    normalizeTriggerBody(body) {
+        const trimmed = stripStatementNewlines(body).trim();
+        return /;\s*$/.test(trimmed) ? trimmed : `${trimmed};`;
+    }
     /** Wraps the body in `BEGIN ... END` if not already, and flattens internal `;\n` so the schema-generator's statement splitter doesn't tear the DDL. */
     wrapRoutineBody(body) {
         const trimmed = stripStatementNewlines(body).trim();

package/schema/SqlSchemaGenerator.d.ts

@@ -54,6 +54,10 @@ 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>;
     private wrapSchema;
     private append;

package/schema/SqlSchemaGenerator.js

@@ -439,18 +439,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 +468,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);