@prisma/client-engine-runtime 7.10.0-dev.8 → 7.10.0-dev.9

package/dist/index.js

@@ -2553,6 +2553,14 @@ var InvalidTransactionIsolationLevelError = class extends TransactionManagerErro
 
 // src/transaction-manager/transaction-manager.ts
 var MAX_CLOSED_TRANSACTIONS = 100;
+var CANCEL_ROLLBACK_GRACE_MS = 2e3;
+function trackStartingTransaction() {
+  let markSettled;
+  const settled = new Promise((resolve) => {
+    markSettled = resolve;
+  });
+  return { abortController: new AbortController(), settled, markSettled };
+}
 var debug = (0, import_debug.Debug)("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
 var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
@@ -2572,6 +2580,9 @@ var TransactionManager = class {
   // List of last closed transactions. Max MAX_CLOSED_TRANSACTIONS entries.
   // Used to provide better error messages than a generic "transaction not found".
   closedTransactions = [];
+  // Transactions that are still being started. Tracked separately so that
+  // `cancelAllTransactions` can reach them: they are not in `transactions` yet.
+  #startingTransactions = /* @__PURE__ */ new Set();
   driverAdapter;
   transactionOptions;
   tracingHelper;
@@ -2635,56 +2646,91 @@ var TransactionManager = class {
         return { id: existing.id };
       });
     }
-    const transaction = {
-      id: await randomUUID(),
-      status: "waiting",
-      timer: void 0,
-      timeout: options.timeout,
-      startedAt: Date.now(),
-      transaction: void 0,
-      operationQueue: Promise.resolve(),
-      depth: 1,
-      savepoints: [],
-      savepointCounter: 0
-    };
-    const abortController = new AbortController();
-    const startTimer = createTimeoutIfDefined(() => abortController.abort(), options.maxWait);
-    startTimer?.unref?.();
-    const startTransactionPromise = this.driverAdapter.startTransaction(options.isolationLevel).catch(rethrowAsUserFacing);
-    transaction.transaction = await Promise.race([
-      startTransactionPromise.finally(() => clearTimeout(startTimer)),
-      once(abortController.signal, "abort").then(() => void 0)
-    ]);
-    this.transactions.set(transaction.id, transaction);
-    switch (transaction.status) {
-      case "waiting":
-        if (abortController.signal.aborted) {
-          void startTransactionPromise.then(async (tx) => {
-            if (tx.options.usePhantomQuery) {
-              await tx.rollback();
-            } else {
-              try {
-                await tx.executeRaw(ROLLBACK_QUERY());
-              } finally {
-                await tx.rollback();
-              }
-            }
-          }).catch((e) => debug("error in discarded transaction:", e));
-          await this.#closeTransaction(transaction, "timed_out");
-          throw new TransactionStartTimeoutError();
+    const starting = trackStartingTransaction();
+    const { abortController } = starting;
+    this.#startingTransactions.add(starting);
+    let discarding;
+    try {
+      const transaction = {
+        id: await randomUUID(),
+        status: "waiting",
+        timer: void 0,
+        timeout: options.timeout,
+        startedAt: Date.now(),
+        transaction: void 0,
+        operationQueue: Promise.resolve(),
+        depth: 1,
+        savepoints: [],
+        savepointCounter: 0
+      };
+      if (abortController.signal.aborted) {
+        throw new TransactionStartTimeoutError();
+      }
+      const startTimer = createTimeoutIfDefined(() => abortController.abort(), options.maxWait);
+      startTimer?.unref?.();
+      const startTransactionPromise = this.driverAdapter.startTransaction(options.isolationLevel).catch(rethrowAsUserFacing);
+      transaction.transaction = await Promise.race([
+        startTransactionPromise.finally(() => clearTimeout(startTimer)),
+        once(abortController.signal, "abort").then(() => void 0)
+      ]);
+      this.transactions.set(transaction.id, transaction);
+      switch (transaction.status) {
+        case "waiting":
+          if (abortController.signal.aborted) {
+            transaction.transaction = void 0;
+            discarding = this.#discardStartedTransaction(startTransactionPromise);
+            await this.#closeTransaction(transaction, "timed_out");
+            throw new TransactionStartTimeoutError();
+          }
+          transaction.status = "running";
+          transaction.startedAt = Date.now();
+          transaction.timer = this.#startTransactionTimeout(transaction.id, options.timeout);
+          return { id: transaction.id };
+        case "timed_out":
+        case "running":
+        case "committed":
+        case "rolled_back":
+          throw new TransactionInternalConsistencyError(
+            `Transaction in invalid state ${transaction.status} although it just finished startup.`
+          );
+        default:
+          return assertNever(transaction["status"], "Unknown transaction status.");
+      }
+    } finally {
+      this.#startingTransactions.delete(starting);
+      if (discarding) {
+        void discarding.finally(starting.markSettled);
+      } else {
+        starting.markSettled();
+      }
+    }
+  }
+  /**
+   * Rolls back a transaction whose start was abandoned, and releases its connection.
+   *
+   * The `startTransaction` promise may still be running in the background. If it eventually
+   * succeeds, we need to roll back and release the connection to avoid leaking it and
+   * exhausting the connection pool. For adapters that don't use phantom queries (e.g. pg/neon),
+   * `rollback()` only releases the connection without sending SQL, so we send an explicit
+   * ROLLBACK first; otherwise the connection returns to the pool mid-transaction because
+   * `BEGIN` already ran on the wire during startup.
+   *
+   * Errors are only logged: the caller has already reported the failure that led here.
+   */
+  async #discardStartedTransaction(startTransactionPromise) {
+    try {
+      const tx = await startTransactionPromise;
+      if (tx.options.usePhantomQuery) {
+        await tx.rollback();
+      } else {
+        try {
+          await tx.executeRaw(ROLLBACK_QUERY());
+        } finally {
+          await tx.rollback();
         }
-        transaction.status = "running";
-        transaction.timer = this.#startTransactionTimeout(transaction.id, options.timeout);
-        return { id: transaction.id };
-      case "timed_out":
-      case "running":
-      case "committed":
-      case "rolled_back":
-        throw new TransactionInternalConsistencyError(
-          `Transaction in invalid state ${transaction.status} although it just finished startup.`
-        );
-      default:
-        assertNever(transaction["status"], "Unknown transaction status.");
+      }
+    } catch (e) {
+      debug("error in discarded transaction:", e);
     }
   }
   async commitTransaction(transactionId) {
@@ -2775,16 +2821,21 @@ var TransactionManager = class {
     return transaction;
   }
   async cancelAllTransactions() {
-    await Promise.allSettled(
-      [...this.transactions.values()].map(
+    const starting = [...this.#startingTransactions];
+    for (const { abortController } of starting) {
+      abortController.abort();
+    }
+    await Promise.allSettled([
+      ...[...this.transactions.values()].map(
         (tx) => this.#runSerialized(tx, async () => {
           const current = this.transactions.get(tx.id);
           if (current) {
             await this.#closeTransaction(current, "rolled_back");
           }
         })
-      )
-    );
+      ),
+      ...starting.map(({ settled }) => settleWithin(settled, CANCEL_ROLLBACK_GRACE_MS))
+    ]);
   }
   #nextSavepointName(transaction) {
     return `prisma_sp_${transaction.savepointCounter++}`;
@@ -2937,6 +2988,14 @@ var TransactionManager = class {
 function createTimeoutIfDefined(cb, ms) {
   return ms !== void 0 ? setTimeout(cb, ms) : void 0;
 }
+function settleWithin(promise, timeout) {
+  let timer;
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(resolve, timeout);
+    timer?.unref?.();
+  });
+  return Promise.race([promise, deadline]).finally(() => clearTimeout(timer));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DataMapperError,

package/dist/index.mjs

@@ -2500,6 +2500,14 @@ var InvalidTransactionIsolationLevelError = class extends TransactionManagerErro
 
 // src/transaction-manager/transaction-manager.ts
 var MAX_CLOSED_TRANSACTIONS = 100;
+var CANCEL_ROLLBACK_GRACE_MS = 2e3;
+function trackStartingTransaction() {
+  let markSettled;
+  const settled = new Promise((resolve) => {
+    markSettled = resolve;
+  });
+  return { abortController: new AbortController(), settled, markSettled };
+}
 var debug = Debug("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
 var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
@@ -2519,6 +2527,9 @@ var TransactionManager = class {
   // List of last closed transactions. Max MAX_CLOSED_TRANSACTIONS entries.
   // Used to provide better error messages than a generic "transaction not found".
   closedTransactions = [];
+  // Transactions that are still being started. Tracked separately so that
+  // `cancelAllTransactions` can reach them: they are not in `transactions` yet.
+  #startingTransactions = /* @__PURE__ */ new Set();
   driverAdapter;
   transactionOptions;
   tracingHelper;
@@ -2582,56 +2593,91 @@ var TransactionManager = class {
         return { id: existing.id };
       });
     }
-    const transaction = {
-      id: await randomUUID(),
-      status: "waiting",
-      timer: void 0,
-      timeout: options.timeout,
-      startedAt: Date.now(),
-      transaction: void 0,
-      operationQueue: Promise.resolve(),
-      depth: 1,
-      savepoints: [],
-      savepointCounter: 0
-    };
-    const abortController = new AbortController();
-    const startTimer = createTimeoutIfDefined(() => abortController.abort(), options.maxWait);
-    startTimer?.unref?.();
-    const startTransactionPromise = this.driverAdapter.startTransaction(options.isolationLevel).catch(rethrowAsUserFacing);
-    transaction.transaction = await Promise.race([
-      startTransactionPromise.finally(() => clearTimeout(startTimer)),
-      once(abortController.signal, "abort").then(() => void 0)
-    ]);
-    this.transactions.set(transaction.id, transaction);
-    switch (transaction.status) {
-      case "waiting":
-        if (abortController.signal.aborted) {
-          void startTransactionPromise.then(async (tx) => {
-            if (tx.options.usePhantomQuery) {
-              await tx.rollback();
-            } else {
-              try {
-                await tx.executeRaw(ROLLBACK_QUERY());
-              } finally {
-                await tx.rollback();
-              }
-            }
-          }).catch((e) => debug("error in discarded transaction:", e));
-          await this.#closeTransaction(transaction, "timed_out");
-          throw new TransactionStartTimeoutError();
+    const starting = trackStartingTransaction();
+    const { abortController } = starting;
+    this.#startingTransactions.add(starting);
+    let discarding;
+    try {
+      const transaction = {
+        id: await randomUUID(),
+        status: "waiting",
+        timer: void 0,
+        timeout: options.timeout,
+        startedAt: Date.now(),
+        transaction: void 0,
+        operationQueue: Promise.resolve(),
+        depth: 1,
+        savepoints: [],
+        savepointCounter: 0
+      };
+      if (abortController.signal.aborted) {
+        throw new TransactionStartTimeoutError();
+      }
+      const startTimer = createTimeoutIfDefined(() => abortController.abort(), options.maxWait);
+      startTimer?.unref?.();
+      const startTransactionPromise = this.driverAdapter.startTransaction(options.isolationLevel).catch(rethrowAsUserFacing);
+      transaction.transaction = await Promise.race([
+        startTransactionPromise.finally(() => clearTimeout(startTimer)),
+        once(abortController.signal, "abort").then(() => void 0)
+      ]);
+      this.transactions.set(transaction.id, transaction);
+      switch (transaction.status) {
+        case "waiting":
+          if (abortController.signal.aborted) {
+            transaction.transaction = void 0;
+            discarding = this.#discardStartedTransaction(startTransactionPromise);
+            await this.#closeTransaction(transaction, "timed_out");
+            throw new TransactionStartTimeoutError();
+          }
+          transaction.status = "running";
+          transaction.startedAt = Date.now();
+          transaction.timer = this.#startTransactionTimeout(transaction.id, options.timeout);
+          return { id: transaction.id };
+        case "timed_out":
+        case "running":
+        case "committed":
+        case "rolled_back":
+          throw new TransactionInternalConsistencyError(
+            `Transaction in invalid state ${transaction.status} although it just finished startup.`
+          );
+        default:
+          return assertNever(transaction["status"], "Unknown transaction status.");
+      }
+    } finally {
+      this.#startingTransactions.delete(starting);
+      if (discarding) {
+        void discarding.finally(starting.markSettled);
+      } else {
+        starting.markSettled();
+      }
+    }
+  }
+  /**
+   * Rolls back a transaction whose start was abandoned, and releases its connection.
+   *
+   * The `startTransaction` promise may still be running in the background. If it eventually
+   * succeeds, we need to roll back and release the connection to avoid leaking it and
+   * exhausting the connection pool. For adapters that don't use phantom queries (e.g. pg/neon),
+   * `rollback()` only releases the connection without sending SQL, so we send an explicit
+   * ROLLBACK first; otherwise the connection returns to the pool mid-transaction because
+   * `BEGIN` already ran on the wire during startup.
+   *
+   * Errors are only logged: the caller has already reported the failure that led here.
+   */
+  async #discardStartedTransaction(startTransactionPromise) {
+    try {
+      const tx = await startTransactionPromise;
+      if (tx.options.usePhantomQuery) {
+        await tx.rollback();
+      } else {
+        try {
+          await tx.executeRaw(ROLLBACK_QUERY());
+        } finally {
+          await tx.rollback();
         }
-        transaction.status = "running";
-        transaction.timer = this.#startTransactionTimeout(transaction.id, options.timeout);
-        return { id: transaction.id };
-      case "timed_out":
-      case "running":
-      case "committed":
-      case "rolled_back":
-        throw new TransactionInternalConsistencyError(
-          `Transaction in invalid state ${transaction.status} although it just finished startup.`
-        );
-      default:
-        assertNever(transaction["status"], "Unknown transaction status.");
+      }
+    } catch (e) {
+      debug("error in discarded transaction:", e);
     }
   }
   async commitTransaction(transactionId) {
@@ -2722,16 +2768,21 @@ var TransactionManager = class {
     return transaction;
   }
   async cancelAllTransactions() {
-    await Promise.allSettled(
-      [...this.transactions.values()].map(
+    const starting = [...this.#startingTransactions];
+    for (const { abortController } of starting) {
+      abortController.abort();
+    }
+    await Promise.allSettled([
+      ...[...this.transactions.values()].map(
         (tx) => this.#runSerialized(tx, async () => {
           const current = this.transactions.get(tx.id);
           if (current) {
             await this.#closeTransaction(current, "rolled_back");
           }
         })
-      )
-    );
+      ),
+      ...starting.map(({ settled }) => settleWithin(settled, CANCEL_ROLLBACK_GRACE_MS))
+    ]);
   }
   #nextSavepointName(transaction) {
     return `prisma_sp_${transaction.savepointCounter++}`;
@@ -2884,6 +2935,14 @@ var TransactionManager = class {
 function createTimeoutIfDefined(cb, ms) {
   return ms !== void 0 ? setTimeout(cb, ms) : void 0;
 }
+function settleWithin(promise, timeout) {
+  let timer;
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(resolve, timeout);
+    timer?.unref?.();
+  });
+  return Promise.race([promise, deadline]).finally(() => clearTimeout(timer));
+}
 export {
   DataMapperError,
   QueryInterpreter,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "7.10.0-dev.8",
+  "version": "7.10.0-dev.9",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -31,20 +31,20 @@
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "14.0.0",
-    "@prisma/client-runtime-utils": "7.10.0-dev.8",
-    "@prisma/debug": "7.10.0-dev.8",
-    "@prisma/driver-adapter-utils": "7.10.0-dev.8",
-    "@prisma/sqlcommenter": "7.10.0-dev.8",
-    "@prisma/param-graph": "7.10.0-dev.8",
-    "@prisma/json-protocol": "7.10.0-dev.8"
+    "@prisma/driver-adapter-utils": "7.10.0-dev.9",
+    "@prisma/sqlcommenter": "7.10.0-dev.9",
+    "@prisma/param-graph": "7.10.0-dev.9",
+    "@prisma/client-runtime-utils": "7.10.0-dev.9",
+    "@prisma/debug": "7.10.0-dev.9",
+    "@prisma/json-protocol": "7.10.0-dev.9"
   },
   "devDependencies": {
     "@codspeed/benchmark.js-plugin": "4.0.0",
     "@types/benchmark": "2.1.5",
     "@types/node": "~20.19.24",
     "benchmark": "2.1.4",
-    "@prisma/get-dmmf": "7.10.0-dev.8",
-    "@prisma/param-graph-builder": "7.10.0-dev.8"
+    "@prisma/get-dmmf": "7.10.0-dev.9",
+    "@prisma/param-graph-builder": "7.10.0-dev.9"
   },
   "files": [
     "dist"