@prisma/client-engine-runtime 6.4.0-dev.48 → 6.4.0-dev.50

package/dist/index.js

@@ -1,4 +1,10 @@
+"use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
@@ -6,28 +12,46 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
-// src/runtime/core/engines/common/types/Transaction.ts
-var IsolationLevel = /* @__PURE__ */ ((IsolationLevel2) => {
-  IsolationLevel2["ReadUncommitted"] = "ReadUncommitted";
-  IsolationLevel2["ReadCommitted"] = "ReadCommitted";
-  IsolationLevel2["RepeatableRead"] = "RepeatableRead";
-  IsolationLevel2["Snapshot"] = "Snapshot";
-  IsolationLevel2["Serializable"] = "Serializable";
-  return IsolationLevel2;
-})(IsolationLevel || {});
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  IsolationLevel: () => IsolationLevel,
+  QueryInterpreter: () => QueryInterpreter,
+  TransactionManager: () => TransactionManager,
+  TransactionManagerError: () => TransactionManagerError,
+  isPrismaValuePlaceholder: () => isPrismaValuePlaceholder
+});
+module.exports = __toCommonJS(index_exports);
 
-// src/runtime/core/engines/client/QueryPlan.ts
+// src/QueryPlan.ts
 function isPrismaValuePlaceholder(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "param";
 }
 
-// src/runtime/core/engines/client/interpreter/renderQueryTemplate.ts
+// src/interpreter/renderQueryTemplate.ts
 var BEGIN_REPEAT = "/* prisma-comma-repeatable-start */";
 var END_REPEAT = "/* prisma-comma-repeatable-end */";
 function renderQueryTemplate({
@@ -125,7 +149,7 @@ function renderQueryTemplate({
   };
 }
 
-// src/runtime/core/engines/client/interpreter/renderQuery.ts
+// src/interpreter/renderQuery.ts
 function renderQuery({ query, params }, scope) {
   const substitutedParams = params.map((param) => {
     if (!isPrismaValuePlaceholder(param)) {
@@ -187,7 +211,7 @@ function placeholderTypeToArgType(type) {
   return mappedType;
 }
 
-// src/runtime/core/engines/client/interpreter/serializer.ts
+// src/interpreter/serialize.ts
 function serialize(resultSet) {
   return resultSet.rows.map(
     (row) => row.reduce((acc, value, index) => {
@@ -209,7 +233,7 @@ function serialize(resultSet) {
   );
 }
 
-// src/runtime/core/engines/client/interpreter/QueryInterpreter.ts
+// src/interpreter/QueryInterpreter.ts
 var _queryable, _placeholderValues, _onQuery, _QueryInterpreter_instances, withQueryEvent_fn;
 var QueryInterpreter = class {
   constructor({ queryable, placeholderValues, onQuery }) {
@@ -343,16 +367,7 @@ withQueryEvent_fn = async function(query, execute) {
     timestamp,
     duration: endInstant - startInstant,
     query: query.sql,
-    // TODO: we should probably change the interface to contain a proper array in the next major version.
-    params: JSON.stringify(query.args),
-    // TODO: this field only exists for historical reasons as we grandfathered it from the time
-    // when we emitted `tracing` events to stdout in the engine unchanged, and then described
-    // them in the public API as TS types. Thus this field used to contain the name of the Rust
-    // module in which an event originated. When using library engine, which uses a different
-    // mechanism with a JavaScript callback for logs, it's normally just an empty string instead.
-    // This field is definitely not useful and should be removed from the public types (but it's
-    // technically a breaking change, even if a tiny and inconsequential one).
-    target: "QueryInterpreter"
+    params: query.args
   });
   return result;
 };
@@ -412,292 +427,80 @@ function childRecordMatchesParent(childRecord, parentRecord, joinExpr) {
   return true;
 }
 
-// ../../node_modules/.pnpm/kleur@4.1.5/node_modules/kleur/colors.mjs
-var colors_exports = {};
-__export(colors_exports, {
-  $: () => $,
-  bgBlack: () => bgBlack,
-  bgBlue: () => bgBlue,
-  bgCyan: () => bgCyan,
-  bgGreen: () => bgGreen,
-  bgMagenta: () => bgMagenta,
-  bgRed: () => bgRed,
-  bgWhite: () => bgWhite,
-  bgYellow: () => bgYellow,
-  black: () => black,
-  blue: () => blue,
-  bold: () => bold,
-  cyan: () => cyan,
-  dim: () => dim,
-  gray: () => gray,
-  green: () => green,
-  grey: () => grey,
-  hidden: () => hidden,
-  inverse: () => inverse,
-  italic: () => italic,
-  magenta: () => magenta,
-  red: () => red,
-  reset: () => reset,
-  strikethrough: () => strikethrough,
-  underline: () => underline,
-  white: () => white,
-  yellow: () => yellow
-});
-var FORCE_COLOR;
-var NODE_DISABLE_COLORS;
-var NO_COLOR;
-var TERM;
-var isTTY = true;
-if (typeof process !== "undefined") {
-  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
-  isTTY = process.stdout && process.stdout.isTTY;
-}
-var $ = {
-  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY)
-};
-function init(x, y) {
-  let rgx = new RegExp(`\\x1b\\[${y}m`, "g");
-  let open = `\x1B[${x}m`, close = `\x1B[${y}m`;
-  return function(txt) {
-    if (!$.enabled || txt == null) return txt;
-    return open + (!!~("" + txt).indexOf(close) ? txt.replace(rgx, close + open) : txt) + close;
-  };
-}
-var reset = init(0, 0);
-var bold = init(1, 22);
-var dim = init(2, 22);
-var italic = init(3, 23);
-var underline = init(4, 24);
-var inverse = init(7, 27);
-var hidden = init(8, 28);
-var strikethrough = init(9, 29);
-var black = init(30, 39);
-var red = init(31, 39);
-var green = init(32, 39);
-var yellow = init(33, 39);
-var blue = init(34, 39);
-var magenta = init(35, 39);
-var cyan = init(36, 39);
-var white = init(37, 39);
-var gray = init(90, 39);
-var grey = init(90, 39);
-var bgBlack = init(40, 49);
-var bgRed = init(41, 49);
-var bgGreen = init(42, 49);
-var bgYellow = init(43, 49);
-var bgBlue = init(44, 49);
-var bgMagenta = init(45, 49);
-var bgCyan = init(46, 49);
-var bgWhite = init(47, 49);
-
-// ../debug/src/index.ts
-var MAX_ARGS_HISTORY = 100;
-var COLORS = ["green", "yellow", "blue", "magenta", "cyan", "red"];
-var argsHistory = [];
-var lastTimestamp = Date.now();
-var lastColor = 0;
-var processEnv = typeof process !== "undefined" ? process.env : {};
-globalThis.DEBUG ??= processEnv.DEBUG ?? "";
-globalThis.DEBUG_COLORS ??= processEnv.DEBUG_COLORS ? processEnv.DEBUG_COLORS === "true" : true;
-var topProps = {
-  enable(namespace) {
-    if (typeof namespace === "string") {
-      globalThis.DEBUG = namespace;
-    }
-  },
-  disable() {
-    const prev = globalThis.DEBUG;
-    globalThis.DEBUG = "";
-    return prev;
-  },
-  // this is the core logic to check if logging should happen or not
-  enabled(namespace) {
-    const listenedNamespaces = globalThis.DEBUG.split(",").map((s) => {
-      return s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-    });
-    const isListened = listenedNamespaces.some((listenedNamespace) => {
-      if (listenedNamespace === "" || listenedNamespace[0] === "-") return false;
-      return namespace.match(RegExp(listenedNamespace.split("*").join(".*") + "$"));
-    });
-    const isExcluded = listenedNamespaces.some((listenedNamespace) => {
-      if (listenedNamespace === "" || listenedNamespace[0] !== "-") return false;
-      return namespace.match(RegExp(listenedNamespace.slice(1).split("*").join(".*") + "$"));
-    });
-    return isListened && !isExcluded;
-  },
-  log: (...args) => {
-    const [namespace, format, ...rest] = args;
-    const logWithFormatting = console.warn ?? console.log;
-    logWithFormatting(`${namespace} ${format}`, ...rest);
-  },
-  formatters: {}
-  // not implemented
-};
-function debugCreate(namespace) {
-  const instanceProps = {
-    color: COLORS[lastColor++ % COLORS.length],
-    enabled: topProps.enabled(namespace),
-    namespace,
-    log: topProps.log,
-    extend: () => {
-    }
-    // not implemented
-  };
-  const debugCall = (...args) => {
-    const { enabled, namespace: namespace2, color, log } = instanceProps;
-    if (args.length !== 0) {
-      argsHistory.push([namespace2, ...args]);
-    }
-    if (argsHistory.length > MAX_ARGS_HISTORY) {
-      argsHistory.shift();
-    }
-    if (topProps.enabled(namespace2) || enabled) {
-      const stringArgs = args.map((arg) => {
-        if (typeof arg === "string") {
-          return arg;
-        }
-        return safeStringify(arg);
-      });
-      const ms = `+${Date.now() - lastTimestamp}ms`;
-      lastTimestamp = Date.now();
-      if (globalThis.DEBUG_COLORS) {
-        log(colors_exports[color](bold(namespace2)), ...stringArgs, colors_exports[color](ms));
-      } else {
-        log(namespace2, ...stringArgs, ms);
-      }
-    }
-  };
-  return new Proxy(debugCall, {
-    get: (_, prop) => instanceProps[prop],
-    set: (_, prop, value) => instanceProps[prop] = value
-  });
-}
-var Debug = new Proxy(debugCreate, {
-  get: (_, prop) => topProps[prop],
-  set: (_, prop, value) => topProps[prop] = value
-});
-function safeStringify(value, indent = 2) {
-  const cache = /* @__PURE__ */ new Set();
-  return JSON.stringify(
-    value,
-    (key, value2) => {
-      if (typeof value2 === "object" && value2 !== null) {
-        if (cache.has(value2)) {
-          return `[Circular *]`;
-        }
-        cache.add(value2);
-      } else if (typeof value2 === "bigint") {
-        return value2.toString();
-      }
-      return value2;
-    },
-    indent
-  );
-}
-var src_default = Debug;
+// src/transactionManager/Transaction.ts
+var IsolationLevel = /* @__PURE__ */ ((IsolationLevel2) => {
+  IsolationLevel2["ReadUncommitted"] = "ReadUncommitted";
+  IsolationLevel2["ReadCommitted"] = "ReadCommitted";
+  IsolationLevel2["RepeatableRead"] = "RepeatableRead";
+  IsolationLevel2["Snapshot"] = "Snapshot";
+  IsolationLevel2["Serializable"] = "Serializable";
+  return IsolationLevel2;
+})(IsolationLevel || {});
 
-// ../internals/src/utils/assertNever.ts
-function assertNever(arg, errorMessage) {
-  throw new Error(errorMessage);
-}
+// src/transactionManager/TransactionManager.ts
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_debug = __toESM(require("@prisma/debug"));
 
-// ../internals/src/utils/setClassName.ts
-function setClassName(classObject, name) {
-  Object.defineProperty(classObject, "name", {
-    value: name,
-    configurable: true
-  });
+// src/utils.ts
+function assertNever(_, message) {
+  throw new Error(message);
 }
 
-// src/runtime/core/engines/client/transactionManager/TransactionManager.ts
-import crypto from "crypto";
-
-// src/runtime/core/errors/PrismaClientKnownRequestError.ts
-var PrismaClientKnownRequestError = class extends Error {
-  constructor(message, { code, clientVersion, meta, batchRequestIdx }) {
-    super(message);
-    this.name = "PrismaClientKnownRequestError";
-    this.code = code;
-    this.clientVersion = clientVersion;
+// src/transactionManager/TransactionManagerErrors.ts
+var TransactionManagerError = class extends Error {
+  constructor(message, meta) {
+    super("Transaction API error: " + message);
     this.meta = meta;
-    Object.defineProperty(this, "batchRequestIdx", {
-      value: batchRequestIdx,
-      enumerable: false,
-      writable: true
-    });
-  }
-  get [Symbol.toStringTag]() {
-    return "PrismaClientKnownRequestError";
-  }
-};
-setClassName(PrismaClientKnownRequestError, "PrismaClientKnownRequestError");
-
-// src/runtime/core/engines/client/transactionManager/TransactionManagerErrors.ts
-var TransactionManagerError = class extends PrismaClientKnownRequestError {
-  constructor(message, {
-    clientVersion,
-    meta
-  }) {
-    super("Transaction API error: " + message, {
-      code: "P2028",
-      clientVersion,
-      meta
-    });
+    this.code = "P2028";
   }
 };
 var TransactionDriverAdapterError = class extends TransactionManagerError {
   constructor(message, errorParams) {
-    super(`Error from Driver Adapter: ${message}`, {
-      clientVersion: errorParams.clientVersion,
-      meta: {
-        ...errorParams.driverAdapterError
-      }
-    });
+    super(`Error from Driver Adapter: ${message}`, { ...errorParams.driverAdapterError });
   }
 };
 var TransactionNotFoundError = class extends TransactionManagerError {
-  constructor(errorParams) {
+  constructor() {
     super(
-      "Transaction not found. Transaction ID is invalid, refers to an old closed transaction Prisma doesn't have information about anymore, or was obtained before disconnecting.",
-      errorParams
+      "Transaction not found. Transaction ID is invalid, refers to an old closed transaction Prisma doesn't have information about anymore, or was obtained before disconnecting."
     );
   }
 };
 var TransactionClosedError = class extends TransactionManagerError {
-  constructor(operation, errorParams) {
-    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`, errorParams);
+  constructor(operation) {
+    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`);
   }
 };
 var TransactionRolledBackError = class extends TransactionManagerError {
-  constructor(operation, errorParams) {
-    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`, errorParams);
+  constructor(operation) {
+    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`);
   }
 };
 var TransactionStartTimoutError = class extends TransactionManagerError {
-  constructor(errorParams) {
-    super("Unable to start a transaction in the given time.", errorParams);
+  constructor() {
+    super("Unable to start a transaction in the given time.");
   }
 };
 var TransactionExecutionTimeoutError = class extends TransactionManagerError {
-  constructor(operation, { clientVersion, timeout, timeTaken }) {
+  constructor(operation, { timeout, timeTaken }) {
     super(
       `A ${operation} cannot be executed on an expired transaction. The timeout for this transaction was ${timeout} ms, however ${timeTaken} ms passed since the start of the transaction. Consider increasing the interactive transaction timeout or doing less work in the transaction`,
-      { clientVersion }
+      { operation, timeout, timeTaken }
     );
   }
 };
 var TransactionInternalConsistencyError = class extends TransactionManagerError {
-  constructor(message, errorParams) {
-    super(`Internal Consistency Error: ${message}`, errorParams);
+  constructor(message) {
+    super(`Internal Consistency Error: ${message}`);
   }
 };
 var InvalidTransactionIsolationLevelError = class extends TransactionManagerError {
-  constructor(isolationLevel, errorParams) {
-    super(`Invalid isolation level: ${isolationLevel}`, errorParams);
+  constructor(isolationLevel) {
+    super(`Invalid isolation level: ${isolationLevel}`, { isolationLevel });
   }
 };
 
-// src/runtime/core/engines/client/transactionManager/TransactionManager.ts
+// src/transactionManager/TransactionManager.ts
 var MAX_CLOSED_TRANSACTIONS = 100;
 var isolationLevelMap = {
   ReadUncommitted: "READ UNCOMMITTED",
@@ -706,7 +509,7 @@ var isolationLevelMap = {
   Snapshot: "SNAPSHOT",
   Serializable: "SERIALIZABLE"
 };
-var debug = src_default("prisma:client:transactionManager");
+var debug = (0, import_debug.default)("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
 var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
 var ISOLATION_LEVEL_QUERY = (isolationLevel) => ({
@@ -715,19 +518,18 @@ var ISOLATION_LEVEL_QUERY = (isolationLevel) => ({
   argTypes: []
 });
 var TransactionManager = class {
-  constructor({ driverAdapter, clientVersion }) {
+  constructor({ driverAdapter }) {
     // The map of active transactions.
     this.transactions = /* @__PURE__ */ new Map();
     // List of last closed transactions. Max MAX_CLOSED_TRANSACTIONS entries.
     // Used to provide better error messages than a generic "transaction not found".
     this.closedTransactions = [];
     this.driverAdapter = driverAdapter;
-    this.clientVersion = clientVersion;
   }
   async startTransaction(options) {
     const validatedOptions = this.validateOptions(options);
     const transaction = {
-      id: crypto.randomUUID(),
+      id: import_node_crypto.default.randomUUID(),
       status: "waiting",
       timer: void 0,
       timeout: validatedOptions.timeout,
@@ -739,8 +541,7 @@ var TransactionManager = class {
     const txContext = await this.driverAdapter.transactionContext();
     if (!txContext.ok)
       throw new TransactionDriverAdapterError("Failed to start transaction.", {
-        driverAdapterError: txContext.error,
-        clientVersion: this.clientVersion
+        driverAdapterError: txContext.error
       });
     if (this.requiresSettingIsolationLevelFirst() && validatedOptions.isolationLevel) {
       await txContext.value.executeRaw(ISOLATION_LEVEL_QUERY(validatedOptions.isolationLevel));
@@ -748,8 +549,7 @@ var TransactionManager = class {
     const startedTransaction = await txContext.value.startTransaction();
     if (!startedTransaction.ok)
       throw new TransactionDriverAdapterError("Failed to start transaction.", {
-        driverAdapterError: startedTransaction.error,
-        clientVersion: this.clientVersion
+        driverAdapterError: startedTransaction.error
       });
     if (!startedTransaction.value.options.usePhantomQuery) {
       await startedTransaction.value.executeRaw({ sql: "BEGIN", args: [], argTypes: [] });
@@ -764,17 +564,14 @@ var TransactionManager = class {
         transaction.timer = void 0;
         transaction.status = "running";
         transaction.timer = this.startTransactionTimeout(transaction.id, validatedOptions.timeout);
-        return { id: transaction.id, payload: void 0 };
+        return { id: transaction.id };
       case "timed_out":
-        throw new TransactionStartTimoutError({ clientVersion: this.clientVersion });
+        throw new TransactionStartTimoutError();
       case "running":
       case "committed":
       case "rolled_back":
         throw new TransactionInternalConsistencyError(
-          `Transaction in invalid state ${transaction.status} although it just finished startup.`,
-          {
-            clientVersion: this.clientVersion
-          }
+          `Transaction in invalid state ${transaction.status} although it just finished startup.`
         );
       default:
         assertNever(transaction.status, "Unknown transaction status.");
@@ -790,7 +587,7 @@ var TransactionManager = class {
   }
   getTransaction(txInfo, operation) {
     const tx = this.getActiveTransaction(txInfo.id, operation);
-    if (!tx.transaction) throw new TransactionNotFoundError({ clientVersion: this.clientVersion });
+    if (!tx.transaction) throw new TransactionNotFoundError();
     return tx.transaction;
   }
   getActiveTransaction(transactionId, operation) {
@@ -802,29 +599,24 @@ var TransactionManager = class {
         switch (closedTransaction.status) {
           case "waiting":
           case "running":
-            throw new TransactionInternalConsistencyError("Active transaction found in closed transactions list.", {
-              clientVersion: this.clientVersion
-            });
+            throw new TransactionInternalConsistencyError("Active transaction found in closed transactions list.");
           case "committed":
-            throw new TransactionClosedError(operation, { clientVersion: this.clientVersion });
+            throw new TransactionClosedError(operation);
           case "rolled_back":
-            throw new TransactionRolledBackError(operation, { clientVersion: this.clientVersion });
+            throw new TransactionRolledBackError(operation);
           case "timed_out":
             throw new TransactionExecutionTimeoutError(operation, {
               timeout: closedTransaction.timeout,
-              timeTaken: Date.now() - closedTransaction.startedAt,
-              clientVersion: this.clientVersion
+              timeTaken: Date.now() - closedTransaction.startedAt
             });
         }
       } else {
         debug(`Transaction not found.`, transactionId);
-        throw new TransactionNotFoundError({ clientVersion: this.clientVersion });
+        throw new TransactionNotFoundError();
       }
     }
     if (["committed", "rolled_back", "timed_out"].includes(transaction.status)) {
-      throw new TransactionInternalConsistencyError("Closed transaction found in active transactions map.", {
-        clientVersion: this.clientVersion
-      });
+      throw new TransactionInternalConsistencyError("Closed transaction found in active transactions map.");
     }
     return transaction;
   }
@@ -850,8 +642,7 @@ var TransactionManager = class {
       const result = await tx.transaction.commit();
       if (!result.ok)
         throw new TransactionDriverAdapterError("Failed to commit transaction.", {
-          driverAdapterError: result.error,
-          clientVersion: this.clientVersion
+          driverAdapterError: result.error
         });
       if (!tx.transaction.options.usePhantomQuery) {
         await tx.transaction.executeRaw(COMMIT_QUERY());
@@ -860,8 +651,7 @@ var TransactionManager = class {
       const result = await tx.transaction.rollback();
       if (!result.ok)
         throw new TransactionDriverAdapterError("Failed to rollback transaction.", {
-          driverAdapterError: result.error,
-          clientVersion: this.clientVersion
+          driverAdapterError: result.error
         });
       if (!tx.transaction.options.usePhantomQuery) {
         await tx.transaction.executeRaw(ROLLBACK_QUERY());
@@ -876,14 +666,12 @@ var TransactionManager = class {
     }
   }
   validateOptions(options) {
-    if (!options.timeout)
-      throw new TransactionManagerError("timeout is required", { clientVersion: this.clientVersion });
-    if (!options.maxWait)
-      throw new TransactionManagerError("maxWait is required", { clientVersion: this.clientVersion });
+    if (!options.timeout) throw new TransactionManagerError("timeout is required");
+    if (!options.maxWait) throw new TransactionManagerError("maxWait is required");
     if (options.isolationLevel === "Snapshot" /* Snapshot */)
-      throw new InvalidTransactionIsolationLevelError(options.isolationLevel, { clientVersion: this.clientVersion });
+      throw new InvalidTransactionIsolationLevelError(options.isolationLevel);
     if (this.driverAdapter.provider === "sqlite" && options.isolationLevel && options.isolationLevel !== "Serializable" /* Serializable */)
-      throw new InvalidTransactionIsolationLevelError(options.isolationLevel, { clientVersion: this.clientVersion });
+      throw new InvalidTransactionIsolationLevelError(options.isolationLevel);
     return {
       ...options,
       timeout: options.timeout,
@@ -894,9 +682,11 @@ var TransactionManager = class {
     return this.driverAdapter.provider === "mysql";
   }
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   IsolationLevel,
   QueryInterpreter,
   TransactionManager,
+  TransactionManagerError,
   isPrismaValuePlaceholder
-};
+});