@prisma/client-engine-runtime 7.10.0-dev.9 → 7.10.0-integration-prisma7-project-closeout.8

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":
@@ -277,7 +291,11 @@ function rethrowAsUserFacing(error) {
   const code = getErrorCode(error);
   const message = renderErrorMessage(error);
   if (code !== void 0 && message !== void 0) {
-    throw new UserFacingError(message, code, { driverAdapterError: error });
+    const meta = { driverAdapterError: error };
+    if (error.cause.kind === "UniqueConstraintViolation" && error.cause.table) {
+      meta.table = error.cause.table;
+    }
+    throw new UserFacingError(message, code, meta);
   }
   if (isGenericDatabaseErrorKind(error.cause.kind)) {
     throw buildUnmappedDatabaseUserFacingError(error);
@@ -343,6 +361,7 @@ function getErrorCode(err) {
     case "UniqueConstraintViolation":
       return "P2002";
     case "ForeignKeyConstraintViolation":
+    case "RestrictViolation":
       return "P2003";
     case "InvalidInputValue":
       return "P2007";
@@ -415,6 +434,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 +711,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 +728,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 +759,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 +807,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 +1169,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 +1600,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 +1635,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 +1665,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 +1673,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 +1691,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 +1771,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 +1790,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 +1819,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 +2171,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 +2775,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() {
@@ -2561,7 +2851,7 @@ function trackStartingTransaction() {
   });
   return { abortController: new AbortController(), settled, markSettled };
 }
-var debug = (0, import_debug.Debug)("prisma:client:transactionManager");
+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 = () => ({
@@ -2730,7 +3020,7 @@ var TransactionManager = class {
         }
       }
     } catch (e) {
-      debug("error in discarded transaction:", e);
+      debug2("error in discarded transaction:", e);
     }
   }
   async commitTransaction(transactionId) {
@@ -2794,7 +3084,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":
@@ -2811,7 +3101,7 @@ var TransactionManager = class {
             });
         }
       } else {
-        debug(`Transaction not found.`, transactionId);
+        debug2(`Transaction not found.`, transactionId);
         throw new TransactionNotFoundError();
       }
     }
@@ -2862,25 +3152,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;
@@ -2912,7 +3206,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) {