@prisma/query-plan-executor 7.5.0-dev.13 → 7.5.0-dev.14

package/dist/index.d.ts

@@ -668,6 +668,7 @@ json: {
 timeout?: number | undefined;
 maxWait?: number | undefined;
 isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SNAPSHOT" | "SERIALIZABLE" | undefined;
+newTxId?: string | undefined;
 };
 };
 output: {
@@ -3248,6 +3249,18 @@ declare interface Transaction extends AdapterInfo, SqlQueryable {
      * Roll back the transaction.
      */
     rollback(): Promise<void>;
+    /**
+     * Creates a savepoint within the currently running transaction.
+     */
+    createSavepoint?(name: string): Promise<void>;
+    /**
+     * Rolls back transaction state to a previously created savepoint.
+     */
+    rollbackToSavepoint?(name: string): Promise<void>;
+    /**
+     * Releases a previously created savepoint. Optional because not every connector supports this operation.
+     */
+    releaseSavepoint?(name: string): Promise<void>;
 }
 
 declare type TransactionInfo = {
@@ -3289,6 +3302,7 @@ declare type TransactionOptions_2 = {
     maxWait?: number;
     timeout?: number;
     isolationLevel?: IsolationLevel;
+    newTxId?: string;
 };
 
 declare type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = T extends string ? 'text' : T extends JSONValue ? 'json' : ResponseFormat> = {

package/dist/index.js

@@ -101325,7 +101325,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "7.5.0-dev.13";
+var version = "7.5.0-dev.14";
 
 // ../../node_modules/.pnpm/temporal-polyfill@0.3.0/node_modules/temporal-polyfill/chunks/internal.js
 function clampProp(e2, n2, t2, o2, r2) {
@@ -111492,13 +111492,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 (e2) {
+          existing.depth -= 1;
+          existing.savepoints.pop();
+          throw e2;
+        }
+        return { id: existing.id };
+      });
+    }
     const transaction = {
       id: await randomUUID2(),
       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);
@@ -111532,14 +111561,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) {
@@ -111583,22 +111647,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, name6) {
+    if (transaction.releaseSavepoint) {
+      await transaction.releaseSavepoint(name6);
+    }
+  }
+  #debugTransactionAlreadyClosedOnTimeout(transactionId) {
+    debug3("Transaction already committed or rolled back when timeout happened.", transactionId);
   }
   #startTransactionTimeout(transactionId, timeout) {
     const timeoutStartedAt = Date.now();
     const timer = createTimeoutIfDefined(async () => {
       debug3("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 {
-        debug3("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 () => {
       debug3("Closing transaction.", { transactionId: tx.id, status });
@@ -114137,6 +114269,15 @@ var MariaDbTransaction = class extends MariaDbQueryable {
     this.cleanup?.();
     await this.client.end();
   }
+  async createSavepoint(name22) {
+    await this.executeRaw({ sql: `SAVEPOINT ${name22}`, args: [], argTypes: [] });
+  }
+  async rollbackToSavepoint(name22) {
+    await this.executeRaw({ sql: `ROLLBACK TO ${name22}`, args: [], argTypes: [] });
+  }
+  async releaseSavepoint(name22) {
+    await this.executeRaw({ sql: `RELEASE SAVEPOINT ${name22}`, args: [], argTypes: [] });
+  }
 };
 var PrismaMariaDbAdapter = class extends MariaDbQueryable {
   constructor(client, capabilities, options) {
@@ -115165,6 +115306,12 @@ var MssqlTransaction = class extends MssqlQueryable {
       release2();
     }
   }
+  async createSavepoint(name22) {
+    await this.executeRaw({ sql: `SAVE TRANSACTION ${name22}`, args: [], argTypes: [] });
+  }
+  async rollbackToSavepoint(name22) {
+    await this.executeRaw({ sql: `ROLLBACK TRANSACTION ${name22}`, args: [], argTypes: [] });
+  }
 };
 var PrismaMssqlAdapter = class extends MssqlQueryable {
   constructor(pool2, options) {
@@ -115907,6 +116054,15 @@ var PgTransaction = class extends PgQueryable {
     this.cleanup?.();
     this.client.release();
   }
+  async createSavepoint(name22) {
+    await this.executeRaw({ sql: `SAVEPOINT ${name22}`, args: [], argTypes: [] });
+  }
+  async rollbackToSavepoint(name22) {
+    await this.executeRaw({ sql: `ROLLBACK TO SAVEPOINT ${name22}`, args: [], argTypes: [] });
+  }
+  async releaseSavepoint(name22) {
+    await this.executeRaw({ sql: `RELEASE SAVEPOINT ${name22}`, args: [], argTypes: [] });
+  }
 };
 var PrismaPgAdapter = class extends PgQueryable {
   constructor(client, pgOptions, release2) {
@@ -116103,13 +116259,15 @@ function createConnectionStringRegex(protocols) {
 }
 function wrapFactory(protocols, factory) {
   return {
-    ...factory,
+    adapterName: factory.adapterName,
+    provider: factory.provider,
     connect: () => factory.connect().then(wrapAdapter.bind(null, protocols), rethrowSanitizedError.bind(null, protocols))
   };
 }
 function wrapAdapter(protocols, adapter) {
   return {
-    ...adapter,
+    adapterName: adapter.adapterName,
+    provider: adapter.provider,
     dispose: () => adapter.dispose().catch(rethrowSanitizedError.bind(null, protocols)),
     executeRaw: (query2) => adapter.executeRaw(query2).catch(rethrowSanitizedError.bind(null, protocols)),
     queryRaw: (query2) => adapter.queryRaw(query2).catch(rethrowSanitizedError.bind(null, protocols)),
@@ -116120,11 +116278,16 @@ function wrapAdapter(protocols, adapter) {
 }
 function wrapTransaction(protocols, tx) {
   return {
-    ...tx,
+    adapterName: tx.adapterName,
+    provider: tx.provider,
+    options: tx.options,
     commit: () => tx.commit().catch(rethrowSanitizedError.bind(null, protocols)),
     rollback: () => tx.rollback().catch(rethrowSanitizedError.bind(null, protocols)),
     executeRaw: (query2) => tx.executeRaw(query2).catch(rethrowSanitizedError.bind(null, protocols)),
-    queryRaw: (query2) => tx.queryRaw(query2).catch(rethrowSanitizedError.bind(null, protocols))
+    queryRaw: (query2) => tx.queryRaw(query2).catch(rethrowSanitizedError.bind(null, protocols)),
+    createSavepoint: tx.createSavepoint ? (name6) => tx.createSavepoint(name6).catch(rethrowSanitizedError.bind(null, protocols)) : void 0,
+    rollbackToSavepoint: tx.rollbackToSavepoint ? (name6) => tx.rollbackToSavepoint(name6).catch(rethrowSanitizedError.bind(null, protocols)) : void 0,
+    releaseSavepoint: tx.releaseSavepoint ? (name6) => tx.releaseSavepoint(name6).catch(rethrowSanitizedError.bind(null, protocols)) : void 0
   };
 }
 
@@ -128429,7 +128592,8 @@ var QueryRequestBody = external_exports.object({
 var TransactionStartRequestBody = external_exports.object({
   timeout: external_exports.number().optional(),
   maxWait: external_exports.number().optional(),
-  isolationLevel: external_exports.enum(["READ UNCOMMITTED", "READ COMMITTED", "REPEATABLE READ", "SNAPSHOT", "SERIALIZABLE"]).optional()
+  isolationLevel: external_exports.enum(["READ UNCOMMITTED", "READ COMMITTED", "REPEATABLE READ", "SNAPSHOT", "SERIALIZABLE"]).optional(),
+  newTxId: external_exports.string().optional()
 });
 
 // src/server/server.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/query-plan-executor",
-  "version": "7.5.0-dev.13",
+  "version": "7.5.0-dev.14",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,11 +20,11 @@
     "temporal-polyfill": "0.3.0",
     "vitest": "3.2.4",
     "zod": "4.1.3",
-    "@prisma/adapter-pg": "7.5.0-dev.13",
-    "@prisma/adapter-mariadb": "7.5.0-dev.13",
-    "@prisma/client-engine-runtime": "7.5.0-dev.13",
-    "@prisma/adapter-mssql": "7.5.0-dev.13",
-    "@prisma/driver-adapter-utils": "7.5.0-dev.13"
+    "@prisma/adapter-pg": "7.5.0-dev.14",
+    "@prisma/adapter-mariadb": "7.5.0-dev.14",
+    "@prisma/adapter-mssql": "7.5.0-dev.14",
+    "@prisma/client-engine-runtime": "7.5.0-dev.14",
+    "@prisma/driver-adapter-utils": "7.5.0-dev.14"
   },
   "files": [
     "dist"