kern-orm 0.8.0 → 0.9.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { B as noOrder, C as toNode, D as isType, E as defineType, F as createNode, L as falseNode, N as defineGenericOperator, P as createList, S as toFunctionOperandNode, T as getBooleanType, U as trueNode, _ as isOperandSource, b as toCastValueNode, c as textOperators, d as orderingOperators, f as compare, g as isExpression, h as getType, k as equalityOperators, v as operandNode, x as toExpression, y as toBooleanExpression } from "./text-CIUxPWPl.mjs";
-import { A as literal, C as RequiredRelationError, D as createAggregateCall, E as countType, F as combineNodes, M as isColumnValues, N as not, O as createCountCall, P as or, S as NotFoundError, T as countProjection, _ as many, a as identifier, b as createTableFactory, c as defineSchema, d as requireDerived, f as addTerms, g as matchColumn, h as orderBy, i as createDatabase, j as and, k as toAggregateType, l as SelectQuery, m as desc, n as QueryError, o as param, p as asc, r as toDriverError, s as sql, t as ConnectionError, u as from, v as one, w as ResultDecodeError, x as defineTable, y as createStatement } from "./driver-error-Dx5R83Rp.mjs";
+import { A as toAggregateType, C as NotFoundError, D as countType, E as countProjection, F as or, I as combineNodes, M as and, N as isColumnValues, O as createAggregateCall, P as not, S as defineTable, T as ResultDecodeError, _ as matchColumn, a as toDriverError, b as createStatement, c as sql, d as from, f as requireDerived, g as orderBy, h as desc, i as QueryError, j as literal, k as createCountCall, l as defineSchema, m as asc, n as TransactionConnectionError, o as identifier, p as addTerms, r as ConnectionError, s as param, t as createDatabase, u as SelectQuery, v as many, w as RequiredRelationError, x as createTableFactory, y as one } from "./database-t66EaIGE.mjs";
 // src/expression/constants.ts
 /** Condition that always holds, such as for a branch of `and` built in code: `and(check, isAdmin ? TRUE : other)`. */
 const TRUE = /* @__PURE__ */ toExpression(trueNode, /* @__PURE__ */ getBooleanType());
@@ -127,6 +127,277 @@ function readFilter(options, method) {
 	if (!isOperandSource(filter)) throw new TypeError(`The filter of ${method} must be an expression or a query of one Boolean value`);
 	return filter[operandNode]();
 }
+// src/execution/error-condition-codes.ts
+/**
+* Condition names of the SQLSTATE codes of PostgreSQL errors, by code: the codes of type `E` with a condition name, which PL/pgSQL takes in `EXCEPTION WHEN`, under the headings of their classes.
+*
+* A code that ends in `000` is the condition of its class.
+* A few names have two codes, such as `null_value_not_allowed`.
+*/
+const conditionsByCode = {
+	"03000": "sql_statement_not_yet_complete",
+	"08000": "connection_exception",
+	"08003": "connection_does_not_exist",
+	"08006": "connection_failure",
+	"08001": "sqlclient_unable_to_establish_sqlconnection",
+	"08004": "sqlserver_rejected_establishment_of_sqlconnection",
+	"08007": "transaction_resolution_unknown",
+	"08P01": "protocol_violation",
+	"09000": "triggered_action_exception",
+	"0A000": "feature_not_supported",
+	"0B000": "invalid_transaction_initiation",
+	"0F000": "locator_exception",
+	"0F001": "invalid_locator_specification",
+	"0L000": "invalid_grantor",
+	"0LP01": "invalid_grant_operation",
+	"0P000": "invalid_role_specification",
+	"0Z000": "diagnostics_exception",
+	"0Z002": "stacked_diagnostics_accessed_without_active_handler",
+	"10608": "invalid_argument_for_xquery",
+	"20000": "case_not_found",
+	"21000": "cardinality_violation",
+	"22000": "data_exception",
+	"2202E": "array_subscript_error",
+	"22021": "character_not_in_repertoire",
+	"22008": "datetime_field_overflow",
+	"22012": "division_by_zero",
+	"22005": "error_in_assignment",
+	"2200B": "escape_character_conflict",
+	"22022": "indicator_overflow",
+	"22015": "interval_field_overflow",
+	"2201E": "invalid_argument_for_logarithm",
+	"22014": "invalid_argument_for_ntile_function",
+	"22016": "invalid_argument_for_nth_value_function",
+	"2201F": "invalid_argument_for_power_function",
+	"2201G": "invalid_argument_for_width_bucket_function",
+	"22018": "invalid_character_value_for_cast",
+	"22007": "invalid_datetime_format",
+	"22019": "invalid_escape_character",
+	"2200D": "invalid_escape_octet",
+	"22025": "invalid_escape_sequence",
+	"22P06": "nonstandard_use_of_escape_character",
+	"22010": "invalid_indicator_parameter_value",
+	"22023": "invalid_parameter_value",
+	"22013": "invalid_preceding_or_following_size",
+	"2201B": "invalid_regular_expression",
+	"2201W": "invalid_row_count_in_limit_clause",
+	"2201X": "invalid_row_count_in_result_offset_clause",
+	"2202H": "invalid_tablesample_argument",
+	"2202G": "invalid_tablesample_repeat",
+	"22009": "invalid_time_zone_displacement_value",
+	"2200C": "invalid_use_of_escape_character",
+	"2200G": "most_specific_type_mismatch",
+	"22004": "null_value_not_allowed",
+	"22002": "null_value_no_indicator_parameter",
+	"22003": "numeric_value_out_of_range",
+	"2200H": "sequence_generator_limit_exceeded",
+	"22026": "string_data_length_mismatch",
+	"22001": "string_data_right_truncation",
+	"22011": "substring_error",
+	"22027": "trim_error",
+	"22024": "unterminated_c_string",
+	"2200F": "zero_length_character_string",
+	"22P01": "floating_point_exception",
+	"22P02": "invalid_text_representation",
+	"22P03": "invalid_binary_representation",
+	"22P04": "bad_copy_file_format",
+	"22P05": "untranslatable_character",
+	"2200L": "not_an_xml_document",
+	"2200M": "invalid_xml_document",
+	"2200N": "invalid_xml_content",
+	"2200S": "invalid_xml_comment",
+	"2200T": "invalid_xml_processing_instruction",
+	"22030": "duplicate_json_object_key_value",
+	"22031": "invalid_argument_for_sql_json_datetime_function",
+	"22032": "invalid_json_text",
+	"22033": "invalid_sql_json_subscript",
+	"22034": "more_than_one_sql_json_item",
+	"22035": "no_sql_json_item",
+	"22036": "non_numeric_sql_json_item",
+	"22037": "non_unique_keys_in_a_json_object",
+	"22038": "singleton_sql_json_item_required",
+	"22039": "sql_json_array_not_found",
+	"2203A": "sql_json_member_not_found",
+	"2203B": "sql_json_number_not_found",
+	"2203C": "sql_json_object_not_found",
+	"2203D": "too_many_json_array_elements",
+	"2203E": "too_many_json_object_members",
+	"2203F": "sql_json_scalar_required",
+	"2203G": "sql_json_item_cannot_be_cast_to_target_type",
+	"23000": "integrity_constraint_violation",
+	"23001": "restrict_violation",
+	"23502": "not_null_violation",
+	"23503": "foreign_key_violation",
+	"23505": "unique_violation",
+	"23514": "check_violation",
+	"23P01": "exclusion_violation",
+	"24000": "invalid_cursor_state",
+	"25000": "invalid_transaction_state",
+	"25001": "active_sql_transaction",
+	"25002": "branch_transaction_already_active",
+	"25008": "held_cursor_requires_same_isolation_level",
+	"25003": "inappropriate_access_mode_for_branch_transaction",
+	"25004": "inappropriate_isolation_level_for_branch_transaction",
+	"25005": "no_active_sql_transaction_for_branch_transaction",
+	"25006": "read_only_sql_transaction",
+	"25007": "schema_and_data_statement_mixing_not_supported",
+	"25P01": "no_active_sql_transaction",
+	"25P02": "in_failed_sql_transaction",
+	"25P03": "idle_in_transaction_session_timeout",
+	"25P04": "transaction_timeout",
+	"26000": "invalid_sql_statement_name",
+	"27000": "triggered_data_change_violation",
+	"28000": "invalid_authorization_specification",
+	"28P01": "invalid_password",
+	"2B000": "dependent_privilege_descriptors_still_exist",
+	"2BP01": "dependent_objects_still_exist",
+	"2D000": "invalid_transaction_termination",
+	"2F000": "sql_routine_exception",
+	"2F005": "function_executed_no_return_statement",
+	"2F002": "modifying_sql_data_not_permitted",
+	"2F003": "prohibited_sql_statement_attempted",
+	"2F004": "reading_sql_data_not_permitted",
+	"34000": "invalid_cursor_name",
+	"38000": "external_routine_exception",
+	"38001": "containing_sql_not_permitted",
+	"38002": "modifying_sql_data_not_permitted",
+	"38003": "prohibited_sql_statement_attempted",
+	"38004": "reading_sql_data_not_permitted",
+	"39000": "external_routine_invocation_exception",
+	"39001": "invalid_sqlstate_returned",
+	"39004": "null_value_not_allowed",
+	"39P01": "trigger_protocol_violated",
+	"39P02": "srf_protocol_violated",
+	"39P03": "event_trigger_protocol_violated",
+	"3B000": "savepoint_exception",
+	"3B001": "invalid_savepoint_specification",
+	"3D000": "invalid_catalog_name",
+	"3F000": "invalid_schema_name",
+	"40000": "transaction_rollback",
+	"40002": "transaction_integrity_constraint_violation",
+	"40001": "serialization_failure",
+	"40003": "statement_completion_unknown",
+	"40P01": "deadlock_detected",
+	"42000": "syntax_error_or_access_rule_violation",
+	"42601": "syntax_error",
+	"42501": "insufficient_privilege",
+	"42846": "cannot_coerce",
+	"42803": "grouping_error",
+	"42P20": "windowing_error",
+	"42P19": "invalid_recursion",
+	"42830": "invalid_foreign_key",
+	"42602": "invalid_name",
+	"42622": "name_too_long",
+	"42939": "reserved_name",
+	"42804": "datatype_mismatch",
+	"42P18": "indeterminate_datatype",
+	"42P21": "collation_mismatch",
+	"42P22": "indeterminate_collation",
+	"42809": "wrong_object_type",
+	"428C9": "generated_always",
+	"42703": "undefined_column",
+	"42883": "undefined_function",
+	"42P01": "undefined_table",
+	"42P02": "undefined_parameter",
+	"42704": "undefined_object",
+	"42701": "duplicate_column",
+	"42P03": "duplicate_cursor",
+	"42P04": "duplicate_database",
+	"42723": "duplicate_function",
+	"42P05": "duplicate_prepared_statement",
+	"42P06": "duplicate_schema",
+	"42P07": "duplicate_table",
+	"42712": "duplicate_alias",
+	"42710": "duplicate_object",
+	"42702": "ambiguous_column",
+	"42725": "ambiguous_function",
+	"42P08": "ambiguous_parameter",
+	"42P09": "ambiguous_alias",
+	"42P10": "invalid_column_reference",
+	"42611": "invalid_column_definition",
+	"42P11": "invalid_cursor_definition",
+	"42P12": "invalid_database_definition",
+	"42P13": "invalid_function_definition",
+	"42P14": "invalid_prepared_statement_definition",
+	"42P15": "invalid_schema_definition",
+	"42P16": "invalid_table_definition",
+	"42P17": "invalid_object_definition",
+	"44000": "with_check_option_violation",
+	"53000": "insufficient_resources",
+	"53100": "disk_full",
+	"53200": "out_of_memory",
+	"53300": "too_many_connections",
+	"53400": "configuration_limit_exceeded",
+	"54000": "program_limit_exceeded",
+	"54001": "statement_too_complex",
+	"54011": "too_many_columns",
+	"54023": "too_many_arguments",
+	"55000": "object_not_in_prerequisite_state",
+	"55006": "object_in_use",
+	"55P02": "cant_change_runtime_param",
+	"55P03": "lock_not_available",
+	"55P04": "unsafe_new_enum_value_usage",
+	"57000": "operator_intervention",
+	"57014": "query_canceled",
+	"57P01": "admin_shutdown",
+	"57P02": "crash_shutdown",
+	"57P03": "cannot_connect_now",
+	"57P04": "database_dropped",
+	"57P05": "idle_session_timeout",
+	"58000": "system_error",
+	"58030": "io_error",
+	"58P01": "undefined_file",
+	"58P02": "duplicate_file",
+	"58P03": "file_name_too_long",
+	F0000: "config_file_error",
+	F0001: "lock_file_exists",
+	HV000: "fdw_error",
+	HV005: "fdw_column_name_not_found",
+	HV002: "fdw_dynamic_parameter_value_needed",
+	HV010: "fdw_function_sequence_error",
+	HV021: "fdw_inconsistent_descriptor_information",
+	HV024: "fdw_invalid_attribute_value",
+	HV007: "fdw_invalid_column_name",
+	HV008: "fdw_invalid_column_number",
+	HV004: "fdw_invalid_data_type",
+	HV006: "fdw_invalid_data_type_descriptors",
+	HV091: "fdw_invalid_descriptor_field_identifier",
+	HV00B: "fdw_invalid_handle",
+	HV00C: "fdw_invalid_option_index",
+	HV00D: "fdw_invalid_option_name",
+	HV090: "fdw_invalid_string_length_or_buffer_length",
+	HV00A: "fdw_invalid_string_format",
+	HV009: "fdw_invalid_use_of_null_pointer",
+	HV014: "fdw_too_many_handles",
+	HV001: "fdw_out_of_memory",
+	HV00P: "fdw_no_schemas",
+	HV00J: "fdw_option_name_not_found",
+	HV00K: "fdw_reply_handle",
+	HV00Q: "fdw_schema_not_found",
+	HV00R: "fdw_table_not_found",
+	HV00L: "fdw_unable_to_create_execution",
+	HV00M: "fdw_unable_to_create_reply",
+	HV00N: "fdw_unable_to_establish_connection",
+	P0000: "plpgsql_error",
+	P0001: "raise_exception",
+	P0002: "no_data_found",
+	P0003: "too_many_rows",
+	P0004: "assert_failure",
+	XX000: "internal_error",
+	XX001: "data_corrupted",
+	XX002: "index_corrupted"
+};
+// src/execution/error-condition.ts
+/**
+* Tells whether `error` is a `QueryError` of `condition`, including a `QueryError` of another copy of kern-orm.
+*
+* The condition of a class, such as `integrity_constraint_violation`, matches every error of its class, as in PL/pgSQL.
+*/
+function isQueryError(error, condition) {
+	if (!(error instanceof QueryError)) return false;
+	const conditions = conditionsByCode;
+	return conditions[error.code] === condition || conditions[`${error.code.slice(0, 2)}000`] === condition;
+}
 // src/query/reusable-expression.ts
 function defineExpression(_table, expression) {
 	return expression;
@@ -157,4 +428,4 @@ const wordStart = /(?<=[\p{Ll}\p{N}])(?=\p{Lu})|(?<=\p{Lu})(?=\p{Lu}(?!s$)\p{Ll}
 function toSnakeCase(key) {
 	return key.replace(wordStart, "_").toLowerCase();
 }
-export { ConnectionError, FALSE, NotFoundError, QueryError, RequiredRelationError, ResultDecodeError, TRUE, and, asc, avg, caseWhen, coalesce, compare, count, countDistinct, createDatabase, createStatement, createTableFactory, defineExpression, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, every, from, greatest, identifier, least, literal, many, matches, max, min, not, one, or, orderBy, orderingOperators, param, some, sql, stringAgg, sum, textOperators, toDriverError, toSnakeCase };
+export { ConnectionError, FALSE, NotFoundError, QueryError, RequiredRelationError, ResultDecodeError, TRUE, TransactionConnectionError, and, asc, avg, caseWhen, coalesce, compare, count, countDistinct, createDatabase, createStatement, createTableFactory, defineExpression, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, every, from, greatest, identifier, isQueryError, least, literal, many, matches, max, min, not, one, or, orderBy, orderingOperators, param, some, sql, stringAgg, sum, textOperators, toDriverError, toSnakeCase };

package/dist/testing.d.mts

@@ -1,4 +1,4 @@
-import { G as TestFixture, J as TestTransactionOptions, K as TestHelpers, Li as Driver, U as OpenedTestFixture, W as PendingTestFixture, Y as createTestHelpers, q as TestHooks } from "./index-B1aH5Ht0.mjs";
+import { $ as TestHooks, J as OpenedTestFixture, Q as TestHelpers, Ui as Driver, X as TestFixture, Y as PendingTestFixture, Z as TestFixtureOptions, et as TestTransactionOptions, tt as createTestHelpers } from "./index-2z5iTzXf.mjs";
 /** Options of `describeDriverContract`: how to create the driver under test. */
 interface DriverContractOptions {
   /** Creates a driver over a new client of the test database with `max` connections. */
@@ -23,4 +23,4 @@ interface DriverContractRunner extends TestHooks {
  * They run in the empty database of its clients and leave it unchanged.
  */
 export declare function describeDriverContract(options: DriverContractOptions, runner: DriverContractRunner): void;
-export { type DriverContractOptions, type DriverContractRunner, type OpenedTestFixture, type PendingTestFixture, type TestFixture, type TestHelpers, type TestHooks, type TestTransactionOptions, createTestHelpers };
+export { type DriverContractOptions, type DriverContractRunner, type OpenedTestFixture, type PendingTestFixture, type TestFixture, type TestFixtureOptions, type TestHelpers, type TestHooks, type TestTransactionOptions, createTestHelpers };

package/dist/testing.mjs

@@ -1,5 +1,5 @@
 import { n as text, t as char } from "./text-CIUxPWPl.mjs";
-import { c as defineSchema, i as createDatabase, j as and, n as QueryError, o as param, s as sql, t as ConnectionError, x as defineTable, y as createStatement } from "./driver-error-Dx5R83Rp.mjs";
+import { M as and, S as defineTable, b as createStatement, c as sql, i as QueryError, l as defineSchema, n as TransactionConnectionError, r as ConnectionError, s as param, t as createDatabase } from "./database-t66EaIGE.mjs";
 import { _ as timestamptz, a as numeric, b as array, d as jsonb, f as enumOf, g as timestamp, h as time, i as integer, l as inet, m as interval, n as bigint, p as date, r as doublePrecision, t as uuid, v as boolean, y as bytea } from "./types-D3d35qR2.mjs";
 import assert from "node:assert/strict";
 // src/execution/testing.ts
@@ -9,11 +9,11 @@ function createTestHelpers(database, hooks) {
 	if (!coordinator.test) throw new Error("createTestHelpers requires a database created with test: true");
 	return {
 		testTransaction: (callback, options) => coordinator.testTransaction(callback, options),
-		useTestFixture(seed) {
+		useTestFixture(seed, options) {
 			let pending;
 			let fixture;
 			hooks.before(async () => {
-				const current = coordinator.startTestFixture(seed);
+				const current = coordinator.startTestFixture(seed, options);
 				pending = current;
 				try {
 					const opened = await current.fixture;
@@ -193,7 +193,6 @@ function describeDriverContract(options, runner) {
 			try {
 				const connection = await own.acquire();
 				const { runStatement, selectValue } = createStatementRunners(connection);
-				let failure;
 				try {
 					await runStatement("CREATE TEMP TABLE pg_order_test (id integer)");
 					await runStatement("BEGIN");
@@ -204,11 +203,8 @@ function describeDriverContract(options, runner) {
 						runStatement("ROLLBACK")
 					]);
 					assert.equal(await selectValue("SELECT count(*) FROM pg_order_test"), "0");
-				} catch (error) {
-					failure = { error };
-					throw error;
 				} finally {
-					await connection.release(failure);
+					await connection.release();
 				}
 			} finally {
 				await own.close();
@@ -292,72 +288,103 @@ function describeDriverContract(options, runner) {
 				await single.close();
 			}
 		});
-		it("leaves no failed transaction on the pool after a release with its error", async () => {
-			const driver = createDriver({ max: 1 });
+		it("returns a connection to the pool after PostgreSQL rejected its last statement outside a transaction", async () => {
+			const own = createDriver({ max: 1 });
 			try {
-				const connection = await driver.acquire();
-				await connection.execute(createStatement("BEGIN"));
-				const error = await connection.execute(createStatement("SELECT 1/0")).catch((error) => error);
-				await connection.release({ error });
-				await assert.rejects(driver.execute(createStatement("SAVEPOINT probe")), /transaction blocks/);
+				const connection = await own.acquire();
+				let pid;
+				try {
+					pid = await createStatementRunners(connection).selectValue("SELECT pg_backend_pid()");
+					await assert.rejects(connection.execute(createStatement("SELECT 1/0")), QueryError);
+				} finally {
+					await connection.release();
+				}
+				assert.equal(await createStatementRunners(own).selectValue("SELECT pg_backend_pid()"), pid);
 			} finally {
-				await driver.close();
+				await own.close();
 			}
 		});
-		if (driver.closesReservedConnections) {
-			for (const [state, text] of [["an open", "SELECT 1"], ["a failed", "SELECT 1/0"]]) it(`does not return a connection in ${state} transaction to the pool`, async () => {
-				const driver = createDriver({ max: 1 });
+		for (const [state, text] of [["an open", "SELECT 1"], ["a failed", "SELECT 1/0"]]) it(`does not return a connection in ${state} transaction to the pool`, async () => {
+			const own = createDriver({ max: 1 });
+			try {
+				const connection = await own.acquire();
 				try {
-					const connection = await driver.acquire();
 					await connection.execute(createStatement("BEGIN"));
 					await connection.execute(createStatement(text)).catch(() => {});
-					await connection.release({ error: /* @__PURE__ */ new Error("failure") });
-					await assert.rejects(driver.execute(createStatement("SAVEPOINT probe")), /transaction blocks/);
 				} finally {
-					await driver.close();
+					await connection.release();
 				}
-			});
-			it("rejects a transaction whose connection is lost and keeps the pool usable", async () => {
-				const single = createDatabase({ driver: createDriver({ max: 1 }) });
-				const { selectValue: selectValueOnSingle } = createStatementRunners(single);
+				await assert.rejects(own.execute(createStatement("SAVEPOINT probe")), /transaction blocks/);
+			} finally {
+				await own.close();
+			}
+		});
+		describe("a statement on the pool that leaves a transaction open", () => {
+			const cases = [
+				[
+					"a statement",
+					(own) => own.execute(createStatement("BEGIN")),
+					ConnectionError
+				],
+				[
+					"a script",
+					(own) => own.executeScript("BEGIN; SELECT 1"),
+					ConnectionError
+				],
+				[
+					"a script that fails in the transaction",
+					(own) => own.executeScript("BEGIN; SELECT 1/0"),
+					Error
+				]
+			];
+			for (const [name, run, rejection] of cases) it(`rejects ${name} and leaves no transaction on the pool`, async () => {
+				const own = createDriver({ max: 2 });
+				const held = [];
 				try {
-					const transaction = single.transaction(async () => {
-						const pid = await selectValueOnSingle("SELECT pg_backend_pid()");
-						await selectValue("SELECT pg_terminate_backend($1)", [pid]);
-						await selectValueOnSingle("SELECT 1");
-					});
-					await assert.rejects(transaction, /Transaction rollback failed/);
-					assert.equal(await single.transaction(() => selectValueOnSingle("SELECT 'usable'")), "usable");
+					await assert.rejects(run(own), rejection);
+					for (let count = 0; count < 2; count++) held.push(await own.acquire());
+					for (const connection of held) await assert.rejects(connection.execute(createStatement("SAVEPOINT probe")), /transaction blocks/);
 				} finally {
-					await single.close();
+					await Promise.allSettled(held.map(async (connection) => connection.release()));
+					await own.close();
 				}
 			});
-			it("rejects a statement of a transaction whose connection is lost with ConnectionError", async () => {
-				const own = createDriver({ max: 1 });
+		});
+		it("rejects a transaction whose connection is lost and keeps the pool usable", async () => {
+			const single = createDatabase({ driver: createDriver({ max: 1 }) });
+			const { selectValue: selectValueOnSingle } = createStatementRunners(single);
+			try {
+				const transaction = single.transaction(async () => {
+					const pid = await selectValueOnSingle("SELECT pg_backend_pid()");
+					await selectValue("SELECT pg_terminate_backend($1)", [pid]);
+					await selectValueOnSingle("SELECT 1");
+				});
+				await assert.rejects(transaction, (error) => error instanceof TransactionConnectionError && error.phase === "transaction");
+				assert.equal(await single.transaction(() => selectValueOnSingle("SELECT 'usable'")), "usable");
+			} finally {
+				await single.close();
+			}
+		});
+		it("rejects a statement of a transaction whose connection is lost with ConnectionError", async () => {
+			const own = createDriver({ max: 1 });
+			try {
+				const connection = await own.acquire();
+				const { runStatement, selectValue: selectValueOnConnection } = createStatementRunners(connection);
 				try {
-					const connection = await own.acquire();
-					const { runStatement, selectValue: selectValueOnConnection } = createStatementRunners(connection);
-					let failure;
-					try {
-						await runStatement("BEGIN");
-						await runStatement("CREATE TEMP TABLE pg_lost_test (id integer) ON COMMIT DROP");
-						const pid = await selectValueOnConnection("SELECT pg_backend_pid()");
-						assert.equal(await selectValue("SELECT pg_terminate_backend($1, 5000)", [pid]), "t");
-						await new Promise((resolve) => setTimeout(resolve, 50));
-						const error = await runStatement("INSERT INTO pg_lost_test VALUES (1)").catch((error) => error);
-						failure = { error };
-						assert.ok(error instanceof ConnectionError, `Expected ConnectionError, got ${String(error)}`);
-					} catch (error) {
-						failure ??= { error };
-						throw error;
-					} finally {
-						await connection.release(failure);
-					}
+					await runStatement("BEGIN");
+					await runStatement("CREATE TEMP TABLE pg_lost_test (id integer) ON COMMIT DROP");
+					const pid = await selectValueOnConnection("SELECT pg_backend_pid()");
+					assert.equal(await selectValue("SELECT pg_terminate_backend($1, 5000)", [pid]), "t");
+					await new Promise((resolve) => setTimeout(resolve, 50));
+					const error = await runStatement("INSERT INTO pg_lost_test VALUES (1)").catch((error) => error);
+					assert.ok(error instanceof ConnectionError, `Expected ConnectionError, got ${String(error)}`);
 				} finally {
-					await own.close();
+					await connection.release();
 				}
-			});
-		}
+			} finally {
+				await own.close();
+			}
+		});
 		it("replaces an idle connection whose backend exited", async () => {
 			const own = createDriver({ max: 2 });
 			const held = [];

package/dist/types.d.mts

@@ -1,4 +1,4 @@
-import { E as AnyExpression, Gi as Type, Jr as HasEquality, Kr as EqualityOperator, Qr as ComparisonSignature, S as TextTypeOperators, Ui as BaseType, Yr as InSignature, aa as NoOperators, ia as MergeOperators, oa as OperatorDefinitions, qr as EqualityOperators, sa as GenericOperator, w as NumberTypeOperators, x as TextOperators } from "./index-B1aH5Ht0.mjs";
+import { $r as EqualityOperators, A as AnyExpression, E as TextTypeOperators, Ji as BaseType, O as NumberTypeOperators, Qr as EqualityOperator, T as TextOperators, Xi as Type, da as OperatorDefinitions, ei as HasEquality, fa as GenericOperator, ii as ComparisonSignature, la as MergeOperators, ti as InSignature, ua as NoOperators } from "./index-2z5iTzXf.mjs";
 /**
  * Creates a one-dimensional array type of `element` values.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kern-orm",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Fully typed relational query builder for PostgreSQL with ambient transactions and single-query relation loading",
   "keywords": [
     "orm",