@mikro-orm/sql 7.1.9-dev.2 → 7.1.9-dev.20

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;
     }

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.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');
     }

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/BaseSqliteConnection.d.ts

@@ -7,4 +7,7 @@ export declare class BaseSqliteConnection extends AbstractSqlConnection {
         skipOnConnect?: boolean;
     }): Promise<void>;
     protected attachDatabases(): Promise<void>;
+    /** Per-connection state, lost whenever the underlying connection is recreated, so it has to be replayed. */
+    protected getConnectionSetupSql(): Promise<string[]>;
+    private getAttachDatabasesSql;
 }

package/dialects/sqlite/BaseSqliteConnection.js

@@ -1,5 +1,6 @@
 import { CompiledQuery } from 'kysely';
 import { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
+const FOREIGN_KEYS_PRAGMA = 'pragma foreign_keys = on';
 export class BaseSqliteConnection extends AbstractSqlConnection {
     createKyselyDialect(options) {
         throw new Error('No SQLite dialect configured. Pass a Kysely dialect via the `driverOptions` config option, ' +
@@ -7,19 +8,28 @@ export class BaseSqliteConnection extends AbstractSqlConnection {
     }
     async connect(options) {
         await super.connect(options);
-        await this.getClient().executeQuery(CompiledQuery.raw('pragma foreign_keys = on'));
+        await this.getClient().executeQuery(CompiledQuery.raw(FOREIGN_KEYS_PRAGMA));
         await this.attachDatabases();
     }
     async attachDatabases() {
+        for (const sql of await this.getAttachDatabasesSql()) {
+            await this.execute(sql);
+        }
+    }
+    /** Per-connection state, lost whenever the underlying connection is recreated, so it has to be replayed. */
+    async getConnectionSetupSql() {
+        return [FOREIGN_KEYS_PRAGMA, ...(await this.getAttachDatabasesSql())];
+    }
+    async getAttachDatabasesSql() {
         const attachDatabases = this.config.get('attachDatabases');
         if (!attachDatabases?.length) {
-            return;
+            return [];
         }
         const { fs } = await import('@mikro-orm/core/fs-utils');
         const baseDir = this.config.get('baseDir');
-        for (const db of attachDatabases) {
+        return attachDatabases.map(db => {
             const path = fs.absolutePath(db.path, baseDir);
-            await this.execute(`attach database '${path}' as ${this.platform.quoteIdentifier(db.name)}`);
-        }
+            return `attach database '${path}' as ${this.platform.quoteIdentifier(db.name)}`;
+        });
     }
 }

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.2",
+  "version": "7.1.9-dev.20",
   "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.2"
+    "@mikro-orm/core": "7.1.9-dev.20"
   },
   "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;
             }
@@ -785,6 +786,10 @@ export class QueryBuilderHelper {
     appendGroupCondition(type, operator, subCondition) {
         const parts = [];
         const params = [];
+        // an empty disjunction is false, same as `$in: []`, while an empty conjunction is vacuously true
+        if (operator === '$or' && subCondition.length === 0) {
+            return { sql: '1 = 0', params };
+        }
         // single sub-condition can be ignored to reduce nesting of parens
         if (subCondition.length === 1 || operator === '$and') {
             for (const sub of subCondition) {

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
@@ -176,6 +182,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
@@ -861,7 +871,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 +895,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,8 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         wrap?: boolean;
         ctx?: Transaction;
     }): Promise<void>;
+    /** 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

@@ -443,14 +443,19 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         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;
@@ -471,6 +476,10 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         });
         await Utils.runSerial(statements, stmt => this.driver.execute(stmt));
     }
+    /** 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);