@prisma/client-engine-runtime 7.10.0-dev.4 → 7.10.0-dev.41

package/dist/index.js

@@ -56,6 +56,12 @@ var import_client_runtime_utils2 = require("@prisma/client-runtime-utils");
 
 // src/utils.ts
 var import_client_runtime_utils = require("@prisma/client-runtime-utils");
+function isUint8Array(value) {
+  return ArrayBuffer.isView(value) && Object.prototype.toString.call(value) === "[object Uint8Array]";
+}
+function isDate(value) {
+  return Object.prototype.toString.call(value) === "[object Date]";
+}
 function assertNever(_, message) {
   throw new Error(message);
 }
@@ -74,11 +80,11 @@ function doKeysMatch(lhs, rhs) {
       const lhsDecimal = asDecimal(lhs[key]);
       const rhsDecimal = asDecimal(rhs[key]);
       return lhsDecimal && rhsDecimal && lhsDecimal.equals(rhsDecimal);
-    } else if (lhs[key] instanceof Uint8Array || rhs[key] instanceof Uint8Array) {
+    } else if (isUint8Array(lhs[key]) || isUint8Array(rhs[key])) {
       const lhsBuffer = asBuffer(lhs[key]);
       const rhsBuffer = asBuffer(rhs[key]);
       return lhsBuffer && rhsBuffer && lhsBuffer.equals(rhsBuffer);
-    } else if (lhs[key] instanceof Date || rhs[key] instanceof Date) {
+    } else if (isDate(lhs[key]) || isDate(rhs[key])) {
       return asDate(lhs[key])?.getTime() === asDate(rhs[key])?.getTime();
     } else if (typeof lhs[key] === "bigint" || typeof rhs[key] === "bigint") {
       return asBigInt(lhs[key]) === asBigInt(rhs[key]);
@@ -100,7 +106,7 @@ function asDecimal(value) {
 function asBuffer(value) {
   if (Buffer.isBuffer(value)) {
     return value;
-  } else if (value instanceof Uint8Array) {
+  } else if (isUint8Array(value)) {
     return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
   } else if (typeof value === "string") {
     return Buffer.from(value, "base64");
@@ -109,7 +115,7 @@ function asBuffer(value) {
   }
 }
 function asDate(value) {
-  if (value instanceof Date) {
+  if (isDate(value)) {
     return value;
   } else if (typeof value === "string" || typeof value === "number") {
     return new Date(value);
@@ -145,6 +151,16 @@ function safeJsonStringify(obj) {
     return val;
   });
 }
+var MAX_PUSH_SPREAD_ARGS = 8192;
+function appendToArray(target, source) {
+  if (source.length <= MAX_PUSH_SPREAD_ARGS) {
+    target.push(...source);
+    return;
+  }
+  for (let i = 0; i < source.length; i += MAX_PUSH_SPREAD_ARGS) {
+    target.push(...source.slice(i, i + MAX_PUSH_SPREAD_ARGS));
+  }
+}
 
 // src/json-protocol.ts
 function normalizeJsonProtocolValues(result) {
@@ -226,10 +242,8 @@ function deserializeTaggedValue({ $type, value }) {
   switch ($type) {
     case "BigInt":
       return BigInt(value);
-    case "Bytes": {
-      const { buffer, byteOffset, byteLength } = Buffer.from(value, "base64");
-      return new Uint8Array(buffer, byteOffset, byteLength);
-    }
+    case "Bytes":
+      return new Uint8Array(Buffer.from(value, "base64"));
     case "DateTime":
       return new Date(value);
     case "Decimal":
@@ -343,6 +357,7 @@ function getErrorCode(err) {
     case "UniqueConstraintViolation":
       return "P2002";
     case "ForeignKeyConstraintViolation":
+    case "RestrictViolation":
       return "P2003";
     case "InvalidInputValue":
       return "P2007";
@@ -415,6 +430,7 @@ function renderErrorMessage(err) {
     case "UniqueConstraintViolation":
       return `Unique constraint failed on the ${renderConstraint(err.cause.constraint)}`;
     case "ForeignKeyConstraintViolation":
+    case "RestrictViolation":
       return `Foreign key constraint violated on the ${renderConstraint(err.cause.constraint)}`;
     case "UnsupportedNativeDataType":
       return `Failed to deserialize column of type '${err.cause.type}'. If you're using $queryRaw and this column is explicitly marked as \`Unsupported\` in your Prisma schema, try casting this column to any supported Prisma type such as \`String\`.`;
@@ -691,7 +707,7 @@ function mapValue(value, columnName, scalarType, enums) {
           throw new DataMapperError(`Expected a boolean in column '${columnName}', got ${typeof value}: ${value}`);
         }
       }
-      if (Array.isArray(value) || value instanceof Uint8Array) {
+      if (Array.isArray(value) || isUint8Array(value)) {
         for (const byte of value) {
           if (byte !== 0) return true;
         }
@@ -708,7 +724,7 @@ function mapValue(value, columnName, scalarType, enums) {
       if (typeof value === "string") {
         return { $type: "DateTime", value: normalizeDateTime(value) };
       }
-      if (typeof value === "number" || value instanceof Date) {
+      if (typeof value === "number" || isDate(value)) {
         return { $type: "DateTime", value };
       }
       throw new DataMapperError(`Expected a date in column '${columnName}', got ${typeof value}: ${value}`);
@@ -739,7 +755,7 @@ function mapValue(value, columnName, scalarType, enums) {
           if (Array.isArray(value)) {
             return { $type: "Bytes", value: Buffer.from(value).toString("base64") };
           }
-          if (value instanceof Uint8Array) {
+          if (isUint8Array(value)) {
             return { $type: "Bytes", value: Buffer.from(value).toString("base64") };
           }
           throw new DataMapperError(`Expected a byte array in column '${columnName}', got ${typeof value}: ${value}`);
@@ -787,6 +803,7 @@ function normalizeDateTime(dt) {
 }
 
 // src/interpreter/query-interpreter.ts
+var import_debug = require("@prisma/debug");
 var import_klona2 = require("klona");
 
 // src/sql-commenter.ts
@@ -1148,8 +1165,9 @@ function renderTemplateSql(fragments, placeholderFormat, params, argTypes) {
     if (fragment.type === "stringChunk") {
       continue;
     }
-    const length = flattenedParams.length;
-    const added = flattenedParams.push(...flattenedFragmentParams(fragment)) - length;
+    const fragmentParams = Array.from(flattenedFragmentParams(fragment));
+    const added = fragmentParams.length;
+    appendToArray(flattenedParams, fragmentParams);
     if (fragment.argType.arity === "tuple") {
       if (added % fragment.argType.elements.length !== 0) {
         throw new Error(
@@ -1578,6 +1596,7 @@ function getErrorCode2(error) {
 }
 
 // src/interpreter/query-interpreter.ts
+var debug = (0, import_debug.Debug)("prisma:client:queryInterpreter");
 var QueryInterpreter = class _QueryInterpreter {
   #onQuery;
   #generators = new GeneratorRegistry();
@@ -1612,17 +1631,27 @@ var QueryInterpreter = class _QueryInterpreter {
     });
   }
   async run(queryPlan, options) {
-    const { value } = await this.interpretNode(queryPlan, {
-      ...options,
-      generators: this.#generators.snapshot()
-    }).catch((e) => rethrowAsUserFacing(e));
+    const generators = this.#generators.snapshot();
+    const context = { ...options, generators };
+    const purified = purifyQueryPlan(queryPlan, (node) => this.interpretNode(node, context))?.catch(
+      (e) => rethrowAsUserFacing(e)
+    );
+    if (purified) {
+      try {
+        return this.#interpretPureNode(await purified, context.scope, generators).value;
+      } catch (e) {
+        rethrowAsUserFacing(e);
+      }
+    }
+    const { value } = await this.interpretNode(queryPlan, context).catch((e) => rethrowAsUserFacing(e));
     return value;
   }
   async interpretNode(node, context) {
     switch (node.type) {
       case "value": {
         return {
-          value: evaluateArg(node.args, context.scope, context.generators)
+          value: evaluateArg(node.args, context.scope, context.generators),
+          lastInsertId: node.lastInsertId
         };
       }
       case "seq": {
@@ -1632,9 +1661,6 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return result ?? { value: void 0 };
       }
-      case "get": {
-        return { value: context.scope[node.args.name] };
-      }
       case "let": {
         const nestedScope = Object.create(context.scope);
         for (const binding of node.args.bindings) {
@@ -1643,15 +1669,6 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return this.interpretNode(node.args.expr, { ...context, scope: nestedScope });
       }
-      case "getFirstNonEmpty": {
-        for (const name of node.args.names) {
-          const value = context.scope[name];
-          if (!isEmpty(value)) {
-            return { value };
-          }
-        }
-        return { value: [] };
-      }
       case "concat": {
         const parts = await Promise.all(
           node.args.map((arg) => this.interpretNode(arg, context).then((res) => res.value))
@@ -1670,42 +1687,46 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "execute": {
         const queries = renderQuery(node.args, context.scope, context.generators, this.#maxChunkSize());
-        let sum = 0;
-        for (const query of queries) {
-          const commentedQuery = applyComments(query, context.sqlCommenter);
-          sum += await this.#withQuerySpanAndEvent(
-            commentedQuery,
-            context.queryable,
-            () => context.queryable.executeRaw(cloneObject(commentedQuery)).catch(
-              (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
-            )
-          );
-        }
-        return { value: sum };
+        return this.#withChunkTransaction(queries.length, context, async (context2) => {
+          let sum = 0;
+          for (const query of queries) {
+            const commentedQuery = applyComments(query, context2.sqlCommenter);
+            sum += await this.#withQuerySpanAndEvent(
+              commentedQuery,
+              context2.queryable,
+              () => context2.queryable.executeRaw(cloneObject(commentedQuery)).catch(
+                (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
+              )
+            );
+          }
+          return { value: sum };
+        });
       }
       case "query": {
         const queries = renderQuery(node.args, context.scope, context.generators, this.#maxChunkSize());
-        let results;
-        for (const query of queries) {
-          const commentedQuery = applyComments(query, context.sqlCommenter);
-          const result = await this.#withQuerySpanAndEvent(
-            commentedQuery,
-            context.queryable,
-            () => context.queryable.queryRaw(cloneObject(commentedQuery)).catch(
-              (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
-            )
-          );
-          if (results === void 0) {
-            results = result;
-          } else {
-            results.rows.push(...result.rows);
-            results.lastInsertId = result.lastInsertId;
+        return this.#withChunkTransaction(queries.length, context, async (context2) => {
+          let results;
+          for (const query of queries) {
+            const commentedQuery = applyComments(query, context2.sqlCommenter);
+            const result = await this.#withQuerySpanAndEvent(
+              commentedQuery,
+              context2.queryable,
+              () => context2.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, context);
@@ -1746,20 +1767,7 @@ var QueryInterpreter = class _QueryInterpreter {
         return { value: attachChildrenToParents(parent, children, node.args.canAssumeStrictEquality), lastInsertId };
       }
       case "transaction": {
-        if (!context.transactionManager.enabled) {
-          return this.interpretNode(node.args, context);
-        }
-        const transactionManager = context.transactionManager.manager;
-        const transactionInfo = await transactionManager.startInternalTransaction();
-        const transaction = await transactionManager.getTransaction(transactionInfo, "query");
-        try {
-          const value = await this.interpretNode(node.args, { ...context, queryable: transaction });
-          await transactionManager.commitTransaction(transactionInfo.id);
-          return value;
-        } catch (e) {
-          await transactionManager.rollbackTransaction(transactionInfo.id);
-          throw e;
-        }
+        return this.#withInternalTransaction(context, (context2) => this.interpretNode(node.args, context2));
       }
       case "dataMap": {
         const { value, lastInsertId } = await this.interpretNode(node.args.expr, context);
@@ -1778,9 +1786,6 @@ var QueryInterpreter = class _QueryInterpreter {
           return await this.interpretNode(node.args.else, context);
         }
       }
-      case "unit": {
-        return { value: void 0 };
-      }
       case "diff": {
         const { value: from } = await this.interpretNode(node.args.from, context);
         const { value: to } = await this.interpretNode(node.args.to, context);
@@ -1810,10 +1815,185 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return { value: record, lastInsertId };
       }
+      default:
+        return this.#interpretPureNode(node, context.scope, context.generators);
+    }
+  }
+  #interpretPureNode(node, scope, generators) {
+    switch (node.type) {
+      case "value": {
+        return { value: evaluateArg(node.args, scope, generators), lastInsertId: node.lastInsertId };
+      }
+      case "seq": {
+        let result;
+        for (const arg of node.args) {
+          result = this.#interpretPureNode(arg, scope, generators);
+        }
+        return result ?? { value: void 0 };
+      }
+      case "get": {
+        return { value: scope[node.args.name] };
+      }
+      case "let": {
+        const nestedScope = Object.create(scope);
+        for (const binding of node.args.bindings) {
+          const { value } = this.#interpretPureNode(binding.expr, nestedScope, generators);
+          nestedScope[binding.name] = value;
+        }
+        return this.#interpretPureNode(node.args.expr, nestedScope, generators);
+      }
+      case "getFirstNonEmpty": {
+        for (const name of node.args.names) {
+          const value = scope[name];
+          if (!isEmpty(value)) {
+            return { value };
+          }
+        }
+        return { value: [] };
+      }
+      case "concat": {
+        const parts = node.args.map((arg) => this.#interpretPureNode(arg, scope, generators).value);
+        return {
+          value: parts.length > 0 ? parts.reduce((acc, part) => acc.concat(asList(part)), []) : []
+        };
+      }
+      case "sum": {
+        const parts = node.args.map((arg) => this.#interpretPureNode(arg, scope, generators).value);
+        return {
+          value: parts.length > 0 ? parts.reduce((acc, part) => asNumber2(acc) + asNumber2(part)) : 0
+        };
+      }
+      case "reverse": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        return { value: Array.isArray(value) ? value.reverse() : value, lastInsertId };
+      }
+      case "unique": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        if (!Array.isArray(value)) {
+          return { value, lastInsertId };
+        }
+        if (value.length > 1) {
+          throw new Error(`Expected zero or one element, got ${value.length}`);
+        }
+        return { value: value[0] ?? null, lastInsertId };
+      }
+      case "required": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        if (isEmpty(value)) {
+          throw new Error("Required value is empty");
+        }
+        return { value, lastInsertId };
+      }
+      case "mapField": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.records, scope, generators);
+        return { value: mapField2(value, node.args.field), lastInsertId };
+      }
+      case "join": {
+        const { value: parent, lastInsertId } = this.#interpretPureNode(node.args.parent, scope, generators);
+        if (parent === null) {
+          return { value: null, lastInsertId };
+        }
+        const children = node.args.children.map((joinExpr) => ({
+          joinExpr,
+          childRecords: this.#interpretPureNode(joinExpr.child, scope, generators).value
+        }));
+        return { value: attachChildrenToParents(parent, children, node.args.canAssumeStrictEquality), lastInsertId };
+      }
+      case "dataMap": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        return { value: applyDataMap(value, node.args.structure, node.args.enums), lastInsertId };
+      }
+      case "validate": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        performValidation(value, node.args.rules, node.args);
+        return { value, lastInsertId };
+      }
+      case "if": {
+        const { value } = this.#interpretPureNode(node.args.value, scope, generators);
+        if (doesSatisfyRule(value, node.args.rule)) {
+          return this.#interpretPureNode(node.args.then, scope, generators);
+        } else {
+          return this.#interpretPureNode(node.args.else, scope, generators);
+        }
+      }
+      case "unit": {
+        return { value: void 0 };
+      }
+      case "diff": {
+        const { value: from } = this.#interpretPureNode(node.args.from, scope, generators);
+        const { value: to } = this.#interpretPureNode(node.args.to, scope, generators);
+        const keyGetter = (item) => item !== null ? getRecordKey(asRecord(item), node.args.fields) : null;
+        const toSet = new Set(asList(to).map(keyGetter));
+        return { value: asList(from).filter((item) => !toSet.has(keyGetter(item))) };
+      }
+      case "process": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const ops = cloneObject(node.args.operations);
+        evaluateProcessingParameters(ops, scope, generators);
+        return { value: processRecords(value, ops), lastInsertId };
+      }
+      case "initializeRecord": {
+        const { lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const record = {};
+        for (const [key, initializer] of Object.entries(node.args.fields)) {
+          record[key] = evalFieldInitializer(initializer, lastInsertId, scope, generators);
+        }
+        return { value: record, lastInsertId };
+      }
+      case "mapRecord": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const record = value === null ? {} : asRecord(value);
+        for (const [key, entry] of Object.entries(node.args.fields)) {
+          record[key] = evalFieldOperation(entry, record[key], scope, generators);
+        }
+        return { value: record, lastInsertId };
+      }
       default:
         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, context, fn) {
+    if (statementCount <= 1) {
+      return fn(context);
+    }
+    return this.#withInternalTransaction(context, fn);
+  }
+  /**
+   * 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(context, fn) {
+    if (!context.transactionManager.enabled) {
+      return fn(context);
+    }
+    const transactionManager = context.transactionManager.manager;
+    const transactionInfo = await transactionManager.startInternalTransaction();
+    const transaction = await transactionManager.getTransaction(transactionInfo, "query");
+    try {
+      const result = await fn({ ...context, queryable: transaction, transactionManager: { enabled: false } });
+      await transactionManager.commitTransaction(transactionInfo.id);
+      return result;
+    } catch (e) {
+      try {
+        await transactionManager.rollbackTransaction(transactionInfo.id);
+      } catch (rollbackError) {
+        debug("failed to roll back an internal transaction", rollbackError);
+      }
+      throw e;
+    }
+  }
   #maxChunkSize() {
     if (this.#connectionInfo?.maxBindValues !== void 0) {
       return this.#connectionInfo.maxBindValues;
@@ -1987,6 +2167,112 @@ function evalFieldOperation(op, value, scope, generators) {
       assertNever(op, `Unexpected field operation type: ${op["type"]}`);
   }
 }
+function purifyQueryPlan(node, evalNode) {
+  const impureNode = findUniqueUnconditionalImpureNode(node);
+  if (!impureNode) {
+    return void 0;
+  }
+  return evalNode(impureNode).then((result) => {
+    const evaluated = {
+      type: "value",
+      args: result.value,
+      lastInsertId: result.lastInsertId
+    };
+    const purified = replaceImpureNode(node, impureNode, evaluated);
+    if (!purified) {
+      throw new Error("Could not substitute the evaluated impure node into the query plan");
+    }
+    return purified;
+  });
+}
+function replaceImpureNode(node, target, replacement) {
+  if (node === target) {
+    return replacement;
+  }
+  switch (node.type) {
+    case "seq":
+    case "sum":
+    case "concat": {
+      for (let i = 0; i < node.args.length; i++) {
+        const child = replaceImpureNode(node.args[i], target, replacement);
+        if (child) {
+          return { ...node, args: node.args.map((arg, j) => j === i ? child : arg) };
+        }
+      }
+      return void 0;
+    }
+    case "dataMap":
+    case "validate":
+    case "initializeRecord":
+    case "mapRecord":
+    case "process": {
+      const expr = replaceImpureNode(node.args.expr, target, replacement);
+      return expr && { ...node, args: { ...node.args, expr } };
+    }
+    case "mapField": {
+      const records = replaceImpureNode(node.args.records, target, replacement);
+      return records && { ...node, args: { ...node.args, records } };
+    }
+    case "reverse":
+    case "unique":
+    case "required": {
+      const args = replaceImpureNode(node.args, target, replacement);
+      return args && { ...node, args };
+    }
+    default:
+      return void 0;
+  }
+}
+function findUniqueUnconditionalImpureNode(node) {
+  switch (node.type) {
+    case "query":
+    case "execute":
+      return node;
+    case "seq":
+    case "sum":
+    case "concat": {
+      let found = void 0;
+      for (const child of node.args) {
+        const childFound = findUniqueUnconditionalImpureNode(child);
+        if (childFound === null) {
+          return null;
+        }
+        if (childFound) {
+          if (found) {
+            return null;
+          }
+          found = childFound;
+        }
+      }
+      return found;
+    }
+    case "dataMap":
+    case "validate":
+    case "initializeRecord":
+    case "mapRecord":
+    case "process":
+      return findUniqueUnconditionalImpureNode(node.args.expr);
+    case "mapField":
+      return findUniqueUnconditionalImpureNode(node.args.records);
+    case "reverse":
+    case "unique":
+    case "required":
+      return findUniqueUnconditionalImpureNode(node.args);
+    case "let":
+    case "join":
+    case "diff":
+    case "if":
+    case "transaction":
+      return null;
+    case "value":
+    case "get":
+    case "getFirstNonEmpty":
+    case "unit":
+      return void 0;
+    default:
+      assertNever(node, `Unexpected node type: ${node.type}`);
+  }
+}
 function applyComments(query, sqlCommenter) {
   if (!sqlCommenter || sqlCommenter.plugins.length === 0) {
     return query;
@@ -2485,7 +2771,7 @@ function normalizeValue(type, value) {
 }
 
 // src/transaction-manager/transaction-manager.ts
-var import_debug = require("@prisma/debug");
+var import_debug2 = require("@prisma/debug");
 
 // src/crypto.ts
 async function getCrypto() {
@@ -2553,7 +2839,15 @@ var InvalidTransactionIsolationLevelError = class extends TransactionManagerErro
 
 // src/transaction-manager/transaction-manager.ts
 var MAX_CLOSED_TRANSACTIONS = 100;
-var debug = (0, import_debug.Debug)("prisma:client:transactionManager");
+var CANCEL_ROLLBACK_GRACE_MS = 2e3;
+function trackStartingTransaction() {
+  let markSettled;
+  const settled = new Promise((resolve) => {
+    markSettled = resolve;
+  });
+  return { abortController: new AbortController(), settled, markSettled };
+}
+var debug2 = (0, import_debug2.Debug)("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
 var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
 var PHANTOM_COMMIT_QUERY = () => ({
@@ -2572,6 +2866,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 +2932,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) {
+      debug2("error in discarded transaction:", e);
     }
   }
   async commitTransaction(transactionId) {
@@ -2748,7 +3080,7 @@ var TransactionManager = class {
     if (!transaction) {
       const closedTransaction = this.closedTransactions.find((tx) => tx.id === transactionId);
       if (closedTransaction) {
-        debug("Transaction already closed.", { transactionId, status: closedTransaction.status });
+        debug2("Transaction already closed.", { transactionId, status: closedTransaction.status });
         switch (closedTransaction.status) {
           case "closing":
           case "waiting":
@@ -2765,7 +3097,7 @@ var TransactionManager = class {
             });
         }
       } else {
-        debug(`Transaction not found.`, transactionId);
+        debug2(`Transaction not found.`, transactionId);
         throw new TransactionNotFoundError();
       }
     }
@@ -2775,16 +3107,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++}`;
@@ -2811,25 +3148,29 @@ var TransactionManager = class {
     }
   }
   #debugTransactionAlreadyClosedOnTimeout(transactionId) {
-    debug("Transaction already committed or rolled back when timeout happened.", transactionId);
+    debug2("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) {
-        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 {
+      try {
+        debug2("Transaction timed out.", { transactionId, timeoutStartedAt, timeout });
+        const tx = this.transactions.get(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);
+          }
+        });
+      } catch (error) {
+        debug2("Error while closing timed-out transaction.", { transactionId, error });
+      }
     }, timeout);
     timer?.unref?.();
     return timer;
@@ -2861,7 +3202,7 @@ var TransactionManager = class {
   }
   async #closeTransaction(tx, status) {
     const createClosingPromise = async () => {
-      debug("Closing transaction.", { transactionId: tx.id, status });
+      debug2("Closing transaction.", { transactionId: tx.id, status });
       try {
         if (tx.transaction && status === "committed") {
           if (tx.transaction.options.usePhantomQuery) {
@@ -2937,6 +3278,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,