@happyvertical/sql 0.80.3 → 0.80.5

package/dist/index.js

@@ -310,6 +310,34 @@ function countValueFromRow(value) {
 //#endregion
 //#region src/shared/types.ts
 /**
+* Error thrown when `transaction()` is called on a transaction-scoped interface
+* belonging to an adapter whose engine has no savepoints.
+*
+* DuckDB — and therefore the JSON adapter built on it — does not implement
+* `SAVEPOINT`, so there is no way to re-enter the current transaction. Adapters
+* that can re-enter (PostgreSQL, SQLite) do so under a savepoint and never
+* throw this.
+*
+* The alternative would be to open a second, independent transaction, which is
+* what these adapters used to do; on a shared connection that silently
+* destroyed the enclosing transaction's uncommitted work.
+*
+* @example Ensuring a helper works on every adapter
+* ```typescript
+* // Take the transaction as a parameter rather than opening a nested one.
+* async function recordClick(db: DatabaseInterface, id: string) {
+*   await db.update('links', { id }, { clicks: 1 });
+* }
+* await db.transaction(async (tx) => recordClick(tx, id));
+* ```
+*/
+var NestedTransactionError = class extends DatabaseError {
+	constructor(message, context) {
+		super(message, context);
+		this.name = "NestedTransactionError";
+	}
+};
+/**
 * Resolves a SchemasOption to its concrete value.
 *
 * Adapters that need schemas (JSON, DuckDB) call this to unwrap the
@@ -1472,60 +1500,27 @@ async function getDatabase$2(options) {
 		const transaction = async (callback) => {
 			try {
 				await connection.run("BEGIN TRANSACTION");
-				const result = await callback({
-					url,
-					client: connection,
-					insert,
-					get,
-					list,
-					update,
-					upsert,
-					getOrInsert,
-					delete: deleteRecords,
-					count,
-					table,
-					many,
-					single,
-					pluck,
-					execute,
-					query,
-					oo,
-					oO,
-					ox,
-					xx,
-					tableExists,
-					syncSchema,
-					transaction
-				});
+				const result = await callback(createTransactionScope());
 				await connection.run("COMMIT");
 				return result;
 			} catch (error) {
-				await connection.run("ROLLBACK");
+				try {
+					await connection.run("ROLLBACK");
+				} catch {}
 				throw error;
 			}
 		};
 		/**
-		* Begins a new transaction and returns a handle for manual control
-		*
-		* Unlike transaction(), this gives you explicit control over commit/rollback.
-		* Ideal for test isolation where you want to rollback after each test.
+		* Builds the transaction-scoped interface handed to a transaction callback.
 		*
-		* @returns Promise resolving to a TransactionHandle
+		* The only difference from the top-level interface is `transaction`, which
+		* refuses to nest. DuckDB has no SAVEPOINT, so there is no way to re-enter
+		* the transaction already in progress; re-exposing the top-level
+		* `transaction` (the previous behaviour) sent the nested call into a second
+		* BEGIN on the same connection, which throws and then rolls back the
+		* *enclosing* transaction, silently discarding its work.
 		*/
-		const beginTransaction = async () => {
-			await connection.run("BEGIN TRANSACTION");
-			let active = true;
-			const commit = async () => {
-				if (!active) throw new DatabaseError("Transaction already ended", {});
-				await connection.run("COMMIT");
-				active = false;
-			};
-			const rollback = async () => {
-				if (!active) throw new DatabaseError("Transaction already ended", {});
-				await connection.run("ROLLBACK");
-				active = false;
-			};
-			const isActive = () => active;
+		const createTransactionScope = () => {
 			return {
 				url,
 				client: connection,
@@ -1549,7 +1544,35 @@ async function getDatabase$2(options) {
 				xx,
 				tableExists,
 				syncSchema,
-				transaction,
+				transaction: async () => {
+					throw new NestedTransactionError("Nested transactions are not supported by this adapter because its engine has no SAVEPOINT. Pass the existing transaction to the callee instead of opening a new one.", { adapter: "json" });
+				}
+			};
+		};
+		/**
+		* Begins a new transaction and returns a handle for manual control
+		*
+		* Unlike transaction(), this gives you explicit control over commit/rollback.
+		* Ideal for test isolation where you want to rollback after each test.
+		*
+		* @returns Promise resolving to a TransactionHandle
+		*/
+		const beginTransaction = async () => {
+			await connection.run("BEGIN TRANSACTION");
+			let active = true;
+			const commit = async () => {
+				if (!active) throw new DatabaseError("Transaction already ended", {});
+				await connection.run("COMMIT");
+				active = false;
+			};
+			const rollback = async () => {
+				if (!active) throw new DatabaseError("Transaction already ended", {});
+				await connection.run("ROLLBACK");
+				active = false;
+			};
+			const isActive = () => active;
+			return {
+				...createTransactionScope(),
 				commit,
 				rollback,
 				isActive
@@ -1963,6 +1986,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 +2102,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 +2674,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 +2810,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 +2827,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 () => {
-			if (!active) throw new DatabaseError("Transaction already ended", {});
-			await txClient.query("COMMIT");
-			active = false;
-			txClient.release();
-		};
-		const rollback = async () => {
+		const end = async (command) => {
 			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,
@@ -3177,8 +3276,8 @@ async function getDatabase(options = {}) {
 	}));
 	if (!options.type && (options.url?.startsWith("file:") || options.url === ":memory:")) options.type = "sqlite";
 	if (options.type === "postgres") return (await Promise.resolve().then(() => postgres_exports)).getDatabase(options);
-	if (options.type === "sqlite") return (await import("./chunks/sqlite-YgU9LCVy.js")).getDatabase(options);
-	if (options.type === "duckdb") return (await import("./chunks/duckdb-DykBBzd6.js")).getDatabase(options);
+	if (options.type === "sqlite") return (await import("./chunks/sqlite-B4ussRTS.js")).getDatabase(options);
+	if (options.type === "duckdb") return (await import("./chunks/duckdb-D_Wu36JL.js")).getDatabase(options);
 	if (options.type === "json") return (await Promise.resolve().then(() => json_exports)).getDatabase(options);
 	throw new Error("Invalid database type");
 }
@@ -3240,6 +3339,6 @@ var src_default = {
 /** @internal */
 var PACKAGE_VERSION_INITIALIZED = true;
 //#endregion
-export { DatabaseSchemaManager, PACKAGE_VERSION_INITIALIZED, assertCanExportDatabase, assertCanImportDatabase, bucketExpr, buildAggregate, buildWhere, checkExpectedTables, checkRelationship, checkUniqueColumn, clearConnectionCache, clearPostgresConnectionCache, convertUniqueIndexesToInlineConstraints, createPostgresDatabase, databaseNameFromUrl, src_default as default, dropPostgresDatabase, dumpPostgresDatabase, escapeSqlValue, formatDbError, getDatabase, isLocalDatabaseUrl, postgresEnvFromUrl, redactDatabaseUrl, resolveSchemas, restorePostgresDatabase, runDoctor, syncSchema, tableExists, validateColumnName };
+export { DatabaseSchemaManager, NestedTransactionError, PACKAGE_VERSION_INITIALIZED, assertCanExportDatabase, assertCanImportDatabase, bucketExpr, buildAggregate, buildWhere, checkExpectedTables, checkRelationship, checkUniqueColumn, clearConnectionCache, clearPostgresConnectionCache, convertUniqueIndexesToInlineConstraints, createPostgresDatabase, databaseNameFromUrl, src_default as default, dropPostgresDatabase, dumpPostgresDatabase, escapeSqlValue, formatDbError, getDatabase, isLocalDatabaseUrl, postgresEnvFromUrl, redactDatabaseUrl, resolveSchemas, restorePostgresDatabase, runDoctor, syncSchema, tableExists, validateColumnName };
 
 //# sourceMappingURL=index.js.map