@prisma/client-engine-runtime 6.4.0-dev.24

package/dist/index.js

@@ -0,0 +1,838 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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/runtime/core/engines/client/QueryPlan.ts
+function isPrismaValuePlaceholder(value) {
+  return typeof value === "object" && value !== null && value["prisma__type"] === "param";
+}
+
+// src/runtime/core/engines/client/interpreter/renderQueryTemplate.ts
+var BEGIN_REPEAT = "/* prisma-comma-repeatable-start */";
+var END_REPEAT = "/* prisma-comma-repeatable-end */";
+function renderQueryTemplate({
+  query,
+  params
+}) {
+  const flattened = [];
+  let lastParamId = 1;
+  let result = "";
+  let templatePos = 0;
+  while (templatePos < query.length) {
+    if (query.slice(templatePos, templatePos + BEGIN_REPEAT.length) === BEGIN_REPEAT) {
+      templatePos += BEGIN_REPEAT.length;
+      result += "(";
+      const paramNum = parseInt(query.slice(templatePos).match(/^\$(\d+)/)?.[1] ?? "0");
+      const arrParam = params[paramNum - 1];
+      const expanded = arrParam.map((_, idx) => "$" + (lastParamId + idx)).join(", ");
+      result += expanded;
+      flattened.push(...arrParam);
+      lastParamId += arrParam.length;
+      templatePos += query.slice(templatePos).indexOf(END_REPEAT) + END_REPEAT.length;
+      result += ")";
+    } else if (query[templatePos] === "$") {
+      const paramMatch = query.slice(templatePos + 1).match(/^\d+/);
+      if (paramMatch) {
+        const paramNum = parseInt(paramMatch[0]);
+        const paramValue = params[paramNum - 1];
+        if (!Array.isArray(paramValue)) {
+          result += "$" + lastParamId;
+          flattened.push(paramValue);
+          lastParamId++;
+          templatePos += paramMatch[0].length + 1;
+        }
+      } else {
+        result += query[templatePos];
+        templatePos++;
+      }
+    } else {
+      result += query[templatePos];
+      templatePos++;
+    }
+  }
+  return {
+    query: result,
+    params: flattened
+  };
+}
+
+// src/runtime/core/engines/client/interpreter/renderQuery.ts
+function renderQuery({ query, params }, scope) {
+  const substitutedParams = params.map((param) => {
+    if (!isPrismaValuePlaceholder(param)) {
+      return param;
+    }
+    const value = scope[param.prisma__value.name];
+    if (value === void 0) {
+      throw new Error(`Missing value for query variable ${param.prisma__value.name}`);
+    }
+    return value;
+  });
+  const { query: renderedQuery, params: expandedParams } = renderQueryTemplate({ query, params: substitutedParams });
+  const argTypes = expandedParams.map((param) => toArgType(param));
+  return {
+    sql: renderedQuery,
+    args: expandedParams,
+    argTypes
+  };
+}
+function toArgType(value) {
+  if (value === null) {
+    return "Int32";
+  }
+  if (typeof value === "string") {
+    return "Text";
+  }
+  if (typeof value === "number") {
+    return "Numeric";
+  }
+  if (typeof value === "boolean") {
+    return "Boolean";
+  }
+  if (Array.isArray(value)) {
+    return "Array";
+  }
+  if (isPrismaValuePlaceholder(value)) {
+    return placeholderTypeToArgType(value.prisma__value.type);
+  }
+  return "Json";
+}
+function placeholderTypeToArgType(type) {
+  const typeMap = {
+    Any: "Json",
+    String: "Text",
+    Int: "Int32",
+    BigInt: "Int64",
+    Float: "Double",
+    Boolean: "Boolean",
+    Decimal: "Numeric",
+    Date: "DateTime",
+    Object: "Json",
+    Bytes: "Bytes",
+    Array: "Array"
+  };
+  const mappedType = typeMap[type];
+  if (!mappedType) {
+    throw new Error(`Unknown placeholder type: ${type}`);
+  }
+  return mappedType;
+}
+
+// src/runtime/core/engines/client/interpreter/serializer.ts
+function serialize(resultSet) {
+  return resultSet.rows.map(
+    (row) => row.reduce((acc, value, index) => {
+      acc[resultSet.columnNames[index]] = value;
+      return acc;
+    }, {})
+  );
+}
+
+// src/runtime/core/engines/client/interpreter/QueryInterpreter.ts
+var _queryable, _placeholderValues, _onQuery, _QueryInterpreter_instances, withQueryEvent_fn;
+var QueryInterpreter = class {
+  constructor({ queryable, placeholderValues, onQuery }) {
+    __privateAdd(this, _QueryInterpreter_instances);
+    __privateAdd(this, _queryable);
+    __privateAdd(this, _placeholderValues);
+    __privateAdd(this, _onQuery);
+    __privateSet(this, _queryable, queryable);
+    __privateSet(this, _placeholderValues, placeholderValues);
+    __privateSet(this, _onQuery, onQuery);
+  }
+  async run(queryPlan) {
+    return this.interpretNode(queryPlan, __privateGet(this, _placeholderValues));
+  }
+  async interpretNode(node, scope) {
+    switch (node.type) {
+      case "seq": {
+        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        return results[results.length - 1];
+      }
+      case "get": {
+        return scope[node.args.name];
+      }
+      case "let": {
+        const nestedScope = Object.create(scope);
+        await Promise.all(
+          node.args.bindings.map(async (binding) => {
+            nestedScope[binding.name] = await this.interpretNode(binding.expr, scope);
+          })
+        );
+        return this.interpretNode(node.args.expr, nestedScope);
+      }
+      case "getFirstNonEmpty": {
+        for (const name of node.args.names) {
+          const value = scope[name];
+          if (!isEmpty(value)) {
+            return value;
+          }
+        }
+        return [];
+      }
+      case "concat": {
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        return parts.reduce((acc, part) => acc.concat(asList(part)), []);
+      }
+      case "sum": {
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        return parts.reduce((acc, part) => asNumber(acc) + asNumber(part));
+      }
+      case "execute": {
+        const query = renderQuery(node.args, scope);
+        return __privateMethod(this, _QueryInterpreter_instances, withQueryEvent_fn).call(this, query, async () => {
+          const result = await __privateGet(this, _queryable).executeRaw(query);
+          if (result.ok) {
+            return result.value;
+          } else {
+            throw result.error;
+          }
+        });
+      }
+      case "query": {
+        const query = renderQuery(node.args, scope);
+        return __privateMethod(this, _QueryInterpreter_instances, withQueryEvent_fn).call(this, query, async () => {
+          const result = await __privateGet(this, _queryable).queryRaw(query);
+          if (result.ok) {
+            return serialize(result.value);
+          } else {
+            throw result.error;
+          }
+        });
+      }
+      case "reverse": {
+        const value = await this.interpretNode(node.args, scope);
+        return Array.isArray(value) ? value.reverse() : value;
+      }
+      case "unique": {
+        const value = await this.interpretNode(node.args, scope);
+        if (!Array.isArray(value)) {
+          return value;
+        }
+        if (value.length !== 1) {
+          throw new Error(`Expected exactly one element, got ${value.length}`);
+        }
+        return value[0];
+      }
+      case "required": {
+        const value = await this.interpretNode(node.args, scope);
+        if (isEmpty(value)) {
+          throw new Error("Required value is empty");
+        }
+        return value;
+      }
+      case "mapField": {
+        const value = await this.interpretNode(node.args.records, scope);
+        return mapField(value, node.args.field);
+      }
+      case "join": {
+        const parent = await this.interpretNode(node.args.parent, scope);
+        const children = await Promise.all(
+          node.args.children.map(async (joinExpr) => ({
+            joinExpr,
+            childRecords: await this.interpretNode(joinExpr.child, scope)
+          }))
+        );
+        if (Array.isArray(parent)) {
+          for (const record of parent) {
+            attachChildrenToParent(asRecord(record), children);
+          }
+          return parent;
+        }
+        return attachChildrenToParent(asRecord(parent), children);
+      }
+      default: {
+        node;
+        throw new Error(`Unexpected node type: ${node.type}`);
+      }
+    }
+  }
+};
+_queryable = new WeakMap();
+_placeholderValues = new WeakMap();
+_onQuery = new WeakMap();
+_QueryInterpreter_instances = new WeakSet();
+withQueryEvent_fn = async function(query, execute) {
+  var _a;
+  const timestamp = /* @__PURE__ */ new Date();
+  const startInstant = performance.now();
+  const result = await execute();
+  const endInstant = performance.now();
+  (_a = __privateGet(this, _onQuery)) == null ? void 0 : _a.call(this, {
+    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"
+  });
+  return result;
+};
+function isEmpty(value) {
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  return value == null;
+}
+function asList(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function asNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return Number(value);
+  }
+  throw new Error(`Expected number, got ${typeof value}`);
+}
+function asRecord(value) {
+  if (typeof value === "object" && value !== null) {
+    return value;
+  }
+  throw new Error(`Expected object, got ${typeof value}`);
+}
+function mapField(value, field) {
+  if (Array.isArray(value)) {
+    return value.map((element) => mapField(element, field));
+  }
+  if (typeof value === "object" && value !== null) {
+    return value[field] ?? null;
+  }
+  return value;
+}
+function attachChildrenToParent(parentRecord, children) {
+  for (const { joinExpr, childRecords } of children) {
+    parentRecord[joinExpr.parentField] = filterChildRecords(childRecords, parentRecord, joinExpr);
+  }
+  return parentRecord;
+}
+function filterChildRecords(records, parentRecord, joinExpr) {
+  if (Array.isArray(records)) {
+    return records.filter((record) => childRecordMatchesParent(asRecord(record), parentRecord, joinExpr));
+  } else {
+    const record = asRecord(records);
+    return childRecordMatchesParent(record, parentRecord, joinExpr) ? record : null;
+  }
+}
+function childRecordMatchesParent(childRecord, parentRecord, joinExpr) {
+  for (const [parentField, childField] of joinExpr.on) {
+    if (parentRecord[parentField] !== childRecord[childField]) {
+      return false;
+    }
+  }
+  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;
+
+// ../internals/src/utils/assertNever.ts
+function assertNever(arg, errorMessage) {
+  throw new Error(errorMessage);
+}
+
+// ../internals/src/utils/setClassName.ts
+function setClassName(classObject, name) {
+  Object.defineProperty(classObject, "name", {
+    value: name,
+    configurable: true
+  });
+}
+
+// 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;
+    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
+    });
+  }
+};
+var TransactionDriverAdapterError = class extends TransactionManagerError {
+  constructor(message, errorParams) {
+    super(`Error from Driver Adapter: ${message}`, {
+      clientVersion: errorParams.clientVersion,
+      meta: {
+        ...errorParams.driverAdapterError
+      }
+    });
+  }
+};
+var TransactionNotFoundError = class extends TransactionManagerError {
+  constructor(errorParams) {
+    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
+    );
+  }
+};
+var TransactionClosedError = class extends TransactionManagerError {
+  constructor(operation, errorParams) {
+    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`, errorParams);
+  }
+};
+var TransactionRolledBackError = class extends TransactionManagerError {
+  constructor(operation, errorParams) {
+    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`, errorParams);
+  }
+};
+var TransactionStartTimoutError = class extends TransactionManagerError {
+  constructor(errorParams) {
+    super("Unable to start a transaction in the given time.", errorParams);
+  }
+};
+var TransactionExecutionTimeoutError = class extends TransactionManagerError {
+  constructor(operation, { clientVersion, 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 }
+    );
+  }
+};
+var TransactionInternalConsistencyError = class extends TransactionManagerError {
+  constructor(message, errorParams) {
+    super(`Internal Consistency Error: ${message}`, errorParams);
+  }
+};
+var InvalidTransactionIsolationLevelError = class extends TransactionManagerError {
+  constructor(isolationLevel, errorParams) {
+    super(`Invalid isolation level: ${isolationLevel}`, errorParams);
+  }
+};
+
+// src/runtime/core/engines/client/transactionManager/TransactionManager.ts
+var MAX_CLOSED_TRANSACTIONS = 100;
+var isolationLevelMap = {
+  ReadUncommitted: "READ UNCOMMITTED",
+  ReadCommitted: "READ COMMITTED",
+  RepeatableRead: "REPEATABLE READ",
+  Snapshot: "SNAPSHOT",
+  Serializable: "SERIALIZABLE"
+};
+var debug = src_default("prisma:client:transactionManager");
+var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
+var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
+var ISOLATION_LEVEL_QUERY = (isolationLevel) => ({
+  sql: "SET TRANSACTION ISOLATION LEVEL " + isolationLevelMap[isolationLevel],
+  args: [],
+  argTypes: []
+});
+var TransactionManager = class {
+  constructor({ driverAdapter, clientVersion }) {
+    // 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(),
+      status: "waiting",
+      timer: void 0,
+      timeout: validatedOptions.timeout,
+      startedAt: Date.now(),
+      transaction: void 0
+    };
+    this.transactions.set(transaction.id, transaction);
+    transaction.timer = this.startTransactionTimeout(transaction.id, validatedOptions.maxWait);
+    const txContext = await this.driverAdapter.transactionContext();
+    if (!txContext.ok)
+      throw new TransactionDriverAdapterError("Failed to start transaction.", {
+        driverAdapterError: txContext.error,
+        clientVersion: this.clientVersion
+      });
+    if (this.requiresSettingIsolationLevelFirst() && validatedOptions.isolationLevel) {
+      await txContext.value.executeRaw(ISOLATION_LEVEL_QUERY(validatedOptions.isolationLevel));
+    }
+    const startedTransaction = await txContext.value.startTransaction();
+    if (!startedTransaction.ok)
+      throw new TransactionDriverAdapterError("Failed to start transaction.", {
+        driverAdapterError: startedTransaction.error,
+        clientVersion: this.clientVersion
+      });
+    if (!startedTransaction.value.options.usePhantomQuery) {
+      await startedTransaction.value.executeRaw({ sql: "BEGIN", args: [], argTypes: [] });
+      if (!this.requiresSettingIsolationLevelFirst() && validatedOptions.isolationLevel) {
+        await txContext.value.executeRaw(ISOLATION_LEVEL_QUERY(validatedOptions.isolationLevel));
+      }
+    }
+    switch (transaction.status) {
+      case "waiting":
+        transaction.transaction = startedTransaction.value;
+        clearTimeout(transaction.timer);
+        transaction.timer = void 0;
+        transaction.status = "running";
+        transaction.timer = this.startTransactionTimeout(transaction.id, validatedOptions.timeout);
+        return { id: transaction.id, payload: void 0 };
+      case "timed_out":
+        throw new TransactionStartTimoutError({ clientVersion: this.clientVersion });
+      case "running":
+      case "committed":
+      case "rolled_back":
+        throw new TransactionInternalConsistencyError(
+          `Transaction in invalid state ${transaction.status} although it just finished startup.`,
+          {
+            clientVersion: this.clientVersion
+          }
+        );
+      default:
+        assertNever(transaction.status, "Unknown transaction status.");
+    }
+  }
+  async commitTransaction(transactionId) {
+    const txw = this.getActiveTransaction(transactionId, "commit");
+    await this.closeTransaction(txw, "committed");
+  }
+  async rollbackTransaction(transactionId) {
+    const txw = this.getActiveTransaction(transactionId, "rollback");
+    await this.closeTransaction(txw, "rolled_back");
+  }
+  getTransaction(txInfo, operation) {
+    const tx = this.getActiveTransaction(txInfo.id, operation);
+    if (!tx.transaction) throw new TransactionNotFoundError({ clientVersion: this.clientVersion });
+    return tx.transaction;
+  }
+  getActiveTransaction(transactionId, operation) {
+    const transaction = this.transactions.get(transactionId);
+    if (!transaction) {
+      const closedTransaction = this.closedTransactions.find((tx) => tx.id === transactionId);
+      if (closedTransaction) {
+        debug("Transaction already closed.", { transactionId, status: closedTransaction.status });
+        switch (closedTransaction.status) {
+          case "waiting":
+          case "running":
+            throw new TransactionInternalConsistencyError("Active transaction found in closed transactions list.", {
+              clientVersion: this.clientVersion
+            });
+          case "committed":
+            throw new TransactionClosedError(operation, { clientVersion: this.clientVersion });
+          case "rolled_back":
+            throw new TransactionRolledBackError(operation, { clientVersion: this.clientVersion });
+          case "timed_out":
+            throw new TransactionExecutionTimeoutError(operation, {
+              timeout: closedTransaction.timeout,
+              timeTaken: Date.now() - closedTransaction.startedAt,
+              clientVersion: this.clientVersion
+            });
+        }
+      } else {
+        debug(`Transaction not found.`, transactionId);
+        throw new TransactionNotFoundError({ clientVersion: this.clientVersion });
+      }
+    }
+    if (["committed", "rolled_back", "timed_out"].includes(transaction.status)) {
+      throw new TransactionInternalConsistencyError("Closed transaction found in active transactions map.", {
+        clientVersion: this.clientVersion
+      });
+    }
+    return transaction;
+  }
+  startTransactionTimeout(transactionId, timeout) {
+    const timeoutStartedAt = Date.now();
+    return setTimeout(async () => {
+      debug("Transaction timed out.", { transactionId, timeoutStartedAt, timeout });
+      const tx = this.transactions.get(transactionId);
+      if (tx && ["running", "waiting"].includes(tx.status)) {
+        await this.closeTransaction(tx, "timed_out");
+      } else {
+        debug("Transaction already committed or rolled back when timeout happened.", transactionId);
+      }
+    }, timeout);
+  }
+  async closeTransaction(tx, status) {
+    debug("Closing transaction.", { transactionId: tx.id, status });
+    tx.status = status;
+    if (tx.transaction && status === "committed") {
+      const result = await tx.transaction.commit();
+      if (!result.ok)
+        throw new TransactionDriverAdapterError("Failed to commit transaction.", {
+          driverAdapterError: result.error,
+          clientVersion: this.clientVersion
+        });
+      if (!tx.transaction.options.usePhantomQuery) {
+        await tx.transaction.executeRaw(COMMIT_QUERY());
+      }
+    } else if (tx.transaction) {
+      const result = await tx.transaction.rollback();
+      if (!result.ok)
+        throw new TransactionDriverAdapterError("Failed to rollback transaction.", {
+          driverAdapterError: result.error,
+          clientVersion: this.clientVersion
+        });
+      if (!tx.transaction.options.usePhantomQuery) {
+        await tx.transaction.executeRaw(ROLLBACK_QUERY());
+      }
+    }
+    clearTimeout(tx.timer);
+    tx.timer = void 0;
+    this.transactions.delete(tx.id);
+    this.closedTransactions.push(tx);
+    if (this.closedTransactions.length > MAX_CLOSED_TRANSACTIONS) {
+      this.closedTransactions.shift();
+    }
+  }
+  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.isolationLevel === "Snapshot" /* Snapshot */)
+      throw new InvalidTransactionIsolationLevelError(options.isolationLevel, { clientVersion: this.clientVersion });
+    if (this.driverAdapter.provider === "sqlite" && options.isolationLevel && options.isolationLevel !== "Serializable" /* Serializable */)
+      throw new InvalidTransactionIsolationLevelError(options.isolationLevel, { clientVersion: this.clientVersion });
+    return {
+      ...options,
+      timeout: options.timeout,
+      maxWait: options.maxWait
+    };
+  }
+  requiresSettingIsolationLevelFirst() {
+    return this.driverAdapter.provider === "mysql";
+  }
+};
+export {
+  IsolationLevel,
+  QueryInterpreter,
+  TransactionManager,
+  isPrismaValuePlaceholder
+};