@vibeorm/adapter-bun 1.3.0 → 2.0.0-alpha.10

package/dist/index.js

@@ -0,0 +1,909 @@
+// @bun
+// packages/adapter-bun/src/index.ts
+var {SQL } = globalThis.Bun;
+import { postgresDialect, renderDiagnostic } from "@vibeorm/sql";
+
+// packages/adapter-bun/src/connection-url.ts
+import { VibeError } from "@vibeorm/schema";
+function buildStartupOptions(params) {
+  const { planCacheMode, statementTimeout } = params;
+  const parts = [];
+  if (planCacheMode !== "auto")
+    parts.push(`-c plan_cache_mode=${planCacheMode}`);
+  if (statementTimeout !== undefined) {
+    if (!Number.isInteger(statementTimeout) || statementTimeout < 0) {
+      throw new VibeError({
+        code: "VIBE_VALIDATION",
+        message: `statementTimeout must be a non-negative integer of milliseconds, received ${String(statementTimeout)}`,
+        meta: { statementTimeout }
+      });
+    }
+    parts.push(`-c statement_timeout=${statementTimeout}`);
+  }
+  return parts.length === 0 ? undefined : parts.join(" ");
+}
+function applyStartupOptions(params) {
+  const { url, startupOptions } = params;
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}options=${encodeURIComponent(startupOptions)}`;
+}
+
+// packages/adapter-bun/src/errors.ts
+import { VibeError as VibeError2 } from "@vibeorm/schema";
+var BUN_SQLSTATE_ERROR_CODES = Object.freeze({
+  "23505": "VIBE_UNIQUE_VIOLATION",
+  "23503": "VIBE_FK_VIOLATION",
+  "23502": "VIBE_VALIDATION",
+  "23514": "VIBE_VALIDATION",
+  "22P02": "VIBE_VALIDATION",
+  "42501": "VIBE_PERMISSION_DENIED",
+  "40001": "VIBE_TRANSACTION",
+  "40P01": "VIBE_TRANSACTION",
+  "57014": "VIBE_TRANSACTION"
+});
+var BUN_SQLSTATE_REASONS = Object.freeze({
+  "57014": "timeout"
+});
+var SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;
+function readStringField(params) {
+  const value = params.source[params.key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function bunErrorSqlstate(params) {
+  const { error } = params;
+  if (error === null || typeof error !== "object")
+    return;
+  const source = error;
+  for (const key of ["code", "errno"]) {
+    const value = readStringField({ source, key });
+    if (value !== undefined && SQLSTATE_PATTERN.test(value))
+      return value;
+  }
+  return;
+}
+function mapBunDriverError(params) {
+  const { error } = params;
+  if (error instanceof VibeError2)
+    return error;
+  const source = error !== null && typeof error === "object" ? error : {};
+  const sqlstate = bunErrorSqlstate({ error });
+  const code = (sqlstate === undefined ? undefined : BUN_SQLSTATE_ERROR_CODES[sqlstate]) ?? "VIBE_ADAPTER";
+  const meta = {};
+  if (sqlstate !== undefined)
+    meta.sqlstate = sqlstate;
+  const constraint = readStringField({ source, key: "constraint" });
+  if (constraint !== undefined)
+    meta.constraint = constraint;
+  const table = readStringField({ source, key: "table" });
+  if (table !== undefined)
+    meta.table = table;
+  const column = readStringField({ source, key: "column" });
+  if (column !== undefined)
+    meta.column = column;
+  const reason = sqlstate === undefined ? undefined : BUN_SQLSTATE_REASONS[sqlstate];
+  if (reason !== undefined)
+    meta.reason = reason;
+  const driverCode = readStringField({ source, key: "code" });
+  if (driverCode !== undefined && driverCode !== sqlstate)
+    meta.driverCode = driverCode;
+  const message = readStringField({ source, key: "message" }) ?? (typeof error === "string" ? error : "unknown bun:sql driver error");
+  return new VibeError2({ code, message, meta, cause: error });
+}
+async function runMapped(fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw mapBunDriverError({ error });
+  }
+}
+
+// packages/adapter-bun/src/params.ts
+import { VibeError as VibeError3 } from "@vibeorm/schema";
+function quoteElement(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function toPgArrayLiteral(values) {
+  const elements = values.map((value) => {
+    if (value === null || value === undefined)
+      return "NULL";
+    if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
+      return String(value);
+    }
+    if (value instanceof Date)
+      return quoteElement(value.toISOString());
+    if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+      throw new VibeError3({
+        code: "VIBE_VALIDATION",
+        message: "binary values are not supported inside a postgres array literal",
+        meta: { driver: "bun:sql" }
+      });
+    }
+    if (typeof value === "string")
+      return quoteElement(value);
+    if (typeof value === "object")
+      return quoteElement(JSON.stringify(value));
+    return quoteElement(String(value));
+  });
+  return `{${elements.join(",")}}`;
+}
+function serializeParams(params) {
+  return params.values.slice();
+}
+function serializeParamsRaw(params) {
+  return params.values.map((value) => Array.isArray(value) ? toPgArrayLiteral(value) : value);
+}
+
+// packages/adapter-bun/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-bun/src/savepoint-gate.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// packages/adapter-bun/src/savepoints.ts
+function createSavepointCounter() {
+  return { n: 0 };
+}
+function nextSavepointName(params) {
+  return `vibeorm_sp_${params.counter.n++}`;
+}
+
+// packages/adapter-bun/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-bun/src/template-cache.ts
+import { VibeError as VibeError5 } from "@vibeorm/schema";
+function isIdentChar(char) {
+  if (char === undefined)
+    return false;
+  return /[A-Za-z0-9_]/.test(char);
+}
+function skipQuoted(text, start, quote) {
+  const escaping = quote === "'" && (text[start - 1] === "e" || text[start - 1] === "E") && !isIdentChar(text[start - 2]);
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (escaping && char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === quote) {
+      if (text[index + 1] === quote) {
+        index += 2;
+        continue;
+      }
+      return index + 1;
+    }
+    index += 1;
+  }
+  return text.length;
+}
+function skipBlockComment(text, start) {
+  let depth = 0;
+  let index = start;
+  while (index < text.length) {
+    if (text[index] === "/" && text[index + 1] === "*") {
+      depth += 1;
+      index += 2;
+      continue;
+    }
+    if (text[index] === "*" && text[index + 1] === "/") {
+      depth -= 1;
+      index += 2;
+      if (depth === 0)
+        return index;
+      continue;
+    }
+    index += 1;
+  }
+  return text.length;
+}
+function skipDollarQuoted(text, start) {
+  const opener = /^\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/.exec(text.slice(start));
+  if (opener === null)
+    return -1;
+  const tag = opener[0];
+  const close = text.indexOf(tag, start + tag.length);
+  return close === -1 ? text.length : close + tag.length;
+}
+function scanPlaceholders(params) {
+  const { text } = params;
+  const chunks = [];
+  const indices = [];
+  let chunkStart = 0;
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "'" || char === '"') {
+      index = skipQuoted(text, index, char);
+      continue;
+    }
+    if (char === "-" && text[index + 1] === "-") {
+      const newline = text.indexOf(`
+`, index);
+      index = newline === -1 ? text.length : newline + 1;
+      continue;
+    }
+    if (char === "/" && text[index + 1] === "*") {
+      index = skipBlockComment(text, index);
+      continue;
+    }
+    if (char === "$") {
+      const dollarEnd = skipDollarQuoted(text, index);
+      if (dollarEnd !== -1) {
+        index = dollarEnd;
+        continue;
+      }
+      let digits = index + 1;
+      while (digits < text.length && text[digits] !== undefined && /[0-9]/.test(text[digits]))
+        digits += 1;
+      if (digits > index + 1) {
+        chunks.push(text.slice(chunkStart, index));
+        indices.push(Number(text.slice(index + 1, digits)));
+        chunkStart = digits;
+        index = digits;
+        continue;
+      }
+    }
+    index += 1;
+  }
+  chunks.push(text.slice(chunkStart));
+  const template = Object.assign(chunks, { raw: chunks });
+  return { template, indices };
+}
+function templateChunks(params) {
+  return [...scanPlaceholders(params).template];
+}
+function bindTemplateValues(params) {
+  const { text, indices, values } = params;
+  return indices.map((placeholder) => {
+    if (placeholder < 1 || placeholder > values.length) {
+      throw new VibeError5({
+        code: "VIBE_VALIDATION",
+        message: `bun:sql prepared statement references $${placeholder} but only ${values.length} parameter(s) were given`,
+        meta: { text, placeholder, provided: values.length }
+      });
+    }
+    return values[placeholder - 1];
+  });
+}
+function createTemplateCache(params) {
+  const { max } = params;
+  const templates = new Map;
+  return {
+    getTemplate(templateParams) {
+      const { text } = templateParams;
+      const existing = templates.get(text);
+      if (existing !== undefined) {
+        templates.delete(text);
+        templates.set(text, existing);
+        return existing;
+      }
+      const prepared = scanPlaceholders({ text });
+      if (templates.size >= max) {
+        const oldest = templates.keys().next().value;
+        if (oldest !== undefined)
+          templates.delete(oldest);
+      }
+      templates.set(text, prepared);
+      return prepared;
+    },
+    size() {
+      return templates.size;
+    }
+  };
+}
+
+// packages/adapter-bun/src/transaction-sql.ts
+import { VibeError as VibeError6 } from "@vibeorm/schema";
+var ISOLATION_LEVEL_SQL = Object.freeze({
+  ReadCommitted: "READ COMMITTED",
+  RepeatableRead: "REPEATABLE READ",
+  Serializable: "SERIALIZABLE"
+});
+function beginStatement(params) {
+  const { isolationLevel } = params;
+  return isolationLevel === undefined ? "BEGIN" : `BEGIN ISOLATION LEVEL ${ISOLATION_LEVEL_SQL[isolationLevel]}`;
+}
+function statementTimeoutStatement(params) {
+  const { timeout } = params;
+  if (!Number.isInteger(timeout) || timeout < 0) {
+    throw new VibeError6({
+      code: "VIBE_VALIDATION",
+      message: `transaction timeout must be a non-negative integer of milliseconds, received ${String(timeout)}`,
+      meta: { timeout }
+    });
+  }
+  return `SET LOCAL statement_timeout = ${timeout}`;
+}
+var RAW_OPEN_PATTERN = /^\s*(?:begin|start\s+transaction)\b[^;]*;?\s*$/i;
+var RAW_CLOSE_PATTERN = /^\s*(?:commit|end|rollback|abort)(?:\s+(?:transaction|work))?\s*;?\s*$/i;
+function classifyRawTransactionControl(params) {
+  if (RAW_OPEN_PATTERN.test(params.text))
+    return "open";
+  if (RAW_CLOSE_PATTERN.test(params.text))
+    return "close";
+  return null;
+}
+function refuseNestedTransactionOptions(params) {
+  const { options, provider } = params;
+  if (options === undefined)
+    return;
+  const passed = [];
+  if (options.isolationLevel !== undefined)
+    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 };
+  if (options.isolationLevel !== undefined)
+    meta.isolationLevel = options.isolationLevel;
+  if (options.timeout !== undefined)
+    meta.timeout = options.timeout;
+  if (options.deadline !== undefined)
+    meta.deadline = options.deadline;
+  throw new VibeError6({
+    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, 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
+  });
+}
+
+// packages/adapter-bun/src/index.ts
+class CallbackError extends Error {
+  inner;
+  constructor(inner) {
+    super("vibeorm: transaction callback failed");
+    this.name = "CallbackError";
+    this.inner = inner;
+  }
+}
+var DIALECT = "postgres";
+var PROVIDER = "postgresql";
+var BUDGETS = Object.freeze({
+  acquireTimeout: true,
+  statementTimeout: "all-statements",
+  transactionDeadline: "cancel-running-statements"
+});
+var WIRE_TEXT = Object.freeze({ dateTime: "native", json: "text", numbers: "native" });
+var WIRE_PARSED = Object.freeze({ dateTime: "native", json: "parsed", numbers: "native" });
+function bunAdapter(options) {
+  const usePrepared = options?.preparedStatements ?? false;
+  const templates = createTemplateCache({ max: options?.stmtCacheMax ?? 1000 });
+  let activeWire = WIRE_TEXT;
+  let wireSettled = false;
+  let wireProbe = null;
+  let instance = null;
+  let rawSession = null;
+  function getSql() {
+    if (instance !== null)
+      return instance;
+    const sqlOptions = { max: options?.max ?? 10 };
+    if (options?.connectionTimeout !== undefined) {
+      sqlOptions.connectionTimeout = Math.max(1, Math.ceil(options.connectionTimeout / 1000));
+    }
+    const startupOptions = buildStartupOptions({
+      planCacheMode: options?.planCacheMode ?? "force_custom_plan",
+      statementTimeout: options?.statementTimeout
+    });
+    const baseUrl = options?.url ?? process.env.DATABASE_URL;
+    const url = baseUrl === undefined || startupOptions === undefined ? baseUrl : applyStartupOptions({ url: baseUrl, startupOptions });
+    instance = url === undefined ? new SQL(sqlOptions) : new SQL(url, sqlOptions);
+    return instance;
+  }
+  async function probeJsonWire(source) {
+    const probe = renderDiagnostic({ dialect: postgresDialect, query: "postgresJsonWire" });
+    try {
+      const rows = usePrepared ? await source(templates.getTemplate({ text: probe.text }).template) : await source.unsafe(probe.text, []);
+      const probed = rows[0]?.probe;
+      if (typeof probed === "object" && probed !== null)
+        activeWire = WIRE_PARSED;
+    } catch {} finally {
+      wireSettled = true;
+    }
+  }
+  async function runExecute(params) {
+    if (!wireSettled) {
+      wireProbe ??= probeJsonWire(params.source);
+      await wireProbe;
+    }
+    const values = serializeParams({ values: params.values });
+    if (usePrepared) {
+      const prepared = templates.getTemplate({ text: params.text });
+      const bound = bindTemplateValues({ text: params.text, indices: prepared.indices, values });
+      return runMapped(() => params.source(prepared.template, ...bound));
+    }
+    return runMapped(() => params.source.unsafe(params.text, values));
+  }
+  async function runExecuteUnsafe(params) {
+    const values = params.values === undefined ? undefined : serializeParamsRaw({ values: params.values });
+    const rows = await runMapped(() => params.source.unsafe(params.text, values));
+    return { rows, affectedRows: readAffectedRows({ rows }) };
+  }
+  function createAdapter(params) {
+    const { source, parentMode, scope, budget } = params;
+    async function applyEngineBudget() {
+      if (budget === undefined)
+        return;
+      const ms = engineStatementBudgetMs({ budget });
+      if (ms === null)
+        return;
+      await runMapped(() => source.unsafe(statementTimeoutStatement({ timeout: ms })));
+    }
+    async function transactionViaSavepoint(fn, nestedOptions) {
+      refuseNestedTransactionOptions({ options: nestedOptions, provider: PROVIDER });
+      budget?.assertUsable({ stage: "nested" });
+      const transactional = source;
+      const driverSavepoint = transactional.savepoint?.bind(transactional);
+      if (driverSavepoint !== undefined) {
+        return runNestedSavepoint({
+          scope,
+          body: async (child) => {
+            try {
+              return await driverSavepoint(async (savepointSql) => {
+                const nested = createAdapter({
+                  source: savepointSql,
+                  parentMode: "tx",
+                  scope: child
+                });
+                try {
+                  return await fn(nested);
+                } catch (error) {
+                  throw new CallbackError(error);
+                }
+              });
+            } catch (error) {
+              if (error instanceof CallbackError)
+                throw error.inner;
+              throw mapBunDriverError({ error });
+            }
+          }
+        });
+      }
+      return runNestedSavepoint({
+        scope,
+        execute: (statement) => runMapped(() => transactional.unsafe(statement)),
+        body: (child) => fn(createAdapter({ source: transactional, parentMode: "tx", scope: child, budget }))
+      });
+    }
+    async function transactionViaPool(fn, transactionOptions) {
+      const pool = source;
+      validateTransactionDeadline({
+        options: transactionOptions,
+        support: BUDGETS.transactionDeadline,
+        provider: PROVIDER
+      });
+      if (transactionOptions?.isolationLevel === undefined && transactionOptions?.timeout === undefined && transactionOptions?.deadline === undefined) {
+        const budget3 = startTransactionBudget({ provider: PROVIDER });
+        try {
+          const result = await pool.begin(async (txSql) => {
+            const txScope = createSavepointScope();
+            const txAdapter = createAdapter({
+              source: txSql,
+              parentMode: "tx",
+              scope: txScope,
+              budget: budget3
+            });
+            try {
+              return await runRootScope({ scope: txScope, body: () => fn(txAdapter) });
+            } catch (error) {
+              throw new CallbackError(error);
+            }
+          });
+          budget3.close({ outcome: "committed" });
+          return result;
+        } catch (error) {
+          budget3.close({ outcome: "rolled-back" });
+          if (error instanceof CallbackError)
+            throw error.inner;
+          throw mapBunDriverError({ error });
+        }
+      }
+      const timeoutText = transactionOptions.timeout === undefined ? undefined : statementTimeoutStatement({ timeout: transactionOptions.timeout });
+      const reserved = await runMapped(() => pool.reserve());
+      const budget2 = startTransactionBudget({ options: transactionOptions, provider: PROVIDER });
+      try {
+        await runMapped(() => reserved.unsafe(beginStatement({ isolationLevel: transactionOptions.isolationLevel })));
+        if (timeoutText !== undefined)
+          await runMapped(() => reserved.unsafe(timeoutText));
+        const txScope = createSavepointScope();
+        const txAdapter = createAdapter({
+          source: reserved,
+          parentMode: "tx",
+          scope: txScope,
+          budget: budget2
+        });
+        const result = await runRootScope({ scope: txScope, body: () => fn(txAdapter) });
+        budget2.assertUsable({ stage: "commit" });
+        await runMapped(() => reserved.unsafe("COMMIT"));
+        budget2.close({ outcome: "committed" });
+        return result;
+      } catch (error) {
+        try {
+          await reserved.unsafe("ROLLBACK");
+          budget2.close({ outcome: "rolled-back" });
+        } catch {
+          budget2.close({ outcome: "unknown" });
+          if (budget2.totalMs !== null && isTransactionDeadlineError(error)) {
+            throw transactionOutcomeUnknownError({
+              provider: PROVIDER,
+              totalMs: budget2.totalMs,
+              cause: error
+            });
+          }
+        }
+        throw error;
+      } finally {
+        reserved.release();
+      }
+    }
+    return {
+      dialect: DIALECT,
+      provider: PROVIDER,
+      budgets: BUDGETS,
+      get wire() {
+        return activeWire;
+      },
+      async execute(execParams) {
+        const turn = scopeTurn({ scope });
+        if (turn !== undefined)
+          await turn;
+        budget?.assertUsable({ stage: "statement" });
+        await applyEngineBudget();
+        return runExecute({ source, ...execParams });
+      },
+      async executeUnsafe(execParams) {
+        const turn = scopeTurn({ scope });
+        if (turn !== undefined)
+          await turn;
+        budget?.assertUsable({ stage: "statement" });
+        await applyEngineBudget();
+        return runExecuteUnsafe({ source, ...execParams });
+      },
+      async transaction(fn, transactionOptions) {
+        return parentMode === "pool" ? transactionViaPool(fn, transactionOptions) : transactionViaSavepoint(fn, transactionOptions);
+      },
+      async connect() {
+        if (parentMode !== "pool")
+          return;
+        const reserved = await runMapped(() => source.reserve());
+        reserved.release();
+      },
+      async disconnect() {
+        if (parentMode !== "pool")
+          return;
+        await runMapped(() => source.close());
+        instance = null;
+      },
+      formatArrayParam(values) {
+        return toPgArrayLiteral(values);
+      }
+    };
+  }
+  function poolAdapter() {
+    return createAdapter({
+      source: getSql(),
+      parentMode: "pool",
+      scope: createSavepointScope()
+    });
+  }
+  return {
+    dialect: DIALECT,
+    provider: PROVIDER,
+    budgets: BUDGETS,
+    get wire() {
+      return activeWire;
+    },
+    async execute(params) {
+      return poolAdapter().execute(params);
+    },
+    async executeUnsafe(params) {
+      const control = classifyRawTransactionControl({ text: params.text });
+      if (rawSession !== null) {
+        if (control === "close") {
+          const session = rawSession;
+          rawSession = null;
+          try {
+            return await runExecuteUnsafe({ source: session, ...params });
+          } finally {
+            session.release();
+          }
+        }
+        return runExecuteUnsafe({ source: rawSession, ...params });
+      }
+      if (control === "open") {
+        const reserved = await runMapped(() => getSql().reserve());
+        try {
+          const result = await runExecuteUnsafe({ source: reserved, ...params });
+          rawSession = reserved;
+          return result;
+        } catch (error) {
+          reserved.release();
+          throw error;
+        }
+      }
+      return poolAdapter().executeUnsafe(params);
+    },
+    async transaction(fn, transactionOptions) {
+      return poolAdapter().transaction(fn, transactionOptions);
+    },
+    async connect() {
+      return poolAdapter().connect();
+    },
+    async disconnect() {
+      if (rawSession !== null) {
+        const session = rawSession;
+        rawSession = null;
+        try {
+          await session.unsafe("ROLLBACK");
+        } catch {}
+        session.release();
+      }
+      if (instance === null)
+        return;
+      const closing = instance;
+      instance = null;
+      await runMapped(() => closing.close());
+    },
+    formatArrayParam(values) {
+      return toPgArrayLiteral(values);
+    }
+  };
+}
+function readAffectedRows(params) {
+  const { rows } = params;
+  if (typeof rows.count === "number")
+    return rows.count;
+  if (typeof rows.affectedRows === "number")
+    return rows.affectedRows;
+  return rows.length;
+}
+export {
+  validateTransactionDeadline,
+  transactionOutcomeUnknownError,
+  transactionDeadlineError,
+  transactionClosedError,
+  toPgArrayLiteral,
+  templateChunks,
+  statementTimeoutStatement,
+  startTransactionBudget,
+  serializeParamsRaw,
+  serializeParams,
+  refuseNestedTransactionOptions,
+  nextSavepointName,
+  mapBunDriverError,
+  isTransactionDeadlineError,
+  engineStatementBudgetMs,
+  createTemplateCache,
+  createSavepointCounter,
+  classifyRawTransactionControl,
+  bunErrorSqlstate,
+  bunAdapter,
+  buildStartupOptions,
+  beginStatement,
+  applyStartupOptions,
+  ISOLATION_LEVEL_SQL,
+  DEFAULT_DEADLINE_CLOCK,
+  BUN_SQLSTATE_REASONS,
+  BUN_SQLSTATE_ERROR_CODES
+};
+
+//# debugId=81824F43B962EC8264756E2164756E21