@happyvertical/sql 0.89.4 → 0.89.6

package/README.md

@@ -353,6 +353,13 @@ child rollback therefore cannot silently remove a successful parent operation.
 The enclosing commit or rollback drains all
 accepted child scopes before ending the transaction. PostgreSQL pools separate
 connections, so top-level transactions there run concurrently and never queue.
+PostgreSQL CRUD helpers apply the same value serialization both inside and
+outside a transaction: objects and arrays are encoded for JSON/JSONB columns,
+dates use ISO timestamps, binary buffers and views retain their native `bytea`
+representation, `null` remains SQL `NULL`, and scalar values pass through
+unchanged. If a PostgreSQL statement aborts a transaction, later
+operations and commit preserve the first statement error rather than replacing
+it with the generic `25P02 current transaction is aborted` state error.
 Every SQLite transaction-scoped operation is registered when its public method
 is called. Ending a callback or invoking a manual handle's commit/rollback
 seals the scope synchronously, drains operations already accepted, and rejects

package/dist/index.js

@@ -8,7 +8,7 @@ import { mkdir, readdir, stat } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { webcrypto } from "node:crypto";
-import { Pool } from "pg";
+import { DatabaseError as DatabaseError$1, Pool } from "pg";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -2337,21 +2337,13 @@ async function createDatabase(config) {
 	const serializeValue = (value) => {
 		if (value === null || value === void 0) return value;
 		if (value instanceof Date) return value.toISOString();
+		if (Buffer.isBuffer(value) || ArrayBuffer.isView(value)) return value;
 		if (typeof value === "object") return JSON.stringify(value);
 		return value;
 	};
 	/**
 	* Serializes all values in an object for database storage
 	*/
-	/**
-	* The serializer the transaction-scoped interfaces have always used: none.
-	*
-	* Identity, deliberately — not even the `undefined`-dropping the pool-backed
-	* `serializeRecord` does. Those copies bound `undefined` straight through to
-	* `pg`, which stores NULL, whereas dropping the key omits the column and lets
-	* its default apply. Preserving that is the point of this parameter.
-	*/
-	const passThroughRecord = (record) => record;
 	const serializeRecord = (record) => {
 		const serialized = {};
 		for (const [key, value] of Object.entries(record)) {
@@ -2505,12 +2497,183 @@ async function createDatabase(config) {
 			return rollbackError;
 		}
 	};
+	/**
+	* Keeps the first PostgreSQL statement failure attached to a transaction.
+	*
+	* PostgreSQL reports every later statement in an aborted transaction as
+	* 25P02. Replacing the first failure with that generic state error hides the
+	* actionable code and diagnostics from callers. The scoped executor instead
+	* rethrows the first failure whenever PostgreSQL reports 25P02, and exposes
+	* the recorded failure so a swallowed statement error cannot make COMMIT's
+	* implicit rollback look successful.
+	*/
+	const createTransactionExecutor = (txClient) => {
+		let firstError;
+		let firstUnconfirmedError;
+		const pending = /* @__PURE__ */ new Set();
+		const isRollbackToSavepoint = (query) => {
+			const sql = typeof query === "string" ? query : typeof query === "object" && query !== null && "text" in query && typeof query.text === "string" ? query.text : void 0;
+			if (sql === void 0) return false;
+			let statement = sql.trimStart();
+			while (statement.startsWith("--") || statement.startsWith("/*")) {
+				if (statement.startsWith("--")) {
+					const newline = statement.search(/[\r\n]/);
+					if (newline === -1) return false;
+					statement = statement.slice(newline + 1).trimStart();
+					continue;
+				}
+				const commentEnd = statement.indexOf("*/", 2);
+				if (commentEnd === -1) return false;
+				statement = statement.slice(commentEnd + 2).trimStart();
+			}
+			return /^ROLLBACK\s+TO(?:\s+SAVEPOINT)?\s+/i.test(statement);
+		};
+		const errorCode = (error) => {
+			if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") return error.code;
+		};
+		const preserveFirstError = (error) => {
+			if (errorCode(error) === "25P02" && firstError !== void 0) return firstError;
+			if (errorCode(error) === "25P02" && firstUnconfirmedError !== void 0) return firstUnconfirmedError;
+			if (error instanceof DatabaseError$1) firstError ??= error;
+			else firstUnconfirmedError ??= error;
+			return error;
+		};
+		const track = (operation, query) => {
+			const tracked = operation.then((result) => {
+				if (isRollbackToSavepoint(query)) firstError = void 0;
+				firstUnconfirmedError = void 0;
+				return result;
+			}).catch((error) => {
+				throw preserveFirstError(error);
+			});
+			pending.add(tracked);
+			tracked.finally(() => pending.delete(tracked)).catch(() => {});
+			return tracked;
+		};
+		return {
+			client: new Proxy(txClient, { get(target, property) {
+				if (property === "query") return (...args) => {
+					const query = args[0];
+					const callbackIndex = typeof args.at(-1) === "function" ? args.length - 1 : -1;
+					if (typeof query === "object" && query !== null && "submit" in query && typeof query.submit === "function") {
+						if (!("handleError" in query) || typeof query.handleError !== "function" || !("handleReadyForQuery" in query) || typeof query.handleReadyForQuery !== "function") return Reflect.apply(target.query, target, args);
+						const handleError = query.handleError;
+						const handleReadyForQuery = query.handleReadyForQuery;
+						let complete;
+						const completion = new Promise((resolve) => {
+							complete = resolve;
+						});
+						let completed = false;
+						const finish = () => {
+							if (completed) return;
+							completed = true;
+							query.handleError = handleError;
+							query.handleReadyForQuery = handleReadyForQuery;
+							pending.delete(completion);
+							complete();
+						};
+						pending.add(completion);
+						query.handleError = function(...handlerArgs) {
+							const error = preserveFirstError(handlerArgs[0]);
+							try {
+								return Reflect.apply(handleError, this, [error, ...handlerArgs.slice(1)]);
+							} finally {
+								finish();
+							}
+						};
+						query.handleReadyForQuery = function(...handlerArgs) {
+							try {
+								const result = Reflect.apply(handleReadyForQuery, this, handlerArgs);
+								if (isRollbackToSavepoint(query)) firstError = void 0;
+								firstUnconfirmedError = void 0;
+								return result;
+							} finally {
+								finish();
+							}
+						};
+						try {
+							return Reflect.apply(target.query, target, args);
+						} catch (error) {
+							finish();
+							throw preserveFirstError(error);
+						}
+					}
+					if (callbackIndex !== -1) {
+						const callback = args[callbackIndex];
+						let complete;
+						const completion = new Promise((resolve) => {
+							complete = resolve;
+						});
+						pending.add(completion);
+						args[callbackIndex] = (error, result) => {
+							const callbackError = error === null || error === void 0 ? error : preserveFirstError(error);
+							if (callbackError === null || callbackError === void 0) {
+								if (isRollbackToSavepoint(query)) firstError = void 0;
+								firstUnconfirmedError = void 0;
+							}
+							pending.delete(completion);
+							complete();
+							callback(callbackError, result);
+						};
+						try {
+							return Reflect.apply(target.query, target, args);
+						} catch (error) {
+							pending.delete(completion);
+							complete();
+							throw preserveFirstError(error);
+						}
+					}
+					const result = Reflect.apply(target.query, target, args);
+					if (typeof result === "object" && result !== null && "then" in result && typeof result.then === "function") return track(Promise.resolve(result), query);
+					if (typeof result === "object" && result !== null && "once" in result && typeof result.once === "function") {
+						let complete;
+						const completion = new Promise((resolve) => {
+							complete = resolve;
+						});
+						const finish = () => {
+							pending.delete(completion);
+							complete();
+						};
+						pending.add(completion);
+						result.once("error", (error) => {
+							preserveFirstError(error);
+							finish();
+						});
+						result.once("end", () => {
+							if (isRollbackToSavepoint(query)) firstError = void 0;
+							firstUnconfirmedError = void 0;
+							finish();
+						});
+						result.once("close", finish);
+					}
+					return result;
+				};
+				return Reflect.get(target, property, target);
+			} }),
+			executor: { query: (sql, values) => track(txClient.query(sql, values), sql) },
+			clearError: () => {
+				firstError = void 0;
+			},
+			drain: async () => {
+				while (pending.size > 0) await Promise.allSettled([...pending]);
+			},
+			getError: () => firstError,
+			getUnconfirmedError: () => firstUnconfirmedError
+		};
+	};
+	const assertCommitted = (result, transactionState) => {
+		if (result.command === "COMMIT") return;
+		const queryError = transactionState?.getError() ?? transactionState?.getUnconfirmedError();
+		if (queryError !== void 0) throw queryError;
+		throw new DatabaseError("PostgreSQL rolled back the transaction at commit", { command: result.command });
+	};
 	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");
+			const commitResult = await txClient.query("COMMIT");
+			assertCommitted(commitResult);
 			releaseTxClient(txClient);
 			return result;
 		} catch (error) {
@@ -2567,34 +2730,14 @@ async function createDatabase(config) {
 	* Binding a client is the only difference between the two, so it is the only
 	* thing this factory parameterizes.
 	*
-	* One thing is deliberately NOT unified: how `insert` and `update` serialize
-	* values. The pool-backed methods run every value through `serializeRecord`,
-	* which JSON-stringifies objects and arrays; the transaction-scoped copies
-	* never did, so they handed the raw value to `pg`. That is not a cosmetic
-	* difference — it decides what lands in the column, and no single answer is
-	* right for both shapes:
-	*
-	* ```
-	*                    text[] column     jsonb column
-	*   raw JS array     accepted          "invalid input syntax for type json"
-	*   JSON string      "malformed        accepted
-	*                     array literal"
-	* ```
-	*
-	* So collapsing the two would have silently broken array-column writes inside
-	* a transaction while fixing jsonb-array writes, or the reverse — and would
-	* have corrupted `bytea` writes, where a Buffer would become the JSON of a
-	* Buffer with no error anywhere. Neither belongs in a fix for the error
-	* contract, so the serializer is a parameter: each interface keeps exactly
-	* the behaviour it had, and the difference is stated here instead of being an
-	* accident of two copies drifting apart.
-	*
 	* @param executor - Pool or checked-out client every statement runs on
 	* @param inTransaction - Whether `executor` is already inside a transaction
 	* @param serialize - Applied to each record before `insert`/`update` builds
-	*   its SQL. Pass-through for the transaction-scoped interfaces.
+	*   its SQL
+	* @param clearTransactionError - Clears a statement error after a savepoint
+	*   has successfully restored the transaction to a usable state
 	*/
-	const createClientMethods = (executor, inTransaction, serialize) => {
+	const createClientMethods = (executor, inTransaction, serialize, clearTransactionError = () => {}) => {
 		/**
 		* Inserts one or more records into a table
 		*
@@ -2980,6 +3123,7 @@ async function createDatabase(config) {
 				return result;
 			} catch (error) {
 				await executor.query(`ROLLBACK TO SAVEPOINT ${name}`);
+				clearTransactionError();
 				await executor.query(`RELEASE SAVEPOINT ${name}`);
 				throw error;
 			}
@@ -3143,26 +3287,27 @@ async function createDatabase(config) {
 	* rather than on a lock, so `deadlock_timeout` never fires and the process
 	* hangs until some unrelated timeout.
 	*
-	* @param txClient - The client running the enclosing transaction
+	* @param executor - Error-preserving executor bound to the enclosing client
 	* @param scopeFor - Builds the interface handed to the nested callback
 	*/
-	const createNestedTransaction = (txClient, scopeFor) => {
+	const createNestedTransaction = (executor, scopeFor, clearTransactionError) => {
 		const nestedScope = new AsyncLocalStorage();
 		const rootScope = { tail: Promise.resolve() };
 		const runScope = async (scope, callback) => {
 			savepointSequence += 1;
 			const name = `hv_sp_${savepointSequence}`;
-			await txClient.query(`SAVEPOINT ${name}`);
+			await executor.query(`SAVEPOINT ${name}`);
 			try {
 				const result = await callback(scopeFor());
 				await scope.tail;
-				await txClient.query(`RELEASE SAVEPOINT ${name}`);
+				await executor.query(`RELEASE SAVEPOINT ${name}`);
 				return result;
 			} catch (error) {
 				await scope.tail;
 				try {
-					await txClient.query(`ROLLBACK TO SAVEPOINT ${name}`);
-					await txClient.query(`RELEASE SAVEPOINT ${name}`);
+					await executor.query(`ROLLBACK TO SAVEPOINT ${name}`);
+					clearTransactionError();
+					await executor.query(`RELEASE SAVEPOINT ${name}`);
 				} catch {}
 				throw error;
 			}
@@ -3187,23 +3332,29 @@ async function createDatabase(config) {
 	const transaction = async (callback) => {
 		const txClient = await acquireTxClient();
 		let nestedTransaction;
+		const transactionState = createTransactionExecutor(txClient);
 		try {
 			await txClient.query("BEGIN");
 			let txDb;
-			nestedTransaction = createNestedTransaction(txClient, () => txDb);
+			nestedTransaction = createNestedTransaction(transactionState.executor, () => txDb, transactionState.clearError);
 			txDb = {
 				url,
-				client: txClient,
-				...createClientMethods(txClient, true, passThroughRecord),
+				client: transactionState.client,
+				...createClientMethods(transactionState.executor, true, serializeRecord, transactionState.clearError),
 				transaction: nestedTransaction
 			};
 			const result = await callback(txDb);
 			await nestedTransaction.drain();
-			await txClient.query("COMMIT");
+			await transactionState.drain();
+			const statementError = transactionState.getError();
+			if (statementError !== void 0) throw statementError;
+			const commitResult = await txClient.query("COMMIT");
+			assertCommitted(commitResult, transactionState);
 			releaseTxClient(txClient);
 			return result;
 		} catch (error) {
 			await nestedTransaction?.drain();
+			await transactionState.drain();
 			const rollbackError = await discardTxClient(txClient);
 			if (rollbackError !== void 0 && error instanceof Error) error.cause ??= rollbackError;
 			throw error;
@@ -3227,11 +3378,16 @@ async function createDatabase(config) {
 		}
 		let active = true;
 		let nestedTransaction;
+		const transactionState = createTransactionExecutor(txClient);
 		const end = async (command) => {
 			if (!active) throw new DatabaseError("Transaction already ended", {});
 			try {
 				await nestedTransaction?.drain();
-				await txClient.query(command);
+				await transactionState.drain();
+				const statementError = transactionState.getError();
+				if (command === "COMMIT" && statementError !== void 0) throw statementError;
+				const result = await txClient.query(command);
+				if (command === "COMMIT") assertCommitted(result, transactionState);
 				active = false;
 				releaseTxClient(txClient);
 			} catch (error) {
@@ -3245,11 +3401,11 @@ async function createDatabase(config) {
 		const rollback = () => end("ROLLBACK");
 		const isActive = () => active;
 		let txHandle;
-		nestedTransaction = createNestedTransaction(txClient, () => txHandle);
+		nestedTransaction = createNestedTransaction(transactionState.executor, () => txHandle, transactionState.clearError);
 		txHandle = {
 			url,
-			client: txClient,
-			...createClientMethods(txClient, true, passThroughRecord),
+			client: transactionState.client,
+			...createClientMethods(transactionState.executor, true, serializeRecord, transactionState.clearError),
 			transaction: nestedTransaction,
 			commit,
 			rollback,