kern-orm 0.7.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 not, C as countType, D as literal, E as toAggregateType, M as combineNodes, O as and, S as countProjection, T as createCountCall, _ as createTableFactory, a as defineSchema, b as RequiredRelationError, c as requireDerived, d as desc, f as orderBy, g as createStatement, h as one, i as sql, j as or, k as isColumnValues, l as addTerms, m as many, n as identifier, o as SelectQuery, p as matchColumn, r as param, s as from, t as createDatabase, u as asc, v as defineTable, w as createAggregateCall, x as ResultDecodeError, y as NotFoundError } from "./database-B7Kf5Q9X.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 { FALSE, NotFoundError, 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, 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 { B as PendingTestFixture, G as createTestHelpers, H as TestHelpers, Ni as Driver, U as TestHooks, V as TestFixture, W as TestTransactionOptions, z as OpenedTestFixture } from "./index-CLKi9gZL.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. */
@@ -7,8 +7,6 @@ interface DriverContractOptions {
   }): Driver;
   /** Creates a driver over a new client of the test database whose parsers of result values throw; for a client without parsers, the same as `createDriver`. */
   createDriverWithFailingParsers(): Driver;
-  /** Whether the client can close a reserved connection, so that the driver gets rid of a connection left in a transaction or lost; `false` leaves out the tests of it. */
-  closesReservedConnections: boolean;
 }
 /**
  * Functions of a test runner that declare the tests of `describeDriverContract`.
@@ -25,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 { O as and, a as defineSchema, g as createStatement, i as sql, r as param, t as createDatabase, v as defineTable } from "./database-B7Kf5Q9X.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;
@@ -36,14 +36,14 @@ function createTestHelpers(database, hooks) {
 	};
 }
 // src/execution/driver-contract.ts
-/** Creates helpers that run raw statements on `database`. */
-function createStatementRunners(database) {
+/** Creates helpers that run raw statements on `target`: a database, a driver, or a reserved connection. */
+function createStatementRunners(target) {
 	return {
 		async runStatement(text) {
-			await database.execute(createStatement(text));
+			await target.execute(createStatement(text));
 		},
 		async selectValue(text, parameters = []) {
-			const { rows } = await database.execute(createStatement(text, parameters));
+			const { rows } = await target.execute(createStatement(text, parameters));
 			return rows[0][0];
 		}
 	};
@@ -54,12 +54,14 @@ function createStatementRunners(database) {
 * They run in the empty database of its clients and leave it unchanged.
 */
 function describeDriverContract(options, runner) {
-	const { createDriver, createDriverWithFailingParsers, closesReservedConnections } = options;
+	const { createDriver, createDriverWithFailingParsers } = options;
 	const { describe, it, before, after } = runner;
 	describe("driver contract", () => {
-		const database = createDatabase({ driver: createDriver({ max: 2 }) });
+		const driver = createDriver({ max: 2 });
+		const database = createDatabase({ driver });
 		after(() => database.close());
 		const { runStatement, selectValue } = createStatementRunners(database);
+		const { selectValue: selectValueOnDriver } = createStatementRunners(driver);
 		it("executes a query in a transaction", async () => {
 			const tag = defineTable("pg_tag_test", {
 				id: integer,
@@ -91,6 +93,18 @@ function describeDriverContract(options, runner) {
 				await database.script("SET LOCAL client_min_messages = warning; DROP TABLE IF EXISTS pg_statement_test");
 			}
 		});
+		it("returns every value as text", async () => {
+			const { rows } = await driver.execute(createStatement(`SELECT 42::integer, 12345678901234::bigint, true, '{"a":1}'::jsonb, NULL::text, ARRAY['a', 'b'], '2030-01-01 12:00'::timestamp`));
+			assert.deepEqual(rows, [[
+				"42",
+				"12345678901234",
+				"t",
+				"{\"a\": 1}",
+				null,
+				"{a,b}",
+				"2030-01-01 12:00:00"
+			]]);
+		});
 		it("keeps the values of a statement as text without the parsers of the client", async () => {
 			const parsed = createDatabase({ driver: createDriverWithFailingParsers() });
 			try {
@@ -110,7 +124,7 @@ function describeDriverContract(options, runner) {
 		});
 		it("executes a script on the pool in one implicit transaction", async () => {
 			try {
-				await assert.rejects(database.script("CREATE TABLE pg_script_pool_test (id integer); SELECT 1/0"), /division by zero/);
+				await assert.rejects(database.script("CREATE TABLE pg_script_pool_test (id integer); SELECT 1/0"), (error) => error instanceof QueryError && error.code === "22012");
 				assert.equal(await selectValue("SELECT to_regclass('pg_script_pool_test')::text"), null);
 			} finally {
 				await database.script("SET LOCAL client_min_messages = warning; DROP TABLE IF EXISTS pg_script_pool_test");
@@ -156,6 +170,10 @@ function describeDriverContract(options, runner) {
 			assert.equal(await selectValue("SELECT $1", ["text"]), "text");
 			assert.equal(await selectValue("SELECT $1::text IS NULL", [null]), "t");
 		});
+		it("sends a parameter as it is, whatever type PostgreSQL describes for it", async () => {
+			assert.equal(await selectValueOnDriver("SELECT $1::boolean", ["true"]), "t");
+			assert.equal(await selectValueOnDriver("SELECT $1::jsonb ->> 'a'", ["{\"a\":\"x\"}"]), "x");
+		});
 		it("runs concurrent statements of a transaction in the order of calls", async () => {
 			const values = await database.transaction(() => Promise.all([
 				selectValue("SELECT set_config('kern.test', '1', true) FROM pg_sleep(0.05)"),
@@ -170,6 +188,28 @@ function describeDriverContract(options, runner) {
 				"2"
 			]);
 		});
+		it("runs the statements sent on a reserved connection before ROLLBACK inside its transaction", async () => {
+			const own = createDriver({ max: 1 });
+			try {
+				const connection = await own.acquire();
+				const { runStatement, selectValue } = createStatementRunners(connection);
+				try {
+					await runStatement("CREATE TEMP TABLE pg_order_test (id integer)");
+					await runStatement("BEGIN");
+					await Promise.all([
+						runStatement("INSERT INTO pg_order_test VALUES (1)"),
+						runStatement("SELECT pg_sleep(0.05)"),
+						runStatement("INSERT INTO pg_order_test VALUES (2)"),
+						runStatement("ROLLBACK")
+					]);
+					assert.equal(await selectValue("SELECT count(*) FROM pg_order_test"), "0");
+				} finally {
+					await connection.release();
+				}
+			} finally {
+				await own.close();
+			}
+		});
 		it("decodes selected expressions with their types", async () => {
 			const tag = defineTable("pg_tag_test", {
 				id: integer,
@@ -201,6 +241,33 @@ function describeDriverContract(options, runner) {
 				length: null
 			}]);
 		});
+		it("rejects a statement that PostgreSQL rejected with QueryError and keeps its connection, on the pool and on a reserved connection", async () => {
+			const own = createDriver({ max: 1 });
+			try {
+				const pool = createStatementRunners(own);
+				await pool.runStatement("CREATE TEMP TABLE pg_unique_test (id integer CONSTRAINT pg_unique_test_key UNIQUE)");
+				await pool.runStatement("INSERT INTO pg_unique_test VALUES (1)");
+				const pid = await pool.selectValue("SELECT pg_backend_pid()");
+				/** Asserts that inserting a duplicate on `target` rejects with the violated constraint, and that its connection stays the same. */
+				async function assertRejected(target) {
+					const runners = createStatementRunners(target);
+					const error = await runners.runStatement("INSERT INTO pg_unique_test VALUES (1)").catch((error) => error);
+					assert.ok(error instanceof QueryError, `Expected QueryError, got ${String(error)}`);
+					assert.equal(error.code, "23505");
+					assert.equal(error.constraint, "pg_unique_test_key");
+					assert.equal(await runners.selectValue("SELECT pg_backend_pid()"), pid);
+				}
+				await assertRejected(own);
+				const connection = await own.acquire();
+				try {
+					await assertRejected(connection);
+				} finally {
+					await connection.release();
+				}
+			} finally {
+				await own.close();
+			}
+		});
 		it("rejects a transaction whose failed statement the callback caught", async () => {
 			const transaction = database.transaction(async () => {
 				await runStatement("SELECT 1/0").catch(() => {});
@@ -221,47 +288,119 @@ 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 (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 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 {
+					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 connection.release();
+				}
+			} finally {
+				await own.close();
+			}
+		});
+		it("replaces an idle connection whose backend exited", async () => {
+			const own = createDriver({ max: 2 });
+			const held = [];
+			try {
+				for (let count = 0; count < 2; count++) held.push(await own.acquire());
+				const pids = [];
+				for (const connection of held) pids.push(await createStatementRunners(connection).selectValue("SELECT pg_backend_pid()"));
+				while (held.length > 0) await held.shift().release();
+				for (const pid of pids) assert.equal(await selectValue("SELECT pg_terminate_backend($1, 5000)", [pid]), "t");
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				assert.equal(await createStatementRunners(own).selectValue("SELECT 'usable'"), "usable");
+			} finally {
+				await Promise.allSettled(held.map(async (connection) => connection.release()));
+				await own.close();
+			}
+		});
 		it("isolates concurrent transactions on their own connections", async () => {
 			const bothStarted = Promise.withResolvers();
 			let startedCount = 0;
@@ -353,15 +492,15 @@ function describeDriverContract(options, runner) {
 				assert.equal(await query, "slept");
 				assert.deepEqual(settled, ["query", "database"]);
 			});
-			it("rejects a statement, a script, and a connection requested right after it starts", async () => {
+			it("rejects a statement, a script, and a connection requested right after it starts with ConnectionError", async () => {
 				const driver = createDriver({ max: 1 });
 				const held = await driver.acquire();
 				const closing = driver.close();
 				const acquiring = driver.acquire();
 				const rejections = [
-					assert.rejects(driver.execute(createStatement("SELECT 1"))),
-					assert.rejects(driver.executeScript("SELECT 1")),
-					assert.rejects(acquiring)
+					assert.rejects(driver.execute(createStatement("SELECT 1")), ConnectionError),
+					assert.rejects(driver.executeScript("SELECT 1"), ConnectionError),
+					assert.rejects(acquiring, ConnectionError)
 				];
 				acquiring.then((connection) => connection.release()).catch(() => {});
 				await held.release();

package/dist/types.d.mts

@@ -1,4 +1,4 @@
-import { Gr as InSignature, Hr as EqualityOperator, Jr as ComparisonSignature, S as AnyExpression, Ur as EqualityOperators, Vi as Type, Wr as HasEquality, _ as TextOperators, b as NumberTypeOperators, ea as MergeOperators, na as OperatorDefinitions, ra as GenericOperator, ta as NoOperators, v as TextTypeOperators, zi as BaseType } from "./index-CLKi9gZL.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.
  *