@happyvertical/sql 0.80.3 → 0.80.4

package/dist/index.js

@@ -1963,6 +1963,9 @@ async function createDatabase(options, cacheKey) {
 		database,
 		max: poolMax
 	});
+	pool.on("error", (error) => {
+		console.warn("Warning: PostgreSQL pool client error (connection discarded):", error instanceof Error ? error.message : String(error));
+	});
 	const originalEnd = pool.end.bind(pool);
 	const evictFromCache = () => {
 		for (const [key, cached] of connectionCache.entries()) if (cached.client === pool) connectionCache.delete(key);
@@ -2076,18 +2079,83 @@ async function createDatabase(options, cacheKey) {
 			affected: (await executor.query(insertSql, values)).rowCount ?? 0
 		};
 	};
-	const executeNullAwarePostgresUpsertInTransaction = async (table, conflictColumns, serializedData) => {
+	/**
+	* Absorbs 'error' events for the clients currently checked out for a
+	* transaction, keyed by client so the listener can be removed on release.
+	*/
+	const txErrorAbsorbers = /* @__PURE__ */ new WeakMap();
+	const releasedTxClients = /* @__PURE__ */ new WeakSet();
+	/**
+	* Checks out a pooled client for a transaction.
+	*
+	* pg-pool drops its own idle 'error' listener while a client is checked out,
+	* so a backend that dies mid-transaction would emit an unhandled 'error' and
+	* terminate the process. Absorb it here — the failure still reaches the
+	* caller as a rejected query — and drop the listener again on release so
+	* repeated checkouts of the same client cannot accumulate them.
+	*/
+	const acquireTxClient = async () => {
 		const txClient = await client.connect();
+		releasedTxClients.delete(txClient);
+		const absorb = () => {};
+		txClient.on("error", absorb);
+		txErrorAbsorbers.set(txClient, absorb);
+		return txClient;
+	};
+	/**
+	* Returns a transaction client to the pool exactly once.
+	*
+	* Every teardown path must run this, including the ones reached by a throwing
+	* COMMIT or ROLLBACK — a client that is never released stays checked out for
+	* the life of the process, and enough of them exhaust the pool. Releasing
+	* twice throws, so the released clients are tracked rather than assumed.
+	*
+	* @param txClient - The pooled client backing a transaction
+	* @param destroy - Destroy the connection instead of reusing it, for when the
+	*   transaction state could not be cleaned up
+	*/
+	const releaseTxClient = (txClient, destroy = false) => {
+		if (releasedTxClients.has(txClient)) return;
+		releasedTxClients.add(txClient);
+		const absorb = txErrorAbsorbers.get(txClient);
+		if (absorb) {
+			txClient.off("error", absorb);
+			txErrorAbsorbers.delete(txClient);
+		}
+		txClient.release(destroy || void 0);
+	};
+	/**
+	* Rolls back a failed transaction and returns its client to the pool.
+	*
+	* The connection may still be inside a transaction, so ROLLBACK is attempted
+	* to normalize it. If that works the connection is clean and worth reusing;
+	* if it does not, the state is unknown and the connection is destroyed rather
+	* than handed to unrelated code later.
+	*
+	* @returns The rollback failure, if the connection could not be normalized
+	*/
+	const discardTxClient = async (txClient) => {
+		try {
+			await txClient.query("ROLLBACK");
+			releaseTxClient(txClient);
+			return;
+		} catch (rollbackError) {
+			releaseTxClient(txClient, true);
+			return rollbackError;
+		}
+	};
+	const executeNullAwarePostgresUpsertInTransaction = async (table, conflictColumns, serializedData) => {
+		const txClient = await acquireTxClient();
 		try {
 			await txClient.query("BEGIN");
 			const result = await executeNullAwarePostgresUpsert(txClient, table, conflictColumns, serializedData);
 			await txClient.query("COMMIT");
+			releaseTxClient(txClient);
 			return result;
 		} catch (error) {
-			await txClient.query("ROLLBACK");
+			const rollbackError = await discardTxClient(txClient);
+			if (rollbackError !== void 0 && error instanceof Error) error.cause ??= rollbackError;
 			throw error;
-		} finally {
-			txClient.release();
 		}
 	};
 	const executePostgresUpsert = async (executor, table, conflictColumns, data, options, acquireTransaction) => {
@@ -2583,7 +2651,7 @@ async function createDatabase(options, cacheKey) {
 	* @returns Promise resolving to callback result
 	*/
 	const transaction = async (callback) => {
-		const txClient = await client.connect();
+		const txClient = await acquireTxClient();
 		try {
 			await txClient.query("BEGIN");
 			const txDb = {
@@ -2719,12 +2787,12 @@ async function createDatabase(options, cacheKey) {
 			};
 			const result = await callback(txDb);
 			await txClient.query("COMMIT");
+			releaseTxClient(txClient);
 			return result;
 		} catch (error) {
-			await txClient.query("ROLLBACK");
+			const rollbackError = await discardTxClient(txClient);
+			if (rollbackError !== void 0 && error instanceof Error) error.cause ??= rollbackError;
 			throw error;
-		} finally {
-			txClient.release();
 		}
 	};
 	/**
@@ -2736,21 +2804,29 @@ async function createDatabase(options, cacheKey) {
 	* @returns Promise resolving to a TransactionHandle
 	*/
 	const beginTransaction = async () => {
-		const txClient = await client.connect();
-		await txClient.query("BEGIN");
+		const txClient = await acquireTxClient();
+		try {
+			await txClient.query("BEGIN");
+		} catch (error) {
+			releaseTxClient(txClient, true);
+			throw error;
+		}
 		let active = true;
-		const commit = async () => {
+		const end = async (command) => {
 			if (!active) throw new DatabaseError("Transaction already ended", {});
-			await txClient.query("COMMIT");
-			active = false;
-			txClient.release();
-		};
-		const rollback = async () => {
-			if (!active) throw new DatabaseError("Transaction already ended", {});
-			await txClient.query("ROLLBACK");
-			active = false;
-			txClient.release();
+			try {
+				await txClient.query(command);
+				active = false;
+				releaseTxClient(txClient);
+			} catch (error) {
+				active = false;
+				const rollbackError = await discardTxClient(txClient);
+				if (rollbackError !== void 0 && error instanceof Error) error.cause ??= rollbackError;
+				throw error;
+			}
 		};
+		const commit = () => end("COMMIT");
+		const rollback = () => end("ROLLBACK");
 		const isActive = () => active;
 		const txHandle = {
 			url,