@vibeorm/adapter-mysql 2.0.0-alpha.1 → 2.0.0-alpha.10

package/dist/index.js

@@ -3,8 +3,56 @@
 import { internalError } from "@vibeorm/schema";
 import { createPool as mysql2CreatePool } from "mysql2/promise";
 
-// packages/adapter-mysql/src/errors.ts
+// packages/adapter-mysql/src/acquire.ts
 import { VibeError } from "@vibeorm/schema";
+var DEFAULT_ACQUIRE_TIMERS = Object.freeze({
+  set: (fn, ms) => setTimeout(fn, ms),
+  clear: (handle) => clearTimeout(handle)
+});
+var MYSQL_DEFAULT_CONNECTION_LIMIT = 10;
+function acquireTimeoutError(params) {
+  const { timeoutMs, poolSize } = params;
+  const size = poolSize === undefined ? "pool size unknown \u2014 the pool was supplied by the caller" : `connectionLimit ${poolSize}`;
+  return new VibeError({
+    code: "VIBE_ADAPTER",
+    message: `timed out after ${timeoutMs} ms waiting for a mysql pool connection \u2014 every pooled connection ` + `is busy (${size}). Raise \`connectionLimit\`, shorten the work holding a connection, or raise ` + "the adapter's `acquireTimeout` option.",
+    meta: {
+      reason: "acquire-timeout",
+      timeoutMs,
+      ...poolSize === undefined ? {} : { connectionLimit: poolSize }
+    }
+  });
+}
+async function acquireWithTimeout(params) {
+  const { pool, timeoutMs, poolSize } = params;
+  const timers = params.timers ?? DEFAULT_ACQUIRE_TIMERS;
+  const pending = pool.getConnection();
+  let timedOut = false;
+  let handle;
+  const deadline = new Promise((_resolve, reject) => {
+    handle = timers.set(() => {
+      timedOut = true;
+      reject(acquireTimeoutError({ timeoutMs, poolSize }));
+    }, timeoutMs);
+  });
+  pending.then((connection) => {
+    if (timedOut)
+      connection.release();
+  }, () => {
+    return;
+  }).catch(() => {
+    return;
+  });
+  try {
+    return await Promise.race([pending, deadline]);
+  } finally {
+    if (handle !== undefined)
+      timers.clear(handle);
+  }
+}
+
+// packages/adapter-mysql/src/errors.ts
+import { VibeError as VibeError2 } from "@vibeorm/schema";
 var MYSQL_ERRNO_ERROR_CODES = Object.freeze({
   1062: "VIBE_UNIQUE_VIOLATION",
   1586: "VIBE_UNIQUE_VIOLATION",
@@ -44,7 +92,7 @@ function mysqlErrorErrno(params) {
 }
 function mapMysqlDriverError(params) {
   const { error } = params;
-  if (error instanceof VibeError)
+  if (error instanceof VibeError2)
     return error;
   const source = error !== null && typeof error === "object" ? error : {};
   const errno = mysqlErrorErrno({ error });
@@ -65,7 +113,7 @@ function mapMysqlDriverError(params) {
   if (reason !== undefined)
     meta.reason = reason;
   const message = readStringField({ source, key: "message" }) ?? (sqlMessage !== undefined ? sqlMessage.trim() : undefined) ?? (typeof error === "string" ? error : "unknown mysql driver error");
-  return new VibeError({ code, message, meta, cause: error });
+  return new VibeError2({ code, message, meta, cause: error });
 }
 async function runMapped(fn) {
   try {
@@ -75,6 +123,131 @@ async function runMapped(fn) {
   }
 }
 
+// packages/adapter-mysql/src/placeholders.ts
+import { VibeError as VibeError3 } from "@vibeorm/schema";
+var ROW_COUNT_HINT = /\b(?:limit|offset)\b/i;
+function isIdentChar(char) {
+  return char !== undefined && /[A-Za-z0-9_$]/.test(char);
+}
+function skipQuoted(text, start, quote) {
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === quote) {
+      if (text[index + 1] === quote) {
+        index += 2;
+        continue;
+      }
+      return index + 1;
+    }
+    index += 1;
+  }
+  return text.length;
+}
+function skipLineComment(text, start) {
+  const newline = text.indexOf(`
+`, start);
+  return newline === -1 ? text.length : newline + 1;
+}
+function skipBlockComment(text, start) {
+  const close = text.indexOf("*/", start + 2);
+  return close === -1 ? text.length : close + 2;
+}
+function scanPlaceholders(params) {
+  const { text } = params;
+  const rowCountPositions = new Set;
+  let count = 0;
+  let inRowCount = false;
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "'" || char === '"' || char === "`") {
+      index = skipQuoted(text, index, char);
+      inRowCount = false;
+      continue;
+    }
+    if (char === "-" && text[index + 1] === "-" && (text[index + 2] === undefined || /\s/.test(text[index + 2]))) {
+      index = skipLineComment(text, index);
+      continue;
+    }
+    if (char === "#") {
+      index = skipLineComment(text, index);
+      continue;
+    }
+    if (char === "/" && text[index + 1] === "*") {
+      index = skipBlockComment(text, index);
+      continue;
+    }
+    if (char === "?") {
+      if (inRowCount)
+        rowCountPositions.add(count);
+      count += 1;
+      index += 1;
+      continue;
+    }
+    if (/\s/.test(char) || char === ",") {
+      index += 1;
+      continue;
+    }
+    if (/[0-9]/.test(char)) {
+      while (index < text.length && /[0-9]/.test(text[index]))
+        index += 1;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(char)) {
+      const start = index;
+      while (isIdentChar(text[index]))
+        index += 1;
+      const word = text.slice(start, index).toUpperCase();
+      inRowCount = word === "LIMIT" || word === "OFFSET";
+      continue;
+    }
+    inRowCount = false;
+    index += 1;
+  }
+  return { count, rowCountPositions };
+}
+function toRowCount(params) {
+  const { value, ordinal, text } = params;
+  const refuse = (reason) => {
+    throw new VibeError3({
+      code: "VIBE_VALIDATION",
+      message: `parameter $${ordinal} sits in a LIMIT/OFFSET position and ${reason} \u2014 ` + "a row count must be a non-negative integer",
+      meta: { placeholder: ordinal, value: String(value), text }
+    });
+  };
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value))
+      return refuse("is not a safe integer");
+    if (value < 0)
+      return refuse("is negative");
+    return String(value);
+  }
+  if (typeof value === "bigint") {
+    if (value < 0n)
+      return refuse("is negative");
+    return value.toString();
+  }
+  return value;
+}
+function bindRowCountParams(params) {
+  const { text, values } = params;
+  if (values.length === 0)
+    return values;
+  if (!values.some((value) => typeof value === "number" || typeof value === "bigint"))
+    return values;
+  if (!ROW_COUNT_HINT.test(text))
+    return values;
+  const scanned = scanPlaceholders({ text });
+  if (scanned.rowCountPositions.size === 0 || scanned.count !== values.length)
+    return values;
+  return values.map((value, index) => scanned.rowCountPositions.has(index) ? toRowCount({ value, ordinal: index + 1, text }) : value);
+}
+
 // packages/adapter-mysql/src/results.ts
 function isResultSetHeader(params) {
   const { value } = params;
@@ -104,6 +277,128 @@ function normalizeDriverResult(params) {
   return normalizeSingle(result);
 }
 
+// packages/adapter-mysql/src/transaction-budget.ts
+import { VibeError as VibeError4 } from "@vibeorm/schema";
+var DEFAULT_DEADLINE_CLOCK = () => Date.now();
+function validateTransactionDeadline(params) {
+  const { options, support, provider } = params;
+  const deadline = options?.deadline;
+  if (deadline === undefined)
+    return;
+  if (support === "unsupported") {
+    throw new VibeError4({
+      code: "VIBE_UNSUPPORTED_CAPABILITY",
+      message: `${provider} cannot enforce a transaction deadline \u2014 remove the \`deadline\` option`,
+      meta: { provider, feature: "transactionDeadline", supported: support }
+    });
+  }
+  if (!Number.isInteger(deadline.totalMs) || deadline.totalMs <= 0) {
+    throw new VibeError4({
+      code: "VIBE_VALIDATION",
+      message: `transaction deadline \`totalMs\` must be a positive integer of milliseconds, received ${String(deadline.totalMs)}`,
+      meta: { provider, feature: "transactionDeadline", totalMs: deadline.totalMs }
+    });
+  }
+  const requested = deadline.enforcement ?? "between-statements";
+  if (requested === "cancel-running-statements" && support !== "cancel-running-statements") {
+    throw new VibeError4({
+      code: "VIBE_UNSUPPORTED_CAPABILITY",
+      message: `${provider} cannot cancel a statement that is already running, so the requested ` + "`cancel-running-statements` deadline guarantee is refused rather than silently downgraded \u2014 " + 'ask for "between-statements" if a budget checked between statements is enough',
+      meta: { provider, feature: "transactionDeadline", requested, supported: support }
+    });
+  }
+}
+function startTransactionBudget(params) {
+  const { options, provider } = params;
+  const clock = params.clock ?? DEFAULT_DEADLINE_CLOCK;
+  const deadline = options?.deadline;
+  const totalMs = deadline === undefined ? null : deadline.totalMs;
+  const enforcement = deadline === undefined ? null : deadline.enforcement ?? "between-statements";
+  const expiresAt = totalMs === null ? null : clock() + totalMs;
+  let outcome = null;
+  const budget = {
+    enforcement,
+    totalMs,
+    statementTimeoutMs: options?.timeout ?? null,
+    remainingMs() {
+      return expiresAt === null ? null : Math.max(0, expiresAt - clock());
+    },
+    expired() {
+      return expiresAt !== null && clock() >= expiresAt;
+    },
+    assertUsable(assertParams) {
+      if (outcome !== null) {
+        throw transactionClosedError({ provider, outcome, stage: assertParams.stage });
+      }
+      if (expiresAt !== null && clock() >= expiresAt) {
+        throw transactionDeadlineError({
+          provider,
+          stage: assertParams.stage,
+          totalMs,
+          overdueMs: clock() - expiresAt
+        });
+      }
+    },
+    close(closeParams) {
+      if (outcome === null)
+        outcome = closeParams.outcome;
+    },
+    get outcome() {
+      return outcome;
+    }
+  };
+  return budget;
+}
+function engineStatementBudgetMs(params) {
+  const { budget } = params;
+  if (budget.enforcement !== "cancel-running-statements")
+    return null;
+  const remaining = budget.remainingMs();
+  if (remaining === null)
+    return null;
+  const totalBound = Math.max(1, Math.ceil(remaining));
+  return budget.statementTimeoutMs !== null && budget.statementTimeoutMs > 0 ? Math.min(totalBound, budget.statementTimeoutMs) : totalBound;
+}
+function transactionDeadlineError(params) {
+  const { provider, stage, totalMs, overdueMs } = params;
+  const what = stage === "commit" ? "the transaction was rolled back instead of committed" : "the statement was never sent and the transaction is being rolled back";
+  return new VibeError4({
+    code: "VIBE_TRANSACTION",
+    message: `transaction deadline of ${totalMs} ms expired ${Math.max(0, Math.round(overdueMs))} ms ago \u2014 ${what}. ` + "Nothing is retried automatically: work the callback did outside the database may already have happened.",
+    meta: { provider, reason: "transaction-deadline", stage, totalMs, overdueMs: Math.max(0, Math.round(overdueMs)) }
+  });
+}
+function transactionClosedError(params) {
+  const { provider, outcome, stage } = params;
+  return new VibeError4({
+    code: "VIBE_TRANSACTION",
+    message: `this transaction has already finished (${outcome}), so its client can no longer be used \u2014 ` + "a handle kept past the end of `$transaction` would run outside the transaction, on a connection " + "that now belongs to someone else",
+    meta: { provider, reason: "transaction-closed", outcome, stage }
+  });
+}
+function transactionOutcomeUnknownError(params) {
+  const { provider, totalMs, cause } = params;
+  return new VibeError4({
+    code: "VIBE_TRANSACTION",
+    message: `transaction deadline of ${totalMs} ms expired and the rollback that should have cleaned up failed \u2014 ` + "the commit state of this transaction is UNKNOWN. It is not retried automatically; inspect the data " + "before deciding.",
+    meta: {
+      provider,
+      reason: "transaction-outcome-unknown",
+      outcome: "unknown",
+      totalMs,
+      rollbackFailed: true
+    },
+    cause
+  });
+}
+function isTransactionDeadlineError(error) {
+  const reason = error?.meta?.reason;
+  return reason === "transaction-deadline";
+}
+
+// packages/adapter-mysql/src/savepoint-gate.ts
+import { AsyncLocalStorage } from "async_hooks";
+
 // packages/adapter-mysql/src/savepoints.ts
 function createSavepointCounter() {
   return { n: 0 };
@@ -112,8 +407,111 @@ function nextSavepointName(params) {
   return `vibeorm_sp_${params.counter.n++}`;
 }
 
+// packages/adapter-mysql/src/savepoint-gate.ts
+var CURRENT = new AsyncLocalStorage;
+function createSavepointScope() {
+  return { depth: 0, state: { counter: createSavepointCounter(), open: null } };
+}
+function runRootScope(params) {
+  return CURRENT.run(params.scope, params.body);
+}
+function scopeTurn(params) {
+  const open = params.scope.state.open;
+  if (mayProceed({ scope: params.scope, open }))
+    return;
+  return waitForTurn({ scope: params.scope });
+}
+async function runNestedSavepoint(params) {
+  const { scope, execute, body } = params;
+  const node = await acquire({ scope });
+  try {
+    if (execute !== undefined)
+      await execute(`SAVEPOINT ${node.name}`);
+    let result;
+    try {
+      result = await CURRENT.run(node.scope, () => body(node.scope));
+    } catch (error) {
+      await drainDescendants({ node });
+      if (execute !== undefined) {
+        try {
+          await execute(`ROLLBACK TO SAVEPOINT ${node.name}`);
+        } catch {}
+      }
+      throw error;
+    }
+    await drainDescendants({ node });
+    if (execute !== undefined)
+      await execute(`RELEASE SAVEPOINT ${node.name}`);
+    return result;
+  } finally {
+    closeNode({ node });
+  }
+}
+function mayProceed(params) {
+  const { scope, open } = params;
+  if (open === null)
+    return true;
+  if (open.scope === scope)
+    return true;
+  if (open.scope.depth < scope.depth)
+    return true;
+  return CURRENT.getStore() === open.scope;
+}
+async function waitForTurn(params) {
+  for (;; ) {
+    const open = params.scope.state.open;
+    if (open === null || mayProceed({ scope: params.scope, open }))
+      return;
+    await open.settled;
+  }
+}
+async function acquire(params) {
+  const { scope } = params;
+  for (;; ) {
+    const open = scope.state.open;
+    if (mayProceed({ scope, open }))
+      return pushNode({ scope, parent: open });
+    await open.settled;
+  }
+}
+function pushNode(params) {
+  const { scope, parent } = params;
+  const state = scope.state;
+  let settle = () => {
+    return;
+  };
+  const settled = new Promise((resolve) => {
+    settle = () => resolve();
+  });
+  const node = {
+    scope: { depth: (parent === null ? 0 : parent.scope.depth) + 1, state },
+    name: nextSavepointName({ counter: state.counter }),
+    parent,
+    settled,
+    settle
+  };
+  state.open = node;
+  return node;
+}
+function closeNode(params) {
+  const { node } = params;
+  const state = node.scope.state;
+  if (state.open === node)
+    state.open = node.parent;
+  node.settle();
+}
+async function drainDescendants(params) {
+  const state = params.node.scope.state;
+  for (;; ) {
+    const open = state.open;
+    if (open === null || open === params.node || open.scope.depth <= params.node.scope.depth)
+      return;
+    await open.settled;
+  }
+}
+
 // packages/adapter-mysql/src/transaction-sql.ts
-import { VibeError as VibeError2 } from "@vibeorm/schema";
+import { VibeError as VibeError5 } from "@vibeorm/schema";
 var ISOLATION_LEVEL_SQL = Object.freeze({
   ReadCommitted: "READ COMMITTED",
   RepeatableRead: "REPEATABLE READ",
@@ -125,7 +523,7 @@ function setIsolationLevelStatement(params) {
 function maxExecutionTimeStatement(params) {
   const { timeout } = params;
   if (!Number.isInteger(timeout) || timeout < 0) {
-    throw new VibeError2({
+    throw new VibeError5({
       code: "VIBE_VALIDATION",
       message: `transaction timeout must be a non-negative integer of milliseconds, received ${String(timeout)}`,
       meta: { timeout }
@@ -152,6 +550,8 @@ function refuseNestedTransactionOptions(params) {
     passed.push("isolationLevel");
   if (options.timeout !== undefined)
     passed.push("timeout");
+  if (options.deadline !== undefined)
+    passed.push("deadline");
   if (passed.length === 0)
     return;
   const meta = { provider, nested: true };
@@ -159,9 +559,11 @@ function refuseNestedTransactionOptions(params) {
     meta.isolationLevel = options.isolationLevel;
   if (options.timeout !== undefined)
     meta.timeout = options.timeout;
-  throw new VibeError2({
+  if (options.deadline !== undefined)
+    meta.deadline = options.deadline;
+  throw new VibeError5({
     code: "VIBE_VALIDATION",
-    message: `nested transactions run as savepoints and cannot honor ${passed.join(" or ")} \u2014 a savepoint cannot change the isolation level of the transaction it joins, and a nested timeout is not enforceable; pass options on the top-level $transaction`,
+    message: `nested transactions run as savepoints and cannot honor ${passed.join(" or ")} \u2014 a savepoint cannot change the isolation level of the transaction it joins, a nested timeout is not enforceable, and a nested deadline would need its own session setting on a connection it does not own (it inherits the top-level one instead); pass options on the top-level $transaction`,
     meta
   });
 }
@@ -170,6 +572,11 @@ function refuseNestedTransactionOptions(params) {
 var DIALECT = "mysql";
 var PROVIDER = "mysql";
 var WIRE = Object.freeze({ dateTime: "native", json: "parsed", numbers: "native" });
+var BUDGETS = Object.freeze({
+  acquireTimeout: true,
+  statementTimeout: "select-only",
+  transactionDeadline: "between-statements"
+});
 function defaultCreatePool(config) {
   return mysql2CreatePool(config);
 }
@@ -183,6 +590,8 @@ function mysqlAdapter(options) {
   let pool = null;
   let ownsPool = false;
   let rawSession = null;
+  const acquireTimeoutMs = options?.acquireTimeout;
+  const poolSize = options?.pool === undefined ? options?.connectionLimit ?? MYSQL_DEFAULT_CONNECTION_LIMIT : undefined;
   function getPool() {
     if (pool !== null)
       return pool;
@@ -213,40 +622,62 @@ function mysqlAdapter(options) {
     ownsPool = true;
     return pool;
   }
+  async function acquireConnection() {
+    const active = getPool();
+    if (acquireTimeoutMs === undefined) {
+      return runMapped(() => active.getConnection());
+    }
+    return runMapped(() => acquireWithTimeout({ pool: active, timeoutMs: acquireTimeoutMs, poolSize }));
+  }
   async function runExecute(params) {
     const [result] = await runMapped(() => params.queryable.execute(params.text, params.values));
     return normalizeDriverResult({ result }).rows;
   }
+  async function runExecuteAffected(params) {
+    const values = bindRowCountParams({ text: params.text, values: params.values });
+    const [result] = await runMapped(() => params.queryable.execute(params.text, values));
+    return normalizeDriverResult({ result });
+  }
   async function runExecuteUnsafe(params) {
     const [result] = await runMapped(() => params.queryable.query(params.text, params.values));
     return normalizeDriverResult({ result });
   }
   function createConnectionAdapter(params) {
-    const { conn, savepointCounter } = params;
+    const { conn, scope, budget } = params;
     return {
       dialect: DIALECT,
       provider: PROVIDER,
       wire: WIRE,
+      budgets: BUDGETS,
       async execute(execParams) {
+        const turn = scopeTurn({ scope });
+        if (turn !== undefined)
+          await turn;
+        budget.assertUsable({ stage: "statement" });
         return runExecute({ queryable: conn, ...execParams });
       },
       async executeUnsafe(execParams) {
+        const turn = scopeTurn({ scope });
+        if (turn !== undefined)
+          await turn;
+        budget.assertUsable({ stage: "statement" });
         return runExecuteUnsafe({ queryable: conn, ...execParams });
       },
+      async executeAffected(execParams) {
+        const turn = scopeTurn({ scope });
+        if (turn !== undefined)
+          await turn;
+        budget.assertUsable({ stage: "statement" });
+        return runExecuteAffected({ queryable: conn, ...execParams });
+      },
       async transaction(fn, nestedOptions) {
         refuseNestedTransactionOptions({ options: nestedOptions, provider: PROVIDER });
-        const savepoint = nextSavepointName({ counter: savepointCounter });
-        await runMapped(() => conn.query(`SAVEPOINT ${savepoint}`));
-        try {
-          const result = await fn(createConnectionAdapter({ conn, savepointCounter }));
-          await runMapped(() => conn.query(`RELEASE SAVEPOINT ${savepoint}`));
-          return result;
-        } catch (error) {
-          try {
-            await conn.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
-          } catch {}
-          throw error;
-        }
+        budget.assertUsable({ stage: "nested" });
+        return runNestedSavepoint({
+          scope,
+          execute: (statement) => runMapped(() => conn.query(statement)),
+          body: (child) => fn(createConnectionAdapter({ conn, scope: child, budget }))
+        });
       },
       async connect() {},
       async disconnect() {},
@@ -259,8 +690,28 @@ function mysqlAdapter(options) {
     dialect: DIALECT,
     provider: PROVIDER,
     wire: WIRE,
+    budgets: BUDGETS,
     async execute(params) {
-      return runExecute({ queryable: getPool(), ...params });
+      if (acquireTimeoutMs === undefined) {
+        return runExecute({ queryable: getPool(), ...params });
+      }
+      const conn = await acquireConnection();
+      try {
+        return await runExecute({ queryable: conn, ...params });
+      } finally {
+        conn.release();
+      }
+    },
+    async executeAffected(params) {
+      if (acquireTimeoutMs === undefined) {
+        return runExecuteAffected({ queryable: getPool(), ...params });
+      }
+      const conn = await acquireConnection();
+      try {
+        return await runExecuteAffected({ queryable: conn, ...params });
+      } finally {
+        conn.release();
+      }
     },
     async executeUnsafe(params) {
       const control = classifyRawTransactionControl({ text: params.text });
@@ -277,21 +728,36 @@ function mysqlAdapter(options) {
         return runExecuteUnsafe({ queryable: rawSession, ...params });
       }
       if (control === "open") {
-        const conn = await runMapped(() => getPool().getConnection());
+        const conn2 = await acquireConnection();
         try {
-          const result = await runExecuteUnsafe({ queryable: conn, ...params });
-          rawSession = conn;
+          const result = await runExecuteUnsafe({ queryable: conn2, ...params });
+          rawSession = conn2;
           return result;
         } catch (error) {
-          conn.release();
+          conn2.release();
           throw error;
         }
       }
-      return runExecuteUnsafe({ queryable: getPool(), ...params });
+      if (acquireTimeoutMs === undefined) {
+        return runExecuteUnsafe({ queryable: getPool(), ...params });
+      }
+      const conn = await acquireConnection();
+      try {
+        return await runExecuteUnsafe({ queryable: conn, ...params });
+      } finally {
+        conn.release();
+      }
     },
     async transaction(fn, transactionOptions) {
       const timeoutText = transactionOptions?.timeout === undefined ? undefined : maxExecutionTimeStatement({ timeout: transactionOptions.timeout });
-      const conn = await runMapped(() => getPool().getConnection());
+      validateTransactionDeadline({
+        options: transactionOptions,
+        support: BUDGETS.transactionDeadline,
+        provider: PROVIDER
+      });
+      const conn = await acquireConnection();
+      let rollbackFailed = false;
+      const budget = startTransactionBudget({ options: transactionOptions, provider: PROVIDER });
       try {
         if (timeoutText !== undefined) {
           await runMapped(() => conn.query(timeoutText));
@@ -302,19 +768,36 @@ function mysqlAdapter(options) {
           await runMapped(() => conn.query(isolationText));
         }
         await runMapped(() => conn.beginTransaction());
+        const scope = createSavepointScope();
         try {
-          const result = await fn(createConnectionAdapter({ conn, savepointCounter: createSavepointCounter() }));
+          const result = await runRootScope({
+            scope,
+            body: () => fn(createConnectionAdapter({ conn, scope, budget }))
+          });
+          budget.assertUsable({ stage: "commit" });
           await runMapped(() => conn.commit());
+          budget.close({ outcome: "committed" });
           return result;
         } catch (error) {
           try {
             await conn.rollback();
-          } catch {}
+            budget.close({ outcome: "rolled-back" });
+          } catch {
+            rollbackFailed = true;
+            budget.close({ outcome: "unknown" });
+            if (budget.totalMs !== null && isTransactionDeadlineError(error)) {
+              throw transactionOutcomeUnknownError({
+                provider: PROVIDER,
+                totalMs: budget.totalMs,
+                cause: error
+              });
+            }
+          }
           throw error;
         }
       } finally {
-        let poisoned = false;
-        if (timeoutText !== undefined) {
+        let poisoned = rollbackFailed;
+        if (timeoutText !== undefined && !poisoned) {
           try {
             await conn.query(RESET_MAX_EXECUTION_TIME_SQL);
           } catch {
@@ -329,7 +812,7 @@ function mysqlAdapter(options) {
       }
     },
     async connect() {
-      const conn = await runMapped(() => getPool().getConnection());
+      const conn = await acquireConnection();
       try {
         await runMapped(() => conn.ping());
       } finally {
@@ -357,6 +840,11 @@ function mysqlAdapter(options) {
   };
 }
 export {
+  validateTransactionDeadline,
+  transactionOutcomeUnknownError,
+  transactionDeadlineError,
+  transactionClosedError,
+  startTransactionBudget,
   setIsolationLevelStatement,
   runMapped,
   refuseNestedTransactionOptions,
@@ -366,13 +854,20 @@ export {
   mysqlAdapter,
   maxExecutionTimeStatement,
   mapMysqlDriverError,
+  isTransactionDeadlineError,
   isResultSetHeader,
+  engineStatementBudgetMs,
   createSavepointCounter,
   classifyRawTransactionControl,
+  acquireWithTimeout,
+  acquireTimeoutError,
   RESET_MAX_EXECUTION_TIME_SQL,
   MYSQL_ERRNO_REASONS,
   MYSQL_ERRNO_ERROR_CODES,
-  ISOLATION_LEVEL_SQL
+  MYSQL_DEFAULT_CONNECTION_LIMIT,
+  ISOLATION_LEVEL_SQL,
+  DEFAULT_DEADLINE_CLOCK,
+  DEFAULT_ACQUIRE_TIMERS
 };
 
-//# debugId=81C757629DAE03DB64756E2164756E21
+//# debugId=C68F0F22780DCB5D64756E2164756E21