@vibeorm/adapter-pg 2.4.1 → 4.0.0

package/dist/index.js

@@ -2,24 +2,181 @@
 // packages/adapter-pg/src/index.ts
 import {
   abortTransactionOnServerFailure,
+  createDeferredControl,
   observeRowChanges,
   readRowChanges,
   statementRowChanges,
+  createAdapterLifecycleGate,
   runPinnedSession,
+  runShutdownCleanup,
+  transactionLifecycleRefusal,
   createSavepointScope,
   engineStatementBudgetMs,
   isSavepointRollbackFailedError,
-  isTransactionDeadlineError,
+  readOnlyRequested,
   runNestedSavepoint,
   runRootScope,
   scopeTurn,
+  settleFailedTransaction,
   startTransactionBudget,
   transactionAbortedError,
-  transactionOutcomeUnknownError,
   validateTransactionDeadline
 } from "@vibeorm/runtime/adapter-kit";
 import { VibeError as VibeError4 } from "@vibeorm/schema";
+import pg2 from "pg";
+
+// packages/adapter-pg/src/batch.ts
 import pg from "pg";
+var prepareValue = (() => {
+  const utils = pg.utils;
+  return typeof utils?.prepareValue === "function" ? utils.prepareValue : undefined;
+})();
+function supportsBatch(params) {
+  if (prepareValue === undefined)
+    return false;
+  const client = params.client;
+  if (client === null || typeof client !== "object" || client.pipeline === true)
+    return false;
+  const connection = client.connection;
+  return connection !== null && typeof connection === "object" && typeof connection.parse === "function" && typeof connection.bind === "function" && typeof connection.describe === "function" && typeof connection.execute === "function" && typeof connection.sync === "function";
+}
+function prepareBatchValues(params) {
+  const prepare = prepareValue;
+  return params.values.map((value) => prepare(value));
+}
+var COMMAND_TAG = /^([A-Za-z]+)(?: (\d+))?(?: (\d+))?/;
+function isServerError(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const candidate = error;
+  return typeof candidate.code === "string" && /^[0-9A-Z]{5}$/.test(candidate.code) && typeof candidate.severity === "string";
+}
+
+class PgBatch {
+  done;
+  callback = undefined;
+  steps;
+  types;
+  outcomes = [];
+  parsers = [];
+  fields = [];
+  rows = [];
+  rowError = undefined;
+  settled = false;
+  resolve = () => {
+    return;
+  };
+  constructor(params) {
+    this.steps = params.steps;
+    this.types = params.types;
+    this.done = new Promise((resolve) => {
+      this.resolve = resolve;
+    });
+  }
+  submit(connection) {
+    const writer = connection;
+    writer.stream?.cork?.();
+    try {
+      for (const step of this.steps) {
+        writer.parse({ text: step.text, types: [] });
+        writer.bind({ values: step.values ?? [] });
+        writer.describe({ type: "P", name: "" });
+        writer.execute({ portal: "", rows: 0 });
+      }
+      writer.sync();
+    } finally {
+      writer.stream?.uncork?.();
+    }
+  }
+  handleRowDescription(message) {
+    this.fields = message.fields;
+    this.parsers = message.fields.map((field) => this.types.getTypeParser(field.dataTypeID, field.format ?? "text"));
+    this.rows = [];
+  }
+  handleDataRow(message) {
+    if (this.settled || this.rowError !== undefined)
+      return;
+    const row = {};
+    try {
+      for (let index = 0;index < this.fields.length; index++) {
+        const raw = message.fields[index] ?? null;
+        row[this.fields[index].name] = raw === null ? null : this.parsers[index](raw);
+      }
+    } catch (error) {
+      this.rowError = { error };
+      return;
+    }
+    this.rows.push(row);
+  }
+  handleCommandComplete(message) {
+    if (this.settled)
+      return;
+    if (this.rowError !== undefined) {
+      this.outcomes.push({ status: "failed", error: this.rowError.error });
+      this.rowError = undefined;
+      this.rows = [];
+      this.fields = [];
+      this.parsers = [];
+      return;
+    }
+    const match = COMMAND_TAG.exec(message.text ?? message.command ?? "");
+    const command = match?.[1];
+    const rowCount = match?.[3] !== undefined ? Number.parseInt(match[3], 10) : match?.[2] !== undefined ? Number.parseInt(match[2], 10) : null;
+    this.outcomes.push({ status: "ok", result: { rows: this.rows, rowCount, ...command === undefined ? {} : { command } } });
+    this.rows = [];
+    this.fields = [];
+    this.parsers = [];
+  }
+  handleEmptyQuery() {
+    if (this.settled)
+      return;
+    this.outcomes.push({ status: "ok", result: { rows: [], rowCount: null } });
+  }
+  handleError(error) {
+    if (this.settled)
+      return;
+    if (!isServerError(error)) {
+      this.finish({ transportError: error });
+      return;
+    }
+    this.outcomes.push({ status: "failed", error: this.rowError === undefined ? error : this.rowError.error });
+    while (this.outcomes.length < this.steps.length)
+      this.outcomes.push({ status: "skipped" });
+    this.finish({});
+  }
+  handleReadyForQuery() {
+    this.finish({});
+  }
+  handlePortalSuspended() {}
+  handleCopyInResponse(connection) {
+    connection.sendCopyFail?.("COPY FROM STDIN is not supported inside a batch");
+  }
+  handleCopyData() {}
+  finish(params) {
+    if (this.settled)
+      return;
+    this.settled = true;
+    this.callback?.(params.transportError ?? null);
+    this.resolve({
+      steps: this.outcomes,
+      ...params.transportError === undefined ? {} : { transportError: params.transportError }
+    });
+  }
+}
+async function runBatch(params) {
+  const batch = new PgBatch({ steps: params.steps, types: params.types });
+  params.client.query.call(params.client, batch);
+  return batch.done;
+}
+function firstBatchFailure(params) {
+  const { outcome } = params;
+  const index = outcome.steps.findIndex((step) => step.status === "failed");
+  if (index !== -1)
+    return { index, error: outcome.steps[index].error };
+  if (outcome.transportError !== undefined)
+    return { index: outcome.steps.length, error: outcome.transportError };
+  return;
+}
 
 // packages/adapter-pg/src/errors.ts
 import { VibeError } from "@vibeorm/schema";
@@ -39,16 +196,18 @@ var PG_SQLSTATE_ERROR_CODES = Object.freeze({
   "40001": "VIBE_TRANSACTION",
   "40P01": "VIBE_TRANSACTION",
   "57014": "VIBE_TRANSACTION",
-  "55P03": "VIBE_LOCK_NOT_AVAILABLE"
+  "55P03": "VIBE_LOCK_NOT_AVAILABLE",
+  "25006": "VIBE_TRANSACTION"
 });
 var PG_SQLSTATE_REASONS = Object.freeze({
   "23P01": "exclusion-violation",
   "57014": "timeout",
   "55P03": "lock-not-available",
   "40P01": "deadlock",
-  "40001": "serialization-failure"
+  "40001": "serialization-failure",
+  "25006": "read-only-transaction"
 });
-var SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;
+var SQLSTATE_PATTERN = /^(?=[A-Z]*\d)[0-9A-Z]{5}$/;
 function readStringField(params) {
   const value = params.source[params.key];
   return typeof value === "string" && value.length > 0 ? value : undefined;
@@ -247,8 +406,17 @@ var ISOLATION_LEVEL_SQL = Object.freeze({
   Serializable: "SERIALIZABLE"
 });
 function beginStatement(params) {
-  const { isolationLevel } = params;
-  return isolationLevel === undefined ? "BEGIN" : `BEGIN ISOLATION LEVEL ${ISOLATION_LEVEL_SQL[isolationLevel]}`;
+  const { isolationLevel, readOnly } = params;
+  const modes = [];
+  if (isolationLevel !== undefined)
+    modes.push(`ISOLATION LEVEL ${ISOLATION_LEVEL_SQL[isolationLevel]}`);
+  if (readOnly === true)
+    modes.push("READ ONLY");
+  return modes.length === 0 ? "BEGIN" : `BEGIN ${modes.join(", ")}`;
+}
+function openTransactionStatement(params) {
+  const begin = beginStatement(params);
+  return params.timeout === undefined ? begin : `${begin}; ${statementTimeoutStatement({ timeout: params.timeout })}`;
 }
 function statementTimeoutStatement(params) {
   const { timeout } = params;
@@ -276,13 +444,17 @@ import { createSavepointCounter, nextSavepointName } from "@vibeorm/runtime/adap
 import {
   DEFAULT_DEADLINE_CLOCK,
   engineStatementBudgetMs as engineStatementBudgetMs2,
-  isTransactionDeadlineError as isTransactionDeadlineError2,
+  isTransactionDeadlineError,
   startTransactionBudget as startTransactionBudget2,
   transactionClosedError,
   transactionDeadlineError,
-  transactionOutcomeUnknownError as transactionOutcomeUnknownError2,
+  transactionOutcomeUnknownError,
   validateTransactionDeadline as validateTransactionDeadline2
 } from "@vibeorm/runtime/adapter-kit";
+var MAX_STATEMENT_TIMEOUT_MS = 2147483647;
+var ignore = () => {
+  return;
+};
 function finalResult(params) {
   return Array.isArray(params.result) ? params.result.at(-1) ?? { rows: [], rowCount: 0 } : params.result;
 }
@@ -302,13 +474,58 @@ function commitOutcomeUnknownError(params) {
     cause: params.cause
   });
 }
+var NEVER_REUSE_SQLSTATE_CLASSES = new Set(["08", "53", "57", "58", "XX"]);
+var STALE_STATEMENT_SQLSTATES = new Set(["0A000", "26000", "42P05"]);
+function observeReadyForQuery(params) {
+  const client = params.client;
+  let backgroundFailure = false;
+  let settle = () => {
+    return;
+  };
+  const firstEvent = new Promise((resolve) => {
+    settle = resolve;
+  });
+  const onDrain = () => settle("drain");
+  const onError = () => {
+    backgroundFailure = true;
+    settle("error");
+  };
+  const onEnd = () => settle("end");
+  client.on("error", onError);
+  client.on("drain", onDrain);
+  client.on("end", onEnd);
+  return {
+    reusableAfter: async ({ error, named }) => {
+      if (!(error instanceof VibeError4))
+        return false;
+      const sqlstate = error.meta.sqlstate;
+      if (typeof sqlstate !== "string" || NEVER_REUSE_SQLSTATE_CLASSES.has(sqlstate.slice(0, 2)))
+        return false;
+      if (named && STALE_STATEMENT_SQLSTATES.has(sqlstate))
+        return false;
+      const event = await firstEvent;
+      return event === "drain" && !backgroundFailure && client.getTransactionStatus() === "I";
+    },
+    detach: () => {
+      client.removeListener("error", onError);
+      client.removeListener("drain", onDrain);
+      client.removeListener("end", onEnd);
+    }
+  };
+}
+function hasReadyForQuerySeam(params) {
+  const client = params.client;
+  return typeof client.on === "function" && typeof client.removeListener === "function" && typeof client.once === "function" && typeof client.getTransactionStatus === "function" && client.pipeline !== true;
+}
 function guardBackgroundErrors(params) {
-  const { client } = params;
+  const { client, onError } = params;
   if (typeof client.on !== "function")
     return () => {
       return;
     };
-  const swallow = () => {};
+  const swallow = (error) => {
+    onError?.(error);
+  };
   client.on("error", swallow);
   return () => {
     client.removeListener?.("error", swallow);
@@ -317,10 +534,12 @@ function guardBackgroundErrors(params) {
 var DIALECT = "postgres";
 var PROVIDER = "postgresql";
 var WIRE = Object.freeze({ dateTime: "native", json: "parsed", numbers: "native" });
+var ROUND_TRIPS = "network";
 var BUDGETS = Object.freeze({
   acquireTimeout: true,
   statementTimeout: "all-statements",
-  transactionDeadline: "cancel-running-statements"
+  transactionDeadline: "cancel-running-statements",
+  accessModes: Object.freeze(["readOnly"])
 });
 var NUMERIC_ARRAY_OID = 1231;
 var TEXT_ARRAY_OID = 1009;
@@ -328,7 +547,7 @@ var TIMESTAMP_OID = 1114;
 var TIMESTAMP_ARRAY_OID = 1115;
 var DATE_OID = 1082;
 var DATE_ARRAY_OID = 1182;
-var driverTypeParser = pg.types.getTypeParser;
+var driverTypeParser = pg2.types.getTypeParser;
 var ZONE_LESS_TEXT = /^\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2}:\d{2}(?:\.\d{1,6})?)?$/;
 function parseZoneLessAsUtc(value) {
   if (ZONE_LESS_TEXT.test(value)) {
@@ -362,11 +581,25 @@ var EXACT_TYPES = {
     return driverTypeParser(oid, format);
   }
 };
+function takeAddress(params) {
+  const options = params.options;
+  if (options?.pool !== undefined && options.pool !== null)
+    return { pool: options.pool };
+  const connectionString = options?.connectionString;
+  if (typeof connectionString === "string" && connectionString.trim() !== "")
+    return { connectionString };
+  throw new VibeError4({
+    code: "VIBE_CONFIG",
+    message: "pgAdapter needs an explicit address: pass `connectionString` (a PostgreSQL URL) or an existing `pool`. " + "The adapter does not read DATABASE_URL or the PG* environment variables.",
+    meta: { adapter: "pg", reason: "missing-address" }
+  });
+}
 function pgAdapter(options) {
+  const address = takeAddress({ options });
   const usePrepared = options?.preparedStatements ?? false;
   const stmtCacheMax = options?.stmtCacheMax ?? 1000;
   const planCacheMode = options?.planCacheMode === undefined ? "auto" : assertPlanCacheMode({ value: options.planCacheMode });
-  if (planCacheMode !== "auto" && options?.pool !== undefined) {
+  if (planCacheMode !== "auto" && "pool" in address) {
     throw new VibeError4({
       code: "VIBE_CONFIG",
       message: "planCacheMode configures the pool the adapter builds \u2014 it cannot be applied to a caller-supplied `pool`; " + 'set `options: "-c plan_cache_mode=\u2026"` on that pool instead',
@@ -377,22 +610,23 @@ function pgAdapter(options) {
   let ownsPool = false;
   let rawSession = null;
   let rawSessionUnguard = null;
+  let rootViaPoolQuery = false;
   function getPool() {
     if (pool !== null)
       return pool;
-    if (options?.pool !== undefined) {
-      pool = options.pool;
+    if ("pool" in address) {
+      pool = address.pool;
       ownsPool = false;
       return pool;
     }
     const config = buildPoolConfig({
-      connectionString: options?.connectionString ?? process.env.DATABASE_URL,
+      connectionString: address.connectionString,
       max: options?.max ?? 10,
       ...options?.statementTimeout === undefined ? {} : { statementTimeout: options.statementTimeout },
       ...options?.connectionTimeout === undefined ? {} : { connectionTimeout: options.connectionTimeout },
       planCacheMode
     });
-    const PoolCtor = pg.Pool;
+    const PoolCtor = pg2.Pool;
     pool = new PoolCtor(config);
     pool.on?.("error", () => {});
     ownsPool = true;
@@ -420,7 +654,7 @@ function pgAdapter(options) {
     if (results.length === 0)
       observeRowChanges({ scope: params.scope, count: statementRowChanges({ effect: params.effect }) });
     for (const result of results)
-      observeRowChanges({ scope: params.scope, count: statementRowChanges({ effect: params.effect, count: result.rowCount }) });
+      observeRowChanges({ scope: params.scope, count: statementRowChanges({ effect: params.effect, count: result.rowCount, rows: result.rows?.length, resultRows: result.rows }) });
   }
   async function runExecute(params) {
     const config = buildQueryConfig({ text: params.text, values: params.values });
@@ -436,13 +670,25 @@ function pgAdapter(options) {
     return { rows: final.rows, affectedRows: final.rowCount ?? 0 };
   }
   function createClientAdapter(params) {
-    const { dispatch, scope, budget } = params;
-    const client = { query: (config) => dispatch({ config }) };
+    const { dispatch, scope, budget, deferred } = params;
+    const client = { query: (config) => dispatch({ config, batchable: true }) };
+    const rawClient = { query: (config) => dispatch({ config, batchable: (config.values?.length ?? 0) > 0 }) };
+    const savepointControl = (statement, cleanup) => {
+      if (deferred !== null && deferred.routeSavepoint({ text: statement }) !== "send")
+        return;
+      return runMapped(() => dispatch({
+        config: { text: statement },
+        stage: "nested",
+        batchable: true,
+        ...cleanup ? { cleanup: true } : {}
+      }));
+    };
     return {
       dialect: DIALECT,
       provider: PROVIDER,
       wire: WIRE,
       budgets: BUDGETS,
+      roundTrips: ROUND_TRIPS,
       rowChanges: () => {
         budget.assertUsable({ stage: "statement" });
         return readRowChanges({ scope });
@@ -459,33 +705,61 @@ function pgAdapter(options) {
         if (turn !== undefined)
           await turn;
         budget.assertUsable({ stage: "statement" });
-        return runExecuteUnsafe({ queryable: client, scope, ...execParams }).catch((error) => abortTransactionOnServerFailure({ scope, error }));
+        return runExecuteUnsafe({ queryable: rawClient, scope, ...execParams }).catch((error) => abortTransactionOnServerFailure({ scope, error }));
       },
       async transaction(fn, nestedOptions) {
         refuseNestedTransactionOptions({ options: nestedOptions, provider: PROVIDER });
         budget.assertUsable({ stage: "nested" });
         return runNestedSavepoint({
           scope,
-          execute: (statement) => runMapped(() => dispatch({
-            config: { text: statement },
-            stage: "nested",
-            cleanup: statement.startsWith("ROLLBACK TO SAVEPOINT ")
-          })),
-          body: (child) => fn(createClientAdapter({ dispatch, scope: child, budget }))
+          execute: (statement) => savepointControl(statement, false),
+          cleanup: (statement) => savepointControl(statement, true),
+          body: (child) => fn(createClientAdapter({ dispatch, scope: child, budget, deferred }))
         });
       },
-      async connect() {},
-      async disconnect() {},
+      async connect() {
+        budget.assertUsable({ stage: "statement" });
+        throw transactionLifecycleRefusal({ method: "connect" });
+      },
+      async disconnect() {
+        budget.assertUsable({ stage: "statement" });
+        throw transactionLifecycleRefusal({ method: "disconnect" });
+      },
       formatArrayParam(values) {
         return new PgArrayParam(values);
       }
     };
   }
-  return {
-    dialect: DIALECT,
-    provider: PROVIDER,
-    wire: WIRE,
-    budgets: BUDGETS,
+  function closeOwnedResources() {
+    return runShutdownCleanup({
+      steps: [
+        async () => {
+          if (rawSession === null)
+            return;
+          const session = rawSession;
+          const unguard = rawSessionUnguard;
+          rawSession = null;
+          rawSessionUnguard = null;
+          await runMapped(() => session.query({ text: "ROLLBACK" })).then(() => {
+            unguard?.();
+            session.release();
+          }, (error) => {
+            unguard?.();
+            session.release(true);
+            throw error;
+          });
+        },
+        async () => {
+          if (pool === null || !ownsPool)
+            return;
+          const closing = pool;
+          await runMapped(() => closing.end());
+        }
+      ]
+    });
+  }
+  const lifecycle = createAdapterLifecycleGate({ driver: "pg", cleanup: closeOwnedResources });
+  const root = {
     async withSession({ run }) {
       const client = await runMapped(() => getPool().connect());
       let backgroundFailure;
@@ -508,7 +782,29 @@ function pgAdapter(options) {
       });
     },
     async execute(params) {
-      return runExecute({ queryable: getPool(), ...params });
+      const config = buildQueryConfig({ text: params.text, values: params.values });
+      const rootPool = getPool();
+      if (!rootViaPoolQuery) {
+        const client = await runMapped(() => rootPool.connect());
+        if (hasReadyForQuerySeam({ client })) {
+          const seam = observeReadyForQuery({ client });
+          let reuse = false;
+          try {
+            const result = await runMapped(() => client.query(config));
+            reuse = true;
+            return finalResult({ result }).rows;
+          } catch (error) {
+            reuse = await seam.reusableAfter({ error, named: config.name !== undefined });
+            throw error;
+          } finally {
+            seam.detach();
+            client.release(!reuse);
+          }
+        }
+        client.release();
+        rootViaPoolQuery = true;
+      }
+      return finalResult({ result: await runMapped(() => rootPool.query(config)) }).rows;
     },
     async executeUnsafe(params) {
       const control = classifyRawTransactionControl({ text: params.text });
@@ -549,55 +845,145 @@ function pgAdapter(options) {
         support: BUDGETS.transactionDeadline,
         provider: PROVIDER
       });
+      const openingOptions = {
+        isolationLevel: transactionOptions?.isolationLevel,
+        readOnly: readOnlyRequested({ options: transactionOptions, provider: PROVIDER }),
+        timeout: transactionOptions?.timeout
+      };
+      const openText = openTransactionStatement(openingOptions);
       const client = await runMapped(() => getPool().connect());
-      const unguard = guardBackgroundErrors({ client });
+      let connectionFailure;
+      const unguard = guardBackgroundErrors({
+        client,
+        onError: (cause) => {
+          if (connectionFailure === undefined)
+            connectionFailure = { cause };
+        }
+      });
       const scope = createSavepointScope();
       const budget = startTransactionBudget({ options: transactionOptions, provider: PROVIDER });
-      let tail = Promise.resolve();
-      const dispatch = (dispatchParams) => {
-        if (budget.totalMs === null)
-          return client.query(dispatchParams.config);
-        const pending = tail.then(async () => {
-          if (!dispatchParams.cleanup) {
-            if (scope.state.poisoned !== null)
-              throw scope.state.poisoned;
-            const stage = dispatchParams.stage ?? "statement";
+      const capable = supportsBatch({ client });
+      const deferOpening = capable && (openingOptions.timeout === undefined || openingOptions.timeout <= MAX_STATEMENT_TIMEOUT_MS);
+      const opening = deferOpening ? [beginStatement(openingOptions), ...openingOptions.timeout === undefined ? [] : [statementTimeoutStatement({ timeout: openingOptions.timeout })]] : [];
+      const deferred = createDeferredControl({ opening });
+      let openingFailure;
+      let inFlight = null;
+      const sendWithControl = (dispatchParams) => {
+        const { config, cleanup } = dispatchParams;
+        const handOver = () => {
+          dispatchParams.sent?.();
+          return client.query(config);
+        };
+        if (cleanup !== true && openingFailure !== undefined)
+          throw transactionAbortedError({ cause: openingFailure });
+        let bound;
+        if (cleanup !== true && budget.totalMs !== null) {
+          if (scope.state.poisoned !== null)
+            throw scope.state.poisoned;
+          budget.assertUsable({ stage: dispatchParams.stage ?? "statement" });
+          const ms = engineStatementBudgetMs({ budget });
+          if (ms !== null)
+            bound = statementTimeoutStatement({ timeout: ms });
+        }
+        if (!capable) {
+          if (bound === undefined)
+            return handOver();
+          const stage = dispatchParams.stage ?? "statement";
+          return runMapped(() => client.query({ text: bound })).then(() => {
             budget.assertUsable({ stage });
-            const ms = engineStatementBudgetMs({ budget });
-            if (ms !== null) {
-              await runMapped(() => client.query({ text: statementTimeoutStatement({ timeout: ms }) }));
-              budget.assertUsable({ stage });
+            return handOver();
+          });
+        }
+        const pendingControl = cleanup !== true && deferred.hasPending();
+        if (!pendingControl && bound === undefined)
+          return handOver();
+        const statement = dispatchParams.batchable === true ? [{ text: config.text, values: prepareBatchValues({ values: config.values ?? [] }) }] : [];
+        const carriesOpening = !deferred.opened();
+        const control = pendingControl ? [...deferred.take()] : [];
+        if (bound !== undefined)
+          control.push(bound);
+        const openingSteps = carriesOpening ? opening.length : 0;
+        if (statement.length > 0)
+          dispatchParams.sent?.();
+        const burst = runBatch({ client, steps: [...control.map((text) => ({ text })), ...statement], types: EXACT_TYPES }).then((outcome) => {
+          const failure = firstBatchFailure({ outcome });
+          if (failure !== undefined) {
+            if (failure.index < openingSteps || outcome.transportError !== undefined && openingSteps > 0) {
+              openingFailure = mapPgDriverError({ error: failure.error });
             }
+            throw failure.error;
           }
-          return client.query(dispatchParams.config);
-        });
-        tail = pending.then(() => {
-          return;
-        }, () => {
-          return;
+          if (statement.length === 0)
+            return handOver();
+          const last = outcome.steps.at(-1);
+          return last?.status === "ok" ? last.result : { rows: [], rowCount: 0 };
         });
+        if (budget.totalMs === null && carriesOpening) {
+          const settled = burst.then(ignore, ignore).then(() => {
+            if (inFlight === settled)
+              inFlight = null;
+          });
+          inFlight = settled;
+        }
+        return burst;
+      };
+      const send = (dispatchParams) => {
+        try {
+          return sendWithControl(dispatchParams);
+        } catch (error) {
+          return Promise.reject(error);
+        }
+      };
+      let tail = Promise.resolve();
+      const dispatch = (dispatchParams) => {
+        if (budget.totalMs === null) {
+          if (inFlight !== null)
+            return inFlight.then(() => dispatch(dispatchParams));
+          return send(dispatchParams);
+        }
+        const pending = tail.then(() => send(dispatchParams));
+        tail = pending.then(ignore, ignore);
         return pending;
       };
       let discard = false;
+      let commitProgress = "not-sent";
       try {
-        await runMapped(() => client.query({ text: beginStatement({ isolationLevel: transactionOptions?.isolationLevel }) }));
-        if (transactionOptions?.timeout !== undefined) {
-          const text = statementTimeoutStatement({ timeout: transactionOptions.timeout });
-          await runMapped(() => client.query({ text }));
-        }
+        if (!deferOpening)
+          await runMapped(() => client.query({ text: openText }));
         const result = await runRootScope({
           scope,
-          body: () => fn(createClientAdapter({ dispatch, scope, budget }))
+          body: () => fn(createClientAdapter({ dispatch, scope, budget, deferred: capable ? deferred : null }))
         });
         budget.assertUsable({ stage: "commit" });
-        const commit = await runMapped(() => dispatch({ config: { text: "COMMIT" }, stage: "commit" })).catch((cause) => {
-          if (!isConnectionLoss({ error: cause }))
+        if (!deferred.opened()) {
+          budget.close({ outcome: "committed" });
+          return result;
+        }
+        if (openingFailure !== undefined)
+          throw transactionAbortedError({ cause: openingFailure });
+        const commit = await runMapped(() => dispatch({
+          config: { text: "COMMIT" },
+          stage: "commit",
+          batchable: true,
+          sent: () => {
+            if (connectionFailure !== undefined)
+              throw mapPgDriverError({ error: connectionFailure.cause });
+            commitProgress = "sent";
+          }
+        })).catch((cause) => {
+          if (commitProgress === "not-sent")
             throw cause;
+          if (!isConnectionLoss({ error: cause })) {
+            commitProgress = "answered";
+            throw cause;
+          }
+          commitProgress = "unanswered";
           discard = true;
           budget.close({ outcome: "unknown" });
           throw commitOutcomeUnknownError({ cause });
         });
         if (finalResult({ result: commit }).command === "ROLLBACK") {
+          commitProgress = "answered";
           throw transactionAbortedError({ cause: scope.state.aborted?.cause });
         }
         budget.close({ outcome: "committed" });
@@ -607,21 +993,25 @@ function pgAdapter(options) {
           discard = true;
           budget.close({ outcome: "unknown" });
         }
+        let rollback = "not-needed";
         try {
-          await dispatch({ config: { text: "ROLLBACK" }, cleanup: true });
-          budget.close({ outcome: "rolled-back" });
+          if (deferred.opened()) {
+            await dispatch({ config: { text: "ROLLBACK" }, cleanup: true });
+            rollback = "acknowledged";
+          }
         } catch {
           discard = true;
-          budget.close({ outcome: "unknown" });
-          if (budget.totalMs !== null && isTransactionDeadlineError(error)) {
-            throw transactionOutcomeUnknownError({
-              provider: PROVIDER,
-              totalMs: budget.totalMs,
-              cause: error
-            });
-          }
+          rollback = "failed";
         }
-        throw error;
+        throw settleFailedTransaction({
+          error,
+          provider: PROVIDER,
+          budget,
+          scope,
+          commit: commitProgress,
+          rollback,
+          connection: discard ? "discarded" : "returned"
+        });
       } finally {
         unguard();
         client.release(discard);
@@ -630,24 +1020,32 @@ function pgAdapter(options) {
     async connect() {
       const client = await runMapped(() => getPool().connect());
       client.release();
+    }
+  };
+  return {
+    dialect: DIALECT,
+    provider: PROVIDER,
+    wire: WIRE,
+    budgets: BUDGETS,
+    roundTrips: ROUND_TRIPS,
+    transactionOutcome: "reported",
+    withSession({ run }) {
+      return lifecycle.admit({ run: () => root.withSession({ run: (executor) => lifecycle.inCallback({ run: () => run(executor) }) }) });
     },
-    async disconnect() {
-      if (rawSession !== null) {
-        const session = rawSession;
-        const unguard = rawSessionUnguard;
-        rawSession = null;
-        rawSessionUnguard = null;
-        try {
-          await session.query({ text: "ROLLBACK" });
-        } catch {}
-        unguard?.();
-        session.release();
-      }
-      if (pool !== null && ownsPool) {
-        const closing = pool;
-        pool = null;
-        await runMapped(() => closing.end());
-      }
+    execute(params) {
+      return lifecycle.admit({ run: () => root.execute(params) });
+    },
+    executeUnsafe(params) {
+      return lifecycle.admit({ run: () => root.executeUnsafe(params) });
+    },
+    transaction(fn, transactionOptions) {
+      return lifecycle.admit({ run: () => root.transaction((txAdapter) => lifecycle.inCallback({ run: () => fn(txAdapter) }), transactionOptions) });
+    },
+    connect() {
+      return lifecycle.admit({ run: () => root.connect() });
+    },
+    disconnect() {
+      return lifecycle.disconnect();
     },
     formatArrayParam(values) {
       return new PgArrayParam(values);
@@ -666,7 +1064,7 @@ export {
   createSavepointCounter,
   createStatementNameCache,
   engineStatementBudgetMs2 as engineStatementBudgetMs,
-  isTransactionDeadlineError2 as isTransactionDeadlineError,
+  isTransactionDeadlineError,
   mapPgDriverError,
   nextSavepointName,
   pgAdapter,
@@ -679,8 +1077,8 @@ export {
   statementTimeoutStatement,
   transactionClosedError,
   transactionDeadlineError,
-  transactionOutcomeUnknownError2 as transactionOutcomeUnknownError,
+  transactionOutcomeUnknownError,
   validateTransactionDeadline2 as validateTransactionDeadline
 };
 
-//# debugId=2E6D6B100B9B0A5B64756E2164756E21
+//# debugId=9151AD009082F4C664756E2164756E21