@prisma/query-plan-executor 7.10.0-dev.37 → 7.10.0-dev.39

package/dist/index.js

@@ -92936,7 +92936,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "7.10.0-dev.37";
+var version = "7.10.0-dev.39";
 
 // ../../node_modules/.pnpm/temporal-polyfill@0.3.0/node_modules/temporal-polyfill/chunks/internal.js
 function clampProp(e2, n2, t2, o2, r2) {
@@ -104290,6 +104290,7 @@ function getErrorCode2(error44) {
       assertNever(error44, `Unknown error identifier: ${error44}`);
   }
 }
+var debug3 = Debug("prisma:client:queryInterpreter");
 var QueryInterpreter = class _QueryInterpreter {
   #onQuery;
   #generators = new GeneratorRegistry();
@@ -104380,42 +104381,46 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "execute": {
         const queries = renderQuery(node.args, context4.scope, context4.generators, this.#maxChunkSize());
-        let sum2 = 0;
-        for (const query2 of queries) {
-          const commentedQuery = applyComments(query2, context4.sqlCommenter);
-          sum2 += await this.#withQuerySpanAndEvent(
-            commentedQuery,
-            context4.queryable,
-            () => context4.queryable.executeRaw(cloneObject(commentedQuery)).catch(
-              (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
-            )
-          );
-        }
-        return { value: sum2 };
+        return this.#withChunkTransaction(queries.length, context4, async (context22) => {
+          let sum2 = 0;
+          for (const query2 of queries) {
+            const commentedQuery = applyComments(query2, context22.sqlCommenter);
+            sum2 += await this.#withQuerySpanAndEvent(
+              commentedQuery,
+              context22.queryable,
+              () => context22.queryable.executeRaw(cloneObject(commentedQuery)).catch(
+                (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
+              )
+            );
+          }
+          return { value: sum2 };
+        });
       }
       case "query": {
         const queries = renderQuery(node.args, context4.scope, context4.generators, this.#maxChunkSize());
-        let results;
-        for (const query2 of queries) {
-          const commentedQuery = applyComments(query2, context4.sqlCommenter);
-          const result = await this.#withQuerySpanAndEvent(
-            commentedQuery,
-            context4.queryable,
-            () => context4.queryable.queryRaw(cloneObject(commentedQuery)).catch(
-              (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
-            )
-          );
-          if (results === void 0) {
-            results = result;
-          } else {
-            appendToArray(results.rows, result.rows);
-            results.lastInsertId = result.lastInsertId;
+        return this.#withChunkTransaction(queries.length, context4, async (context22) => {
+          let results;
+          for (const query2 of queries) {
+            const commentedQuery = applyComments(query2, context22.sqlCommenter);
+            const result = await this.#withQuerySpanAndEvent(
+              commentedQuery,
+              context22.queryable,
+              () => context22.queryable.queryRaw(cloneObject(commentedQuery)).catch(
+                (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
+              )
+            );
+            if (results === void 0) {
+              results = result;
+            } else {
+              appendToArray(results.rows, result.rows);
+              results.lastInsertId = result.lastInsertId;
+            }
           }
-        }
-        return {
-          value: node.args.type === "rawSql" ? this.#rawSerializer(results) : this.#serializer(results),
-          lastInsertId: results?.lastInsertId
-        };
+          return {
+            value: node.args.type === "rawSql" ? this.#rawSerializer(results) : this.#serializer(results),
+            lastInsertId: results?.lastInsertId
+          };
+        });
       }
       case "reverse": {
         const { value, lastInsertId } = await this.interpretNode(node.args, context4);
@@ -104456,20 +104461,7 @@ var QueryInterpreter = class _QueryInterpreter {
         return { value: attachChildrenToParents(parent, children, node.args.canAssumeStrictEquality), lastInsertId };
       }
       case "transaction": {
-        if (!context4.transactionManager.enabled) {
-          return this.interpretNode(node.args, context4);
-        }
-        const transactionManager = context4.transactionManager.manager;
-        const transactionInfo = await transactionManager.startInternalTransaction();
-        const transaction = await transactionManager.getTransaction(transactionInfo, "query");
-        try {
-          const value = await this.interpretNode(node.args, { ...context4, queryable: transaction });
-          await transactionManager.commitTransaction(transactionInfo.id);
-          return value;
-        } catch (e2) {
-          await transactionManager.rollbackTransaction(transactionInfo.id);
-          throw e2;
-        }
+        return this.#withInternalTransaction(context4, (context22) => this.interpretNode(node.args, context22));
       }
       case "dataMap": {
         const { value, lastInsertId } = await this.interpretNode(node.args.expr, context4);
@@ -104654,6 +104646,48 @@ var QueryInterpreter = class _QueryInterpreter {
         assertNever(node, `Unexpected node type: ${node.type}`);
     }
   }
+  /**
+   * Runs the statements of a `query` or `execute` node via `fn`, wrapping them in a
+   * transaction when a chunkable statement was split into multiple queries at render time,
+   * so that a partially applied write cannot be observed or left behind if a later chunk
+   * fails. A single statement is atomic on its own, so it runs on the current context.
+   */
+  #withChunkTransaction(statementCount, context4, fn2) {
+    if (statementCount <= 1) {
+      return fn2(context4);
+    }
+    return this.#withInternalTransaction(context4, fn2);
+  }
+  /**
+   * Runs `fn` with a context whose queryable is guaranteed to be a transaction, starting a
+   * new internal transaction and committing or rolling it back around the call.
+   *
+   * A disabled transaction manager means the queryable already is a transaction: executors
+   * pass `{ enabled: false }` when the plan runs inside an interactive transaction, and the
+   * context handed to `fn` carries it for the duration of an internal transaction. In that
+   * case `fn` runs on the current context, since the statements it issues are already
+   * covered by the surrounding transaction.
+   */
+  async #withInternalTransaction(context4, fn2) {
+    if (!context4.transactionManager.enabled) {
+      return fn2(context4);
+    }
+    const transactionManager = context4.transactionManager.manager;
+    const transactionInfo = await transactionManager.startInternalTransaction();
+    const transaction = await transactionManager.getTransaction(transactionInfo, "query");
+    try {
+      const result = await fn2({ ...context4, queryable: transaction, transactionManager: { enabled: false } });
+      await transactionManager.commitTransaction(transactionInfo.id);
+      return result;
+    } catch (e2) {
+      try {
+        await transactionManager.rollbackTransaction(transactionInfo.id);
+      } catch (rollbackError) {
+        debug3("failed to roll back an internal transaction", rollbackError);
+      }
+      throw e2;
+    }
+  }
   #maxChunkSize() {
     if (this.#connectionInfo?.maxBindValues !== void 0) {
       return this.#connectionInfo.maxBindValues;
@@ -105032,7 +105066,7 @@ function trackStartingTransaction() {
   });
   return { abortController: new AbortController(), settled, markSettled };
 }
-var debug3 = Debug("prisma:client:transactionManager");
+var debug22 = Debug("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
 var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
 var PHANTOM_COMMIT_QUERY = () => ({
@@ -105201,7 +105235,7 @@ var TransactionManager = class {
         }
       }
     } catch (e2) {
-      debug3("error in discarded transaction:", e2);
+      debug22("error in discarded transaction:", e2);
     }
   }
   async commitTransaction(transactionId) {
@@ -105265,7 +105299,7 @@ var TransactionManager = class {
     if (!transaction) {
       const closedTransaction = this.closedTransactions.find((tx) => tx.id === transactionId);
       if (closedTransaction) {
-        debug3("Transaction already closed.", { transactionId, status: closedTransaction.status });
+        debug22("Transaction already closed.", { transactionId, status: closedTransaction.status });
         switch (closedTransaction.status) {
           case "closing":
           case "waiting":
@@ -105282,7 +105316,7 @@ var TransactionManager = class {
             });
         }
       } else {
-        debug3(`Transaction not found.`, transactionId);
+        debug22(`Transaction not found.`, transactionId);
         throw new TransactionNotFoundError();
       }
     }
@@ -105333,13 +105367,13 @@ var TransactionManager = class {
     }
   }
   #debugTransactionAlreadyClosedOnTimeout(transactionId) {
-    debug3("Transaction already committed or rolled back when timeout happened.", transactionId);
+    debug22("Transaction already committed or rolled back when timeout happened.", transactionId);
   }
   #startTransactionTimeout(transactionId, timeout) {
     const timeoutStartedAt = Date.now();
     const timer = createTimeoutIfDefined(async () => {
       try {
-        debug3("Transaction timed out.", { transactionId, timeoutStartedAt, timeout });
+        debug22("Transaction timed out.", { transactionId, timeoutStartedAt, timeout });
         const tx = this.transactions.get(transactionId);
         if (!tx) {
           this.#debugTransactionAlreadyClosedOnTimeout(transactionId);
@@ -105354,7 +105388,7 @@ var TransactionManager = class {
           }
         });
       } catch (error44) {
-        debug3("Error while closing timed-out transaction.", { transactionId, error: error44 });
+        debug22("Error while closing timed-out transaction.", { transactionId, error: error44 });
       }
     }, timeout);
     timer?.unref?.();
@@ -105387,7 +105421,7 @@ var TransactionManager = class {
   }
   async #closeTransaction(tx, status) {
     const createClosingPromise = async () => {
-      debug3("Closing transaction.", { transactionId: tx.id, status });
+      debug22("Closing transaction.", { transactionId: tx.id, status });
       try {
         if (tx.transaction && status === "committed") {
           if (tx.transaction.options.usePhantomQuery) {
@@ -108997,7 +109031,7 @@ function mapDriverError2(error44) {
 function isDriverError2(error44) {
   return typeof error44.message === "string" && typeof error44.code === "string" && typeof error44.number === "number";
 }
-var debug22 = Debug("prisma:driver-adapter:mssql");
+var debug23 = Debug("prisma:driver-adapter:mssql");
 var MssqlQueryable = class {
   constructor(conn) {
     this.conn = conn;
@@ -109006,7 +109040,7 @@ var MssqlQueryable = class {
   adapterName = name4;
   async queryRaw(query2) {
     const tag2 = "[js::query_raw]";
-    debug22(`${tag2} %O`, query2);
+    debug23(`${tag2} %O`, query2);
     const { recordset, columns: columnsList } = await this.performIO(query2);
     const columns = columnsList?.[0];
     return {
@@ -109017,7 +109051,7 @@ var MssqlQueryable = class {
   }
   async executeRaw(query2) {
     const tag2 = "[js::execute_raw]";
-    debug22(`${tag2} %O`, query2);
+    debug23(`${tag2} %O`, query2);
     return (await this.performIO(query2)).rowsAffected?.[0] ?? 0;
   }
   async performIO(query2) {
@@ -109039,7 +109073,7 @@ var MssqlQueryable = class {
     }
   }
   onError(error44) {
-    debug22("Error in performIO: %O", error44);
+    debug23("Error in performIO: %O", error44);
     throw new DriverAdapterError(convertDriverError2(error44));
   }
 };
@@ -109061,7 +109095,7 @@ var MssqlTransaction = class extends MssqlQueryable {
     }
   }
   async commit() {
-    debug22(`[js::commit]`);
+    debug23(`[js::commit]`);
     const release = await this.#mutex.acquire();
     try {
       await this.transaction.commit();
@@ -109070,12 +109104,12 @@ var MssqlTransaction = class extends MssqlQueryable {
     }
   }
   async rollback() {
-    debug22(`[js::rollback]`);
+    debug23(`[js::rollback]`);
     const release = await this.#mutex.acquire();
     try {
       await this.transaction.rollback().catch((e2) => {
         if (e2.code === "EABORT") {
-          debug22(`[js::rollback] Transaction already aborted`);
+          debug23(`[js::rollback] Transaction already aborted`);
           return;
         }
         throw e2;
@@ -109105,10 +109139,10 @@ var PrismaMssqlAdapter = class extends MssqlQueryable {
       usePhantomQuery: true
     };
     const tag2 = "[js::startTransaction]";
-    debug22("%s options: %O", tag2, options);
+    debug23("%s options: %O", tag2, options);
     const tx = this.pool.transaction();
     tx.on("error", (err) => {
-      debug22("Error from pool connection: %O", err);
+      debug23("Error from pool connection: %O", err);
       this.options?.onConnectionError?.(err);
     });
     try {
@@ -109153,7 +109187,7 @@ var PrismaMssqlAdapterFactory = class {
   async connect() {
     const pool2 = new import_mssql.default.ConnectionPool(this.#config);
     pool2.on("error", (err) => {
-      debug22("Error from pool client: %O", err);
+      debug23("Error from pool client: %O", err);
       this.#options?.onPoolError?.(err);
     });
     await pool2.connect();

package/package.json

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