@mikro-orm/sql 7.1.9-dev.15 → 7.1.9-dev.17

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/package.json

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