@prisma/client-engine-runtime 7.5.0-dev.12 → 7.5.0-dev.14

package/dist/index.d.mts

@@ -497,6 +497,7 @@ export declare type TransactionOptions = {
     maxWait?: number;
     timeout?: number;
     isolationLevel?: IsolationLevel;
+    newTxId?: string;
 };
 
 export declare class UserFacingError extends Error {

package/dist/index.d.ts

@@ -497,6 +497,7 @@ export declare type TransactionOptions = {
     maxWait?: number;
     timeout?: number;
     isolationLevel?: IsolationLevel;
+    newTxId?: string;
 };
 
 export declare class UserFacingError extends Error {

package/dist/index.js

@@ -2087,13 +2087,42 @@ var TransactionManager = class {
     );
   }
   async #startTransactionImpl(options) {
+    if (options.newTxId) {
+      return await this.#withActiveTransactionLock(options.newTxId, "start", async (existing) => {
+        if (existing.status !== "running") {
+          throw new TransactionInternalConsistencyError(
+            `Transaction in invalid state ${existing.status} when starting a nested transaction.`
+          );
+        }
+        if (!existing.transaction) {
+          throw new TransactionInternalConsistencyError(
+            `Transaction missing underlying driver transaction when starting a nested transaction.`
+          );
+        }
+        existing.depth += 1;
+        const savepointName = this.#nextSavepointName(existing);
+        existing.savepoints.push(savepointName);
+        try {
+          await this.#requiredCreateSavepoint(existing.transaction)(savepointName);
+        } catch (e) {
+          existing.depth -= 1;
+          existing.savepoints.pop();
+          throw e;
+        }
+        return { id: existing.id };
+      });
+    }
     const transaction = {
       id: await randomUUID(),
       status: "waiting",
       timer: void 0,
       timeout: options.timeout,
       startedAt: Date.now(),
-      transaction: void 0
+      transaction: void 0,
+      operationQueue: Promise.resolve(),
+      depth: 1,
+      savepoints: [],
+      savepointCounter: 0
     };
     const abortController = new AbortController();
     const startTimer = createTimeoutIfDefined(() => abortController.abort(), options.maxWait);
@@ -2127,14 +2156,49 @@ var TransactionManager = class {
   }
   async commitTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("commit_transaction", async () => {
-      const txw = this.#getActiveOrClosingTransaction(transactionId, "commit");
-      await this.#closeTransaction(txw, "committed");
+      await this.#withActiveTransactionLock(transactionId, "commit", async (txw) => {
+        if (txw.depth > 1) {
+          if (!txw.transaction) throw new TransactionNotFoundError();
+          const savepointName = txw.savepoints.at(-1);
+          if (!savepointName) {
+            throw new TransactionInternalConsistencyError(
+              `Missing savepoint for nested commit. Depth: ${txw.depth}, transactionId: ${txw.id}`
+            );
+          }
+          try {
+            await this.#releaseSavepoint(txw.transaction, savepointName);
+          } finally {
+            txw.savepoints.pop();
+            txw.depth -= 1;
+          }
+          return;
+        }
+        await this.#closeTransaction(txw, "committed");
+      });
     });
   }
   async rollbackTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("rollback_transaction", async () => {
-      const txw = this.#getActiveOrClosingTransaction(transactionId, "rollback");
-      await this.#closeTransaction(txw, "rolled_back");
+      await this.#withActiveTransactionLock(transactionId, "rollback", async (txw) => {
+        if (txw.depth > 1) {
+          if (!txw.transaction) throw new TransactionNotFoundError();
+          const savepointName = txw.savepoints.at(-1);
+          if (!savepointName) {
+            throw new TransactionInternalConsistencyError(
+              `Missing savepoint for nested rollback. Depth: ${txw.depth}, transactionId: ${txw.id}`
+            );
+          }
+          try {
+            await this.#requiredRollbackToSavepoint(txw.transaction)(savepointName);
+            await this.#releaseSavepoint(txw.transaction, savepointName);
+          } finally {
+            txw.savepoints.pop();
+            txw.depth -= 1;
+          }
+          return;
+        }
+        await this.#closeTransaction(txw, "rolled_back");
+      });
     });
   }
   async getTransaction(txInfo, operation) {
@@ -2178,22 +2242,90 @@ var TransactionManager = class {
     return transaction;
   }
   async cancelAllTransactions() {
-    await Promise.allSettled([...this.transactions.values()].map((tx) => this.#closeTransaction(tx, "rolled_back")));
+    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");
+          }
+        })
+      )
+    );
+  }
+  #nextSavepointName(transaction) {
+    return `prisma_sp_${transaction.savepointCounter++}`;
+  }
+  #requiredCreateSavepoint(transaction) {
+    if (transaction.createSavepoint) {
+      return transaction.createSavepoint.bind(transaction);
+    }
+    throw new TransactionManagerError(
+      `Nested transactions are not supported by adapter "${transaction.adapterName}" (${transaction.provider}): createSavepoint is not implemented.`
+    );
+  }
+  #requiredRollbackToSavepoint(transaction) {
+    if (transaction.rollbackToSavepoint) {
+      return transaction.rollbackToSavepoint.bind(transaction);
+    }
+    throw new TransactionManagerError(
+      `Nested transactions are not supported by adapter "${transaction.adapterName}" (${transaction.provider}): rollbackToSavepoint is not implemented.`
+    );
+  }
+  async #releaseSavepoint(transaction, name) {
+    if (transaction.releaseSavepoint) {
+      await transaction.releaseSavepoint(name);
+    }
+  }
+  #debugTransactionAlreadyClosedOnTimeout(transactionId) {
+    debug("Transaction already committed or rolled back when timeout happened.", transactionId);
   }
   #startTransactionTimeout(transactionId, timeout) {
     const timeoutStartedAt = Date.now();
     const timer = createTimeoutIfDefined(async () => {
       debug("Transaction timed out.", { transactionId, timeoutStartedAt, timeout });
       const tx = this.transactions.get(transactionId);
-      if (tx && ["running", "waiting"].includes(tx.status)) {
-        await this.#closeTransaction(tx, "timed_out");
-      } else {
-        debug("Transaction already committed or rolled back when timeout happened.", transactionId);
-      }
+      if (!tx) {
+        this.#debugTransactionAlreadyClosedOnTimeout(transactionId);
+        return;
+      }
+      await this.#runSerialized(tx, async () => {
+        const current = this.transactions.get(transactionId);
+        if (current && ["running", "waiting"].includes(current.status)) {
+          await this.#closeTransaction(current, "timed_out");
+        } else {
+          this.#debugTransactionAlreadyClosedOnTimeout(transactionId);
+        }
+      });
     }, timeout);
     timer?.unref?.();
     return timer;
   }
+  // Any operation that mutates or closes a transaction must run through this lock so
+  // status/savepoint/depth checks and updates happen against a stable view of state.
+  async #withActiveTransactionLock(transactionId, operation, callback) {
+    const tx = this.#getActiveOrClosingTransaction(transactionId, operation);
+    return await this.#runSerialized(tx, async () => {
+      const current = this.#getActiveOrClosingTransaction(transactionId, operation);
+      return await callback(current);
+    });
+  }
+  // Serializes operations per transaction id to prevent interleaving across awaits.
+  // This avoids races where one operation mutates savepoint/depth state while another
+  // operation is suspended, which could otherwise corrupt cleanup logic.
+  async #runSerialized(tx, callback) {
+    const previousOperation = tx.operationQueue;
+    let releaseOperationLock;
+    tx.operationQueue = new Promise((resolve) => {
+      releaseOperationLock = resolve;
+    });
+    await previousOperation;
+    try {
+      return await callback();
+    } finally {
+      releaseOperationLock();
+    }
+  }
   async #closeTransaction(tx, status) {
     const createClosingPromise = async () => {
       debug("Closing transaction.", { transactionId: tx.id, status });

package/dist/index.mjs

@@ -2036,13 +2036,42 @@ var TransactionManager = class {
     );
   }
   async #startTransactionImpl(options) {
+    if (options.newTxId) {
+      return await this.#withActiveTransactionLock(options.newTxId, "start", async (existing) => {
+        if (existing.status !== "running") {
+          throw new TransactionInternalConsistencyError(
+            `Transaction in invalid state ${existing.status} when starting a nested transaction.`
+          );
+        }
+        if (!existing.transaction) {
+          throw new TransactionInternalConsistencyError(
+            `Transaction missing underlying driver transaction when starting a nested transaction.`
+          );
+        }
+        existing.depth += 1;
+        const savepointName = this.#nextSavepointName(existing);
+        existing.savepoints.push(savepointName);
+        try {
+          await this.#requiredCreateSavepoint(existing.transaction)(savepointName);
+        } catch (e) {
+          existing.depth -= 1;
+          existing.savepoints.pop();
+          throw e;
+        }
+        return { id: existing.id };
+      });
+    }
     const transaction = {
       id: await randomUUID(),
       status: "waiting",
       timer: void 0,
       timeout: options.timeout,
       startedAt: Date.now(),
-      transaction: void 0
+      transaction: void 0,
+      operationQueue: Promise.resolve(),
+      depth: 1,
+      savepoints: [],
+      savepointCounter: 0
     };
     const abortController = new AbortController();
     const startTimer = createTimeoutIfDefined(() => abortController.abort(), options.maxWait);
@@ -2076,14 +2105,49 @@ var TransactionManager = class {
   }
   async commitTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("commit_transaction", async () => {
-      const txw = this.#getActiveOrClosingTransaction(transactionId, "commit");
-      await this.#closeTransaction(txw, "committed");
+      await this.#withActiveTransactionLock(transactionId, "commit", async (txw) => {
+        if (txw.depth > 1) {
+          if (!txw.transaction) throw new TransactionNotFoundError();
+          const savepointName = txw.savepoints.at(-1);
+          if (!savepointName) {
+            throw new TransactionInternalConsistencyError(
+              `Missing savepoint for nested commit. Depth: ${txw.depth}, transactionId: ${txw.id}`
+            );
+          }
+          try {
+            await this.#releaseSavepoint(txw.transaction, savepointName);
+          } finally {
+            txw.savepoints.pop();
+            txw.depth -= 1;
+          }
+          return;
+        }
+        await this.#closeTransaction(txw, "committed");
+      });
     });
   }
   async rollbackTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("rollback_transaction", async () => {
-      const txw = this.#getActiveOrClosingTransaction(transactionId, "rollback");
-      await this.#closeTransaction(txw, "rolled_back");
+      await this.#withActiveTransactionLock(transactionId, "rollback", async (txw) => {
+        if (txw.depth > 1) {
+          if (!txw.transaction) throw new TransactionNotFoundError();
+          const savepointName = txw.savepoints.at(-1);
+          if (!savepointName) {
+            throw new TransactionInternalConsistencyError(
+              `Missing savepoint for nested rollback. Depth: ${txw.depth}, transactionId: ${txw.id}`
+            );
+          }
+          try {
+            await this.#requiredRollbackToSavepoint(txw.transaction)(savepointName);
+            await this.#releaseSavepoint(txw.transaction, savepointName);
+          } finally {
+            txw.savepoints.pop();
+            txw.depth -= 1;
+          }
+          return;
+        }
+        await this.#closeTransaction(txw, "rolled_back");
+      });
     });
   }
   async getTransaction(txInfo, operation) {
@@ -2127,22 +2191,90 @@ var TransactionManager = class {
     return transaction;
   }
   async cancelAllTransactions() {
-    await Promise.allSettled([...this.transactions.values()].map((tx) => this.#closeTransaction(tx, "rolled_back")));
+    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");
+          }
+        })
+      )
+    );
+  }
+  #nextSavepointName(transaction) {
+    return `prisma_sp_${transaction.savepointCounter++}`;
+  }
+  #requiredCreateSavepoint(transaction) {
+    if (transaction.createSavepoint) {
+      return transaction.createSavepoint.bind(transaction);
+    }
+    throw new TransactionManagerError(
+      `Nested transactions are not supported by adapter "${transaction.adapterName}" (${transaction.provider}): createSavepoint is not implemented.`
+    );
+  }
+  #requiredRollbackToSavepoint(transaction) {
+    if (transaction.rollbackToSavepoint) {
+      return transaction.rollbackToSavepoint.bind(transaction);
+    }
+    throw new TransactionManagerError(
+      `Nested transactions are not supported by adapter "${transaction.adapterName}" (${transaction.provider}): rollbackToSavepoint is not implemented.`
+    );
+  }
+  async #releaseSavepoint(transaction, name) {
+    if (transaction.releaseSavepoint) {
+      await transaction.releaseSavepoint(name);
+    }
+  }
+  #debugTransactionAlreadyClosedOnTimeout(transactionId) {
+    debug("Transaction already committed or rolled back when timeout happened.", transactionId);
   }
   #startTransactionTimeout(transactionId, timeout) {
     const timeoutStartedAt = Date.now();
     const timer = createTimeoutIfDefined(async () => {
       debug("Transaction timed out.", { transactionId, timeoutStartedAt, timeout });
       const tx = this.transactions.get(transactionId);
-      if (tx && ["running", "waiting"].includes(tx.status)) {
-        await this.#closeTransaction(tx, "timed_out");
-      } else {
-        debug("Transaction already committed or rolled back when timeout happened.", transactionId);
-      }
+      if (!tx) {
+        this.#debugTransactionAlreadyClosedOnTimeout(transactionId);
+        return;
+      }
+      await this.#runSerialized(tx, async () => {
+        const current = this.transactions.get(transactionId);
+        if (current && ["running", "waiting"].includes(current.status)) {
+          await this.#closeTransaction(current, "timed_out");
+        } else {
+          this.#debugTransactionAlreadyClosedOnTimeout(transactionId);
+        }
+      });
     }, timeout);
     timer?.unref?.();
     return timer;
   }
+  // Any operation that mutates or closes a transaction must run through this lock so
+  // status/savepoint/depth checks and updates happen against a stable view of state.
+  async #withActiveTransactionLock(transactionId, operation, callback) {
+    const tx = this.#getActiveOrClosingTransaction(transactionId, operation);
+    return await this.#runSerialized(tx, async () => {
+      const current = this.#getActiveOrClosingTransaction(transactionId, operation);
+      return await callback(current);
+    });
+  }
+  // Serializes operations per transaction id to prevent interleaving across awaits.
+  // This avoids races where one operation mutates savepoint/depth state while another
+  // operation is suspended, which could otherwise corrupt cleanup logic.
+  async #runSerialized(tx, callback) {
+    const previousOperation = tx.operationQueue;
+    let releaseOperationLock;
+    tx.operationQueue = new Promise((resolve) => {
+      releaseOperationLock = resolve;
+    });
+    await previousOperation;
+    try {
+      return await callback();
+    } finally {
+      releaseOperationLock();
+    }
+  }
   async #closeTransaction(tx, status) {
     const createClosingPromise = async () => {
       debug("Closing transaction.", { transactionId: tx.id, status });

package/dist/transaction-manager/transaction.d.ts

@@ -3,6 +3,7 @@ export type Options = {
     maxWait?: number;
     timeout?: number;
     isolationLevel?: IsolationLevel;
+    newTxId?: string;
 };
 export type TransactionInfo = {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "7.5.0-dev.12",
+  "version": "7.5.0-dev.14",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -31,10 +31,10 @@
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "11.1.0",
-    "@prisma/debug": "7.5.0-dev.12",
-    "@prisma/client-runtime-utils": "7.5.0-dev.12",
-    "@prisma/sqlcommenter": "7.5.0-dev.12",
-    "@prisma/driver-adapter-utils": "7.5.0-dev.12"
+    "@prisma/client-runtime-utils": "7.5.0-dev.14",
+    "@prisma/debug": "7.5.0-dev.14",
+    "@prisma/sqlcommenter": "7.5.0-dev.14",
+    "@prisma/driver-adapter-utils": "7.5.0-dev.14"
   },
   "devDependencies": {
     "@codspeed/benchmark.js-plugin": "4.0.0",