kern-db 0.0.0-stage → 0.2.0

package/dist/driver-CSfbXOBJ.d.mts

@@ -0,0 +1,77 @@
+/** PostgreSQL text representation of a value, as a driver sends a parameter and returns a value of a result; `null` is SQL `NULL`. */
+type TextValue = string | null;
+/** SQL statement ready for a driver. */
+interface SqlStatement {
+  readonly text: string;
+  /** Text representations of the parameters; PostgreSQL infers their types from the statement text. */
+  readonly parameters: readonly TextValue[];
+}
+/** Creates a statement from SQL text and the text representations of its parameters, such as `createStatement("BEGIN")`. */
+declare function createStatement(text: string, parameters?: readonly TextValue[]): SqlStatement;
+/** Result of a statement. */
+interface DriverResult {
+  /** Command of the tag that PostgreSQL completed the statement with, such as `SELECT` or `ROLLBACK` for a `COMMIT` of a failed transaction; a driver may give only the first word of a tag of several words, such as `CREATE` of `CREATE TABLE`; `null` for a statement that PostgreSQL completes without a tag, such as an empty text or only a comment. */
+  readonly command: string | null;
+  /** Number of rows that the command tag reports, such as the rows that an `UPDATE` changes, also without `RETURNING`; `0` when PostgreSQL reports none, such as for `BEGIN` or a statement without a command tag. */
+  readonly count: number;
+  /** Names of the result columns in their order, also when the statement returns no rows; none for a statement without result columns, such as `BEGIN` or an `UPDATE` without `RETURNING`. */
+  readonly columns: readonly string[];
+  /** Rows as PostgreSQL text representations of their values, in the order of the result columns. */
+  readonly rows: readonly (readonly TextValue[])[];
+}
+/**
+ * Physical database access: transport, pooling, and connections.
+ *
+ * A driver sends parameters as text without a declared type, so that the statement text alone determines their types, and returns values as text without parsing them.
+ * It rejects with `QueryError` a statement or script that PostgreSQL rejected, whose connection stays usable, and with `ConnectionError` any other failure of a statement, a script, or a connection.
+ */
+interface Driver {
+  /**
+   * Executes a statement on any pooled connection.
+   *
+   * It rejects a statement that leaves its connection in a transaction, such as `BEGIN`, with `ConnectionError`, and leaves no transaction open on the pool.
+   */
+  execute(statement: SqlStatement): Promise<DriverResult>;
+  /**
+   * Executes a script of statements without parameters, such as DDL separated by semicolons, on any pooled connection, where PostgreSQL runs them in one implicit transaction.
+   *
+   * It rejects a script that leaves its connection in a transaction as `execute` rejects such a statement.
+   * A script whose statement PostgreSQL rejected in that transaction may reject with that `QueryError` instead.
+   * Either way, no transaction stays open on the pool.
+   */
+  executeScript(text: string): Promise<void>;
+  /** Reserves a dedicated connection, such as for a transaction or a session. */
+  acquire(): Promise<Connection>;
+  /**
+   * Closes the connections once the statements on the pool and the transactions and sessions on reserved connections end.
+   *
+   * From the call, it rejects a new statement or script on the pool and a new connection with `ConnectionError`.
+   */
+  close(): Promise<void>;
+}
+/**
+ * Checks whether `value` is a driver: an object with the methods of `Driver`, such as to reject a client of PostgreSQL passed instead of its driver.
+ *
+ * It checks the methods rather than a brand, since an application may write a driver of its own.
+ */
+declare function isDriver(value: unknown): value is Driver;
+/** Connection reserved by a driver, such as for a transaction or a session. */
+interface Connection {
+  /**
+   * Executes a statement on the connection.
+   *
+   * Statements and scripts run one at a time in the order of calls, so a statement sent before `COMMIT` or `ROLLBACK` completes before it.
+   * A connection that is lost rejects every later statement and script with `ConnectionError`, in a transaction and outside one, rather than running it on a new connection.
+   */
+  execute(statement: SqlStatement): Promise<DriverResult>;
+  /** Executes a script of statements without parameters on the connection, in the order of calls with its statements. */
+  executeScript(text: string): Promise<void>;
+  /**
+   * Returns the connection to the pool once its statements complete, if PostgreSQL reported an idle transaction status after the last statement; otherwise the driver closes it, which rolls back a transaction left on it.
+   *
+   * The driver tells by itself how the statements on the connection ended.
+   * After a `ConnectionError`, a statement may still run or the connection may be lost, so the driver closes the connection, unless its client refused the statement without breaking the exchange of messages and still reads the status, such as postgres.js 4 for a statement of too many parameters.
+   */
+  release(): void | Promise<void>;
+}
+export { TextValue as a, SqlStatement as i, Driver as n, createStatement as o, DriverResult as r, isDriver as s, Connection as t };

package/dist/driver-error-26zcdHeU.mjs

@@ -0,0 +1,88 @@
+// src/driver-error.ts
+/** Marks an instance of `QueryError` of any copy of kern-db, which `instanceof QueryError` of another copy recognizes. */
+const queryErrorBrand = /* @__PURE__ */ Symbol.for("kern-db.QueryError");
+/** Marks an instance of `ConnectionError` of any copy of kern-db. */
+const connectionErrorBrand = /* @__PURE__ */ Symbol.for("kern-db.ConnectionError");
+/**
+* Tells whether `value` is an instance of `errorClass`: by the brand of any copy of kern-db for `errorClass` itself, and by the prototype chain for its subclasses.
+*
+* An application can load several copies of kern-db, such as when it requires another version of kern-db than kern-orm does, and an error of one copy is then an instance of the class of another.
+*/
+function isInstance(errorClass, root, brand, value) {
+	if (errorClass !== root) return Function.prototype[Symbol.hasInstance].call(errorClass, value);
+	return typeof value === "object" && value !== null && value[brand] === true;
+}
+/** Sets the brand of `error`, which is not enumerable, so that it does not show among the fields of the error. */
+function setBrand(error, brand) {
+	Object.defineProperty(error, brand, { value: true });
+}
+/**
+* Error of a statement that PostgreSQL rejected, such as for a violated constraint; the connection of the statement stays usable.
+*
+* A driver whose client gives the severity of an error only in the language of the server, such as node-postgres, tells such an error by its SQLSTATE when the server translates its messages.
+* An error that ends the session with a code that a statement also gets, such as `40001` of a conflict with recovery on a replica, then rejects with `QueryError`, and the next statement on the connection with `ConnectionError`.
+*/
+var QueryError = class QueryError extends Error {
+	name = "QueryError";
+	/** SQLSTATE of the error, such as `23505` for a violated unique constraint. */
+	code;
+	/** Name of the constraint that the statement violated, if any. */
+	constraint;
+	constructor(message, fields) {
+		super(message, "cause" in fields ? { cause: fields.cause } : void 0);
+		this.code = fields.code;
+		this.constraint = fields.constraint;
+		setBrand(this, queryErrorBrand);
+	}
+	/** Tells whether `value` is an instance of the class, including one of `QueryError` of another copy of kern-db. */
+	static [Symbol.hasInstance](value) {
+		return isInstance(this, QueryError, queryErrorBrand, value);
+	}
+};
+/**
+* Error of a statement or connection that failed for another reason than PostgreSQL rejecting a statement, such as a lost connection, a timeout of the client, or a closed driver.
+*
+* The statement may have run or not, and its connection may be lost or in an unknown state of its transaction.
+*/
+var ConnectionError = class ConnectionError extends Error {
+	name = "ConnectionError";
+	constructor(message, options) {
+		super(message, options);
+		setBrand(this, connectionErrorBrand);
+	}
+	/** Tells whether `value` is an instance of the class, including one of `ConnectionError` of another copy of kern-db. */
+	static [Symbol.hasInstance](value) {
+		return isInstance(this, ConnectionError, connectionErrorBrand, value);
+	}
+};
+/** SQLSTATE of five digits or uppercase letters; clients also give codes of their own, such as `ECONNRESET` or `CONNECTION_CLOSED`. */
+const sqlState = /^[0-9A-Z]{5}$/;
+/** SQLSTATE of an error that ends the session: of the classes of connection exceptions, authorization, operator intervention, and internal errors, and the timeouts of an idle transaction and of a transaction. */
+const sessionEndingCode = /^(?:08|28|57P|XX|25P03$|25P04$)/;
+/** Tells whether an error of the server of `severity` and SQLSTATE `code` ends its session. */
+function isSessionEnding(severity, code) {
+	if (severity === "ERROR") return false;
+	if (severity === "FATAL" || severity === "PANIC") return true;
+	return sessionEndingCode.test(code);
+}
+/**
+* Classifies an error of a client as `QueryError` or `ConnectionError`, by the fields of the PostgreSQL error it carries, for a driver to reject with.
+*
+* An error that kern-db has already classified returns as it is.
+* An error without a severity or a SQLSTATE, such as of a client that lost its connection, is a `ConnectionError`, and so is one of severity `FATAL` or `PANIC`, which ends the session.
+* An error of severity `ERROR` is a `QueryError`.
+* With a translated severity, the SQLSTATE tells an error that ends the session, so a few errors of other codes that end it give `QueryError`.
+*/
+function toDriverError(error, fields) {
+	if (error instanceof QueryError || error instanceof ConnectionError) return error;
+	const message = error instanceof Error ? error.message : String(error);
+	const { severity, code, constraint } = fields ?? {};
+	if (typeof severity !== "string" || typeof code !== "string" || !sqlState.test(code)) return new ConnectionError(message, { cause: error });
+	if (isSessionEnding(severity, code)) return new ConnectionError(message, { cause: error });
+	return new QueryError(message, {
+		code,
+		constraint: typeof constraint === "string" ? constraint : void 0,
+		cause: error
+	});
+}
+export { toDriverError as a, setBrand as i, QueryError as n, isInstance as r, ConnectionError as t };

package/dist/index.d.mts

@@ -0,0 +1,360 @@
+import { a as TextValue, i as SqlStatement, n as Driver, o as createStatement, r as DriverResult, s as isDriver, t as Connection } from "./driver-CSfbXOBJ.mjs";
+import { a as BaseDerivableType, c as Type, d as TypeOutput, f as TypeTransform, h as typeValues, i as AnyType, l as TypeInput, m as isType, n as AcceptedValues, o as DerivableType, p as defineType, r as AnyDerivableType, s as DerivableTypeWithParameters, t as AcceptedNull, u as TypeOptions } from "./type-CbrtxvDF.mjs";
+import { A as OneRow, F as ResultRows, I as ValueRows, M as ResultByRows, N as ResultDecodeError, S as param, T as UntypedValue, _ as isDatabase, a as SqlQuery, b as SqlValue, d as DatabaseOptions, f as IsolationLevel, g as createDatabase, h as TransactionOptions, i as InitialSqlQueryState, j as OneValueRows, k as NotFoundError, m as SessionOptions, n as DecodedFields, o as SqlQueryResult, p as PollLockOptions, r as FieldTypes, s as SqlQueryState, t as AnySqlQuery, u as Database, w as sql, x as identifier, y as SqlFragment } from "./query-BrvYBvWC.mjs";
+/**
+ * Error of a statement that PostgreSQL rejected, such as for a violated constraint; the connection of the statement stays usable.
+ *
+ * A driver whose client gives the severity of an error only in the language of the server, such as node-postgres, tells such an error by its SQLSTATE when the server translates its messages.
+ * An error that ends the session with a code that a statement also gets, such as `40001` of a conflict with recovery on a replica, then rejects with `QueryError`, and the next statement on the connection with `ConnectionError`.
+ */
+export declare class QueryError extends Error {
+  readonly name = "QueryError";
+  /** SQLSTATE of the error, such as `23505` for a violated unique constraint. */
+  readonly code: string;
+  /** Name of the constraint that the statement violated, if any. */
+  readonly constraint: string | undefined;
+  constructor(message: string, fields: {
+    code: string;
+    constraint?: string | undefined;
+    cause?: unknown;
+  });
+  /** Tells whether `value` is an instance of the class, including one of `QueryError` of another copy of kern-db. */
+  static [Symbol.hasInstance]<T>(this: abstract new (...args: never) => T, value: unknown): value is T;
+}
+/**
+ * Error of a statement or connection that failed for another reason than PostgreSQL rejecting a statement, such as a lost connection, a timeout of the client, or a closed driver.
+ *
+ * The statement may have run or not, and its connection may be lost or in an unknown state of its transaction.
+ */
+export declare class ConnectionError extends Error {
+  readonly name: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+  /** Tells whether `value` is an instance of the class, including one of `ConnectionError` of another copy of kern-db. */
+  static [Symbol.hasInstance]<T>(this: abstract new (...args: never) => T, value: unknown): value is T;
+}
+/** Fields of the PostgreSQL error that an error of a client carries, by which `toDriverError` classifies it. */
+interface DriverErrorFields {
+  /**
+   * Severity of the error, such as `ERROR` or `FATAL`.
+   *
+   * Pass the severity in English when the client gives it, and the one in the language of the server otherwise.
+   */
+  readonly severity?: unknown;
+  /** SQLSTATE of the error, such as `23505`. */
+  readonly code?: unknown;
+  /** Name of the constraint that the statement violated. */
+  readonly constraint?: unknown;
+}
+/**
+ * Classifies an error of a client as `QueryError` or `ConnectionError`, by the fields of the PostgreSQL error it carries, for a driver to reject with.
+ *
+ * An error that kern-db has already classified returns as it is.
+ * An error without a severity or a SQLSTATE, such as of a client that lost its connection, is a `ConnectionError`, and so is one of severity `FATAL` or `PANIC`, which ends the session.
+ * An error of severity `ERROR` is a `QueryError`.
+ * With a translated severity, the SQLSTATE tells an error that ends the session, so a few errors of other codes that end it give `QueryError`.
+ */
+export declare function toDriverError(error: unknown, fields?: DriverErrorFields): QueryError | ConnectionError;
+/**
+ * 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`.
+ */
+declare const conditionsByCode: {
+  readonly "03000": "sql_statement_not_yet_complete";
+  readonly "08000": "connection_exception";
+  readonly "08003": "connection_does_not_exist";
+  readonly "08006": "connection_failure";
+  readonly "08001": "sqlclient_unable_to_establish_sqlconnection";
+  readonly "08004": "sqlserver_rejected_establishment_of_sqlconnection";
+  readonly "08007": "transaction_resolution_unknown";
+  readonly "08P01": "protocol_violation";
+  readonly "09000": "triggered_action_exception";
+  readonly "0A000": "feature_not_supported";
+  readonly "0B000": "invalid_transaction_initiation";
+  readonly "0F000": "locator_exception";
+  readonly "0F001": "invalid_locator_specification";
+  readonly "0L000": "invalid_grantor";
+  readonly "0LP01": "invalid_grant_operation";
+  readonly "0P000": "invalid_role_specification";
+  readonly "0Z000": "diagnostics_exception";
+  readonly "0Z002": "stacked_diagnostics_accessed_without_active_handler";
+  readonly "10608": "invalid_argument_for_xquery";
+  readonly "20000": "case_not_found";
+  readonly "21000": "cardinality_violation";
+  readonly "22000": "data_exception";
+  readonly "2202E": "array_subscript_error";
+  readonly "22021": "character_not_in_repertoire";
+  readonly "22008": "datetime_field_overflow";
+  readonly "22012": "division_by_zero";
+  readonly "22005": "error_in_assignment";
+  readonly "2200B": "escape_character_conflict";
+  readonly "22022": "indicator_overflow";
+  readonly "22015": "interval_field_overflow";
+  readonly "2201E": "invalid_argument_for_logarithm";
+  readonly "22014": "invalid_argument_for_ntile_function";
+  readonly "22016": "invalid_argument_for_nth_value_function";
+  readonly "2201F": "invalid_argument_for_power_function";
+  readonly "2201G": "invalid_argument_for_width_bucket_function";
+  readonly "22018": "invalid_character_value_for_cast";
+  readonly "22007": "invalid_datetime_format";
+  readonly "22019": "invalid_escape_character";
+  readonly "2200D": "invalid_escape_octet";
+  readonly "22025": "invalid_escape_sequence";
+  readonly "22P06": "nonstandard_use_of_escape_character";
+  readonly "22010": "invalid_indicator_parameter_value";
+  readonly "22023": "invalid_parameter_value";
+  readonly "22013": "invalid_preceding_or_following_size";
+  readonly "2201B": "invalid_regular_expression";
+  readonly "2201W": "invalid_row_count_in_limit_clause";
+  readonly "2201X": "invalid_row_count_in_result_offset_clause";
+  readonly "2202H": "invalid_tablesample_argument";
+  readonly "2202G": "invalid_tablesample_repeat";
+  readonly "22009": "invalid_time_zone_displacement_value";
+  readonly "2200C": "invalid_use_of_escape_character";
+  readonly "2200G": "most_specific_type_mismatch";
+  readonly "22004": "null_value_not_allowed";
+  readonly "22002": "null_value_no_indicator_parameter";
+  readonly "22003": "numeric_value_out_of_range";
+  readonly "2200H": "sequence_generator_limit_exceeded";
+  readonly "22026": "string_data_length_mismatch";
+  readonly "22001": "string_data_right_truncation";
+  readonly "22011": "substring_error";
+  readonly "22027": "trim_error";
+  readonly "22024": "unterminated_c_string";
+  readonly "2200F": "zero_length_character_string";
+  readonly "22P01": "floating_point_exception";
+  readonly "22P02": "invalid_text_representation";
+  readonly "22P03": "invalid_binary_representation";
+  readonly "22P04": "bad_copy_file_format";
+  readonly "22P05": "untranslatable_character";
+  readonly "2200L": "not_an_xml_document";
+  readonly "2200M": "invalid_xml_document";
+  readonly "2200N": "invalid_xml_content";
+  readonly "2200S": "invalid_xml_comment";
+  readonly "2200T": "invalid_xml_processing_instruction";
+  readonly "22030": "duplicate_json_object_key_value";
+  readonly "22031": "invalid_argument_for_sql_json_datetime_function";
+  readonly "22032": "invalid_json_text";
+  readonly "22033": "invalid_sql_json_subscript";
+  readonly "22034": "more_than_one_sql_json_item";
+  readonly "22035": "no_sql_json_item";
+  readonly "22036": "non_numeric_sql_json_item";
+  readonly "22037": "non_unique_keys_in_a_json_object";
+  readonly "22038": "singleton_sql_json_item_required";
+  readonly "22039": "sql_json_array_not_found";
+  readonly "2203A": "sql_json_member_not_found";
+  readonly "2203B": "sql_json_number_not_found";
+  readonly "2203C": "sql_json_object_not_found";
+  readonly "2203D": "too_many_json_array_elements";
+  readonly "2203E": "too_many_json_object_members";
+  readonly "2203F": "sql_json_scalar_required";
+  readonly "2203G": "sql_json_item_cannot_be_cast_to_target_type";
+  readonly "23000": "integrity_constraint_violation";
+  readonly "23001": "restrict_violation";
+  readonly "23502": "not_null_violation";
+  readonly "23503": "foreign_key_violation";
+  readonly "23505": "unique_violation";
+  readonly "23514": "check_violation";
+  readonly "23P01": "exclusion_violation";
+  readonly "24000": "invalid_cursor_state";
+  readonly "25000": "invalid_transaction_state";
+  readonly "25001": "active_sql_transaction";
+  readonly "25002": "branch_transaction_already_active";
+  readonly "25008": "held_cursor_requires_same_isolation_level";
+  readonly "25003": "inappropriate_access_mode_for_branch_transaction";
+  readonly "25004": "inappropriate_isolation_level_for_branch_transaction";
+  readonly "25005": "no_active_sql_transaction_for_branch_transaction";
+  readonly "25006": "read_only_sql_transaction";
+  readonly "25007": "schema_and_data_statement_mixing_not_supported";
+  readonly "25P01": "no_active_sql_transaction";
+  readonly "25P02": "in_failed_sql_transaction";
+  readonly "25P03": "idle_in_transaction_session_timeout";
+  readonly "25P04": "transaction_timeout";
+  readonly "26000": "invalid_sql_statement_name";
+  readonly "27000": "triggered_data_change_violation";
+  readonly "28000": "invalid_authorization_specification";
+  readonly "28P01": "invalid_password";
+  readonly "2B000": "dependent_privilege_descriptors_still_exist";
+  readonly "2BP01": "dependent_objects_still_exist";
+  readonly "2D000": "invalid_transaction_termination";
+  readonly "2F000": "sql_routine_exception";
+  readonly "2F005": "function_executed_no_return_statement";
+  readonly "2F002": "modifying_sql_data_not_permitted";
+  readonly "2F003": "prohibited_sql_statement_attempted";
+  readonly "2F004": "reading_sql_data_not_permitted";
+  readonly "34000": "invalid_cursor_name";
+  readonly "38000": "external_routine_exception";
+  readonly "38001": "containing_sql_not_permitted";
+  readonly "38002": "modifying_sql_data_not_permitted";
+  readonly "38003": "prohibited_sql_statement_attempted";
+  readonly "38004": "reading_sql_data_not_permitted";
+  readonly "39000": "external_routine_invocation_exception";
+  readonly "39001": "invalid_sqlstate_returned";
+  readonly "39004": "null_value_not_allowed";
+  readonly "39P01": "trigger_protocol_violated";
+  readonly "39P02": "srf_protocol_violated";
+  readonly "39P03": "event_trigger_protocol_violated";
+  readonly "3B000": "savepoint_exception";
+  readonly "3B001": "invalid_savepoint_specification";
+  readonly "3D000": "invalid_catalog_name";
+  readonly "3F000": "invalid_schema_name";
+  readonly "40000": "transaction_rollback";
+  readonly "40002": "transaction_integrity_constraint_violation";
+  readonly "40001": "serialization_failure";
+  readonly "40003": "statement_completion_unknown";
+  readonly "40P01": "deadlock_detected";
+  readonly "42000": "syntax_error_or_access_rule_violation";
+  readonly "42601": "syntax_error";
+  readonly "42501": "insufficient_privilege";
+  readonly "42846": "cannot_coerce";
+  readonly "42803": "grouping_error";
+  readonly "42P20": "windowing_error";
+  readonly "42P19": "invalid_recursion";
+  readonly "42830": "invalid_foreign_key";
+  readonly "42602": "invalid_name";
+  readonly "42622": "name_too_long";
+  readonly "42939": "reserved_name";
+  readonly "42804": "datatype_mismatch";
+  readonly "42P18": "indeterminate_datatype";
+  readonly "42P21": "collation_mismatch";
+  readonly "42P22": "indeterminate_collation";
+  readonly "42809": "wrong_object_type";
+  readonly "428C9": "generated_always";
+  readonly "42703": "undefined_column";
+  readonly "42883": "undefined_function";
+  readonly "42P01": "undefined_table";
+  readonly "42P02": "undefined_parameter";
+  readonly "42704": "undefined_object";
+  readonly "42701": "duplicate_column";
+  readonly "42P03": "duplicate_cursor";
+  readonly "42P04": "duplicate_database";
+  readonly "42723": "duplicate_function";
+  readonly "42P05": "duplicate_prepared_statement";
+  readonly "42P06": "duplicate_schema";
+  readonly "42P07": "duplicate_table";
+  readonly "42712": "duplicate_alias";
+  readonly "42710": "duplicate_object";
+  readonly "42702": "ambiguous_column";
+  readonly "42725": "ambiguous_function";
+  readonly "42P08": "ambiguous_parameter";
+  readonly "42P09": "ambiguous_alias";
+  readonly "42P10": "invalid_column_reference";
+  readonly "42611": "invalid_column_definition";
+  readonly "42P11": "invalid_cursor_definition";
+  readonly "42P12": "invalid_database_definition";
+  readonly "42P13": "invalid_function_definition";
+  readonly "42P14": "invalid_prepared_statement_definition";
+  readonly "42P15": "invalid_schema_definition";
+  readonly "42P16": "invalid_table_definition";
+  readonly "42P17": "invalid_object_definition";
+  readonly "44000": "with_check_option_violation";
+  readonly "53000": "insufficient_resources";
+  readonly "53100": "disk_full";
+  readonly "53200": "out_of_memory";
+  readonly "53300": "too_many_connections";
+  readonly "53400": "configuration_limit_exceeded";
+  readonly "54000": "program_limit_exceeded";
+  readonly "54001": "statement_too_complex";
+  readonly "54011": "too_many_columns";
+  readonly "54023": "too_many_arguments";
+  readonly "55000": "object_not_in_prerequisite_state";
+  readonly "55006": "object_in_use";
+  readonly "55P02": "cant_change_runtime_param";
+  readonly "55P03": "lock_not_available";
+  readonly "55P04": "unsafe_new_enum_value_usage";
+  readonly "57000": "operator_intervention";
+  readonly "57014": "query_canceled";
+  readonly "57P01": "admin_shutdown";
+  readonly "57P02": "crash_shutdown";
+  readonly "57P03": "cannot_connect_now";
+  readonly "57P04": "database_dropped";
+  readonly "57P05": "idle_session_timeout";
+  readonly "58000": "system_error";
+  readonly "58030": "io_error";
+  readonly "58P01": "undefined_file";
+  readonly "58P02": "duplicate_file";
+  readonly "58P03": "file_name_too_long";
+  readonly F0000: "config_file_error";
+  readonly F0001: "lock_file_exists";
+  readonly HV000: "fdw_error";
+  readonly HV005: "fdw_column_name_not_found";
+  readonly HV002: "fdw_dynamic_parameter_value_needed";
+  readonly HV010: "fdw_function_sequence_error";
+  readonly HV021: "fdw_inconsistent_descriptor_information";
+  readonly HV024: "fdw_invalid_attribute_value";
+  readonly HV007: "fdw_invalid_column_name";
+  readonly HV008: "fdw_invalid_column_number";
+  readonly HV004: "fdw_invalid_data_type";
+  readonly HV006: "fdw_invalid_data_type_descriptors";
+  readonly HV091: "fdw_invalid_descriptor_field_identifier";
+  readonly HV00B: "fdw_invalid_handle";
+  readonly HV00C: "fdw_invalid_option_index";
+  readonly HV00D: "fdw_invalid_option_name";
+  readonly HV090: "fdw_invalid_string_length_or_buffer_length";
+  readonly HV00A: "fdw_invalid_string_format";
+  readonly HV009: "fdw_invalid_use_of_null_pointer";
+  readonly HV014: "fdw_too_many_handles";
+  readonly HV001: "fdw_out_of_memory";
+  readonly HV00P: "fdw_no_schemas";
+  readonly HV00J: "fdw_option_name_not_found";
+  readonly HV00K: "fdw_reply_handle";
+  readonly HV00Q: "fdw_schema_not_found";
+  readonly HV00R: "fdw_table_not_found";
+  readonly HV00L: "fdw_unable_to_create_execution";
+  readonly HV00M: "fdw_unable_to_create_reply";
+  readonly HV00N: "fdw_unable_to_establish_connection";
+  readonly P0000: "plpgsql_error";
+  readonly P0001: "raise_exception";
+  readonly P0002: "no_data_found";
+  readonly P0003: "too_many_rows";
+  readonly P0004: "assert_failure";
+  readonly XX000: "internal_error";
+  readonly XX001: "data_corrupted";
+  readonly XX002: "index_corrupted";
+};
+type ConditionsByCode = typeof conditionsByCode;
+/** Name of a condition of PostgreSQL errors, such as `unique_violation`, or of a class of them, such as `integrity_constraint_violation`. */
+type QueryErrorCondition = ConditionsByCode[keyof ConditionsByCode];
+/**
+ * SQLSTATE codes of each condition, with every code of its class for the condition of a class.
+ *
+ * TypeScript computes the map once, whereas a mapped type of the table for each condition would cost a check of another condition about 70 times as many instantiations.
+ */
+type CodesByCondition = { [K in keyof ConditionsByCode as ConditionsByCode[K]]: K extends `${infer Class}000` ? `${Class}${string}` : K; };
+/** SQLSTATE codes of the condition `C`, with every code of its class for the condition of a class. */
+type QueryErrorCode<C extends QueryErrorCondition> = CodesByCondition[C];
+/**
+ * Tells whether `error` is a `QueryError` of `condition`, including a `QueryError` of another copy of kern-db.
+ *
+ * The condition of a class, such as `integrity_constraint_violation`, matches every error of its class, as in PL/pgSQL.
+ */
+export declare function isQueryError<C extends QueryErrorCondition>(error: unknown, condition: C): error is QueryError & {
+  readonly code: QueryErrorCode<C>;
+};
+/** Phase of a transaction in which its connection failed. */
+type TransactionPhase = TransactionConnectionError["phase"];
+/**
+ * Error of a transaction whose connection failed, which tells whether the transaction may have been committed.
+ *
+ * Its `cause` is the error that the transaction would reject with otherwise, such as the error of the callback, or a `SuppressedError` of a failed rollback that keeps it.
+ */
+export declare class TransactionConnectionError extends ConnectionError {
+  readonly name: string;
+  /**
+   * Phase of the transaction in which its connection failed:
+   *
+   * - `begin`: before the callback, such as getting the connection or `BEGIN`, so the transaction applied nothing;
+   * - `transaction`: in the callback or its rollback, so the transaction was rolled back;
+   * - `commit`: during `COMMIT`, so whether the transaction was committed is unknown.
+   */
+  readonly phase: "begin" | "transaction" | "commit";
+  constructor(phase: TransactionPhase, options?: {
+    cause?: unknown;
+  });
+  /** Tells whether `value` is an instance of the class, including one of `TransactionConnectionError` of another copy of kern-db. */
+  static [Symbol.hasInstance]<T>(this: abstract new (...args: never) => T, value: unknown): value is T;
+}
+export { type AcceptedNull, type AcceptedValues, type AnyDerivableType, type AnySqlQuery, type AnyType, type BaseDerivableType, type Connection, type Database, type DatabaseOptions, type DecodedFields, type DerivableType, type DerivableTypeWithParameters, type Driver, type DriverErrorFields, type DriverResult, type FieldTypes, type InitialSqlQueryState, type IsolationLevel, NotFoundError, type OneRow, type OneValueRows, type PollLockOptions, type QueryErrorCode, type QueryErrorCondition, type ResultByRows, ResultDecodeError, type ResultRows, type SessionOptions, type SqlFragment, type SqlQuery, type SqlQueryResult, type SqlQueryState, type SqlStatement, type SqlValue, type TextValue, type TransactionOptions, type Type, type TypeInput, type TypeOptions, type TypeOutput, type TypeTransform, type UntypedValue, type ValueRows, createDatabase, createStatement, defineType, identifier, isDatabase, isDriver, isType, param, sql, type typeValues };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { o as defineType, s as isType } from "./bytea-DNZ_ftio.mjs";
+import { C as isDriver, S as createStatement, _ as sql, h as param, i as ResultDecodeError, m as identifier, r as NotFoundError } from "./query-FKBN7BMY.mjs";
+import { a as toDriverError, n as QueryError, t as ConnectionError } from "./driver-error-26zcdHeU.mjs";
+import { a as TransactionConnectionError, i as isQueryError, r as isDatabase, t as createDatabase } from "./database-BkWPkXG5.mjs";
+export { ConnectionError, NotFoundError, QueryError, ResultDecodeError, TransactionConnectionError, createDatabase, createStatement, defineType, identifier, isDatabase, isDriver, isQueryError, isType, param, sql, toDriverError };

package/dist/node-postgres.d.mts

@@ -0,0 +1,8 @@
+import { n as Driver } from "./driver-CSfbXOBJ.mjs";
+import { Pool } from "pg";
+/**
+ * Creates a kern-db driver over a node-postgres pool; the pool keeps managing its connections.
+ *
+ * Closing the driver ends the supplied pool.
+ */
+export declare function nodePostgresDriver(pool: Pool): Driver;