kern-orm 0.7.0 → 0.8.0

package/dist/{database-B7Kf5Q9X.mjs → driver-error-Dx5R83Rp.mjs}

@@ -4920,4 +4920,91 @@ function createDatabase({ driver, test }) {
 function createLockStatement(key) {
 	return createStatement("SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", [key]);
 }
-export { not as A, countType as C, literal as D, toAggregateType as E, combineNodes as M, and as O, countProjection as S, createCountCall as T, createTableFactory as _, defineSchema as a, RequiredRelationError as b, requireDerived as c, desc as d, orderBy as f, createStatement as g, one as h, sql as i, or as j, isColumnValues as k, addTerms as l, many as m, identifier as n, SelectQuery as o, matchColumn as p, param as r, from as s, createDatabase as t, asc as u, defineTable as v, createAggregateCall as w, ResultDecodeError as x, NotFoundError as y };
+// src/execution/driver-error.ts
+/** Marks an instance of `QueryError` of any copy of kern-orm, which `instanceof QueryError` of another copy recognizes. */
+const queryErrorBrand = /* @__PURE__ */ Symbol.for("kern-orm.QueryError");
+/** Marks an instance of `ConnectionError` of any copy of kern-orm. */
+const connectionErrorBrand = /* @__PURE__ */ Symbol.for("kern-orm.ConnectionError");
+/**
+* Tells whether `value` is an instance of `errorClass`: by the brand of any copy of kern-orm for `errorClass` itself, and by the prototype chain for its subclasses.
+*
+* An application can load several copies of kern-orm, such as one of a driver, 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-orm. */
+	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-orm. */
+	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-orm 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 { literal as A, RequiredRelationError as C, createAggregateCall as D, countType as E, combineNodes as F, isColumnValues as M, not as N, createCountCall as O, or as P, NotFoundError as S, countProjection as T, many as _, identifier as a, createTableFactory as b, defineSchema as c, requireDerived as d, addTerms as f, matchColumn as g, orderBy as h, createDatabase as i, and as j, toAggregateType as k, SelectQuery as l, desc as m, QueryError as n, param as o, asc as p, toDriverError as r, sql as s, ConnectionError as t, from as u, one as v, ResultDecodeError as w, defineTable as x, createStatement as y };

package/dist/{index-CLKi9gZL.d.mts → index-B1aH5Ht0.d.mts}

@@ -241,8 +241,11 @@ interface DriverResult {
  * 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 {
+  /** Whether the driver closes a reserved connection that it cannot return to the pool, such as one left in a transaction or lost; a driver over a client that cannot close one, such as postgres.js 3, keeps it reserved instead. */
+  readonly closesReservedConnections: boolean;
   /** Executes a statement on any pooled connection. */
   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. */
@@ -252,7 +255,7 @@ interface Driver {
   /**
    * Closes the connections once the statements on the pool and the transactions on reserved connections end.
    *
-   * From the call, it rejects a new statement or script on the pool and a new connection.
+   * From the call, it rejects a new statement or script on the pool and a new connection with `ConnectionError`.
    */
   close(): Promise<void>;
 }
@@ -267,14 +270,14 @@ interface Connection {
   /** 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 after a transaction on it.
+   * Returns the connection to the pool.
    *
-   * Without `failure`, the transaction ended with a completed `COMMIT` or `ROLLBACK`, and the connection is idle.
-   * With `failure`, its `BEGIN`, `COMMIT`, or `ROLLBACK` failed, so the transaction may still be open: the driver returns the connection to the pool only once it is idle, and never returns a connection it lost.
+   * Without `failure`, the connection is idle: no transaction ran on it, or its `COMMIT` or `ROLLBACK` completed.
+   * With `failure`, the last statement on the connection failed, such as `BEGIN`, `COMMIT`, or `ROLLBACK`, so the connection may be in a transaction or lost: the driver returns it to the pool only once it is idle, and never returns a connection it lost.
    */
   release(failure?: TransactionFailure): void | Promise<void>;
 }
-/** Failure of the statement that started or ended a transaction on a connection. */
+/** Failure of the last statement on a reserved connection, after which the connection may not be idle. */
 interface TransactionFailure {
   readonly error: unknown;
 }
@@ -3332,6 +3335,61 @@ declare const textOperators: TextOperators;
 declare const TRUE: Expression<boolean>;
 /** Condition that never holds, such as for a branch of `or` built in code: `or(check, isAdmin ? other : FALSE)`. */
 declare const FALSE: Expression<boolean>;
+/**
+ * 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`.
+ */
+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-orm. */
+  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.
+ */
+declare class ConnectionError extends Error {
+  readonly name = "ConnectionError";
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+  /** Tells whether `value` is an instance of the class, including one of `ConnectionError` of another copy of kern-orm. */
+  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-orm 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`.
+ */
+declare function toDriverError(error: unknown, fields?: DriverErrorFields): QueryError | ConnectionError;
 /**
  * Defines a reusable expression of a table, which the callbacks of queries over the table call with their columns and any further arguments, such as to filter by it and select it in one query.
  *
@@ -3415,4 +3473,4 @@ declare function param<E extends AnyExpression, V extends (E extends AnyExpressi
  * A run of capital letters is one word, such as `user_id` for `userID`, and digits stay in their word, such as `line2`.
  */
 declare function toSnakeCase(key: string): string;
-export { NoRelations as $, BoundOperators as $i, ResultOf as $n, ScalarQuery as $r, TypedOperandInput as $t, Db as A, ResultMode as Ai, count as An, and as Ar, DecodedFields as At, PendingTestFixture as B, TextValue as Bi, OrderKey as Bn, CountValueType as Br, InitialMutationState as Bt, BaseOperators as C, TableOptions as Ci, CountExpression as Cn, WhereCondition as Cr, AnyRecordQuery as Ct, UntypedExpression as D, NotFoundError as Di, UnfilteredAggregateOptions as Dn, Condition as Dr, AnyQuery as Dt, TypedExpression as E, defineTable as Ei, StringAggOptions as En, CombinedCondition as Er, SelectionState as Et, DatabaseOptions as F, SqlStatement as Fi, some as Fn, OneRow as Fr, AnyMutationQuery as Ft, createTestHelpers as G, TypeOutput as Gi, asc as Gn, InSignature as Gr, HelperEffect as Gt, TestHelpers as H, TypeInput as Hi, OrderTerms as Hn, EqualityOperator as Hr, MutationQuery as Ht, TransactionOptions as I, TransactionFailure as Ii, stringAgg as In, OneValueRows as Ir, ConflictActionRequired as It, SynchronousResult as J, AnyColumn as Ji, ColumnRefs as Jn, ComparisonSignature as Jr, CaseCondition as Jt, AnyTransformedQuery as K, TypeTransform as Ki, desc as Kn, equalityOperators as Kr, defineHelper as Kt, createDatabase as L, createStatement as Li, sum as Ln, QueryResult as Lr, ConflictKeyRequired as Lt, DbOf as M, Connection as Mi, every as Mn, or as Mr, InitialSqlQueryState as Mt, DbQueryState as N, Driver as Ni, max as Nn, ExistsValueType as Nr, SqlQuery as Nt, AnyDb as O, RequiredRelationError as Oi, UnfilteredStringAggOptions as On, ConditionOperand as Or, SelectQueryKind as Ot, Database as P, DriverResult as Pi, min as Pn, FilteredRows as Pr, SqlQueryState as Pt, MergeRelations as Q, ToColumn as Qi, BoundSelectQuery as Qn, OperandUses as Qr, TypedOperand as Qt, TransactionCoordinator as R, AnyType as Ri, OrderColumns as Rn, ResultByRows as Rr, ConflictTarget as Rt, AnyExpression as S, TableKeys as Si, AggregateOptions as Sn, WhereCallback as Sr, defineSchema as St, ExpressionOperators as T, createTableFactory as Ti, GroupValue as Tn, WhereValues as Tr, RecordQueryState as Tt, TestHooks as U, TypeOperators as Ui, Ordering as Un, EqualityOperators as Ur, MutationQueryState as Ut, TestFixture as V, Type as Vi, OrderTerm as Vn, CompileOptions as Vr, InsertMutationState as Vt, TestTransactionOptions as W, TypeOptions as Wi, SelectedRefs as Wn, HasEquality as Wr, Helper as Wt, TransformedQueryState as X, ColumnAttributes as Xi, RelationRefs as Xn, OperandValue as Xr, FollowingOperand as Xt, TransformedQuery as Y, Column as Yi, QueryContext as Yn, Operand as Yr, CaseValue as Yt, DeclaredRelations as Z, KeyKind as Zi, AnySelectQuery as Zn, compare as Zr, NullSkippingResult as Zt, TextOperators as _, ColumnValues as _i, SelectionResult as _n, KeyCheck as _r, Schema as _t, sql as a, OperatorSignature as aa, InitialQueryState as ai, ColumnFieldTypes as an, InsertValues as ar, RelationKeys as at, NumberTypeOperators as b, Table as bi, literal as bn, PrimaryKeyValues as br, SchemaTables as bt, MatchResult as c, QueryValueType as ci, GroupOperandValue as cn, UpsertValues as cr, SchemaContext as ct, defineExpression as d, TableQueryState as di, GroupedRecord as dn, FoundState as dr, TableRelations as dt, MergeOperators as ea, TypedScalarQuery as ei, TypedOperandOperators as en, SelectQuery as er, OneRelationKeys as et, FALSE as f, AnyTable as fi, MergeSelection as fn, GroupedState as fr, UsableRelation as ft, TextLengthSignature as g, ColumnShape as gi, SelectionFieldTypes as gn, GroupTerms as gr, AnySchema as gt, TextConversionSignature as h, ColumnOperators as hi, Selection as hn, GroupTerm as hr, one as ht, param as i, GenericOperatorImplementation as ia, Grouped as ii, least as in, ConflictUpdateSet as ir, RelationKey as it, DbMutationState as j, ResultRows as ji, countDistinct as jn, not as jr, FieldTypes as jt, BindOptions as k, ResultDecodeError as ki, avg as kn, Predicate as kr, AnySqlQuery as kt, NotAColumn as l, SelectQueryState as li, GroupSelectionResult as ln, FilteredStateRows as lr, SchemaRelations as lt, PatternSignature as m, ColumnDefinitions as mi, SelectedFieldTypes as mn, RowLockOptions as mr, many as mt, SqlTemplate as n, OperatorDefinitions as na, EmptyRecord as ni, coalesce as nn, from as nr, RelationDeclaration as nt, ColumnRefKey as o, defineGenericOperator as oa, QueryState as oi, ExpressionInput as on, UpdateSet as or, RelationKind as ot, TRUE as p, AnyTableKeys as pi, NestedQuery as pn, SelectedOperandType as pr, UsedRelation as pt, NotSynchronous as q, defineType as qi, orderBy as qn, BooleanResult as qr, CaseBranch as qt, identifier as r, GenericOperator as ra, FoundKey as ri, greatest as rn, ColumnValue as rr, RelationDeclarations as rt, MatchCheck as s, QueryStateOf as si, ExpressionValue as sn, UpdateValues as sr, RequiredMember as st, toSnakeCase as t, NoOperators as ta, ValuesQuery as ti, caseWhen as tn, SingletonInsertMany as tr, Relation as tt, matches as u, SingletonQueryState as ui, GroupedField as un, FoundQueryState as ur, TableContext as ut, TextTypeOperators as v, KeyColumns as vi, SelectionUses as vn, NotAKey as vr, SchemaPart as vt, Expression as w, ToColumns as wi, GroupAggregateExpression as wn, WhereFilter as wr, RecordQuery as wt, orderingOperators as x, TableFactoryOptions as xi, AggregateExpression as xn, EqValue as xr, Tables as xt, textOperators as y, Selectable as yi, Literal as yn, PrimaryKeyColumn as yr, SchemaPartRelations as yt, OpenedTestFixture as z, BaseType as zi, OrderDirection as zn, ValueRows as zr, InitialInsertState as zt };
+export { TransformedQuery as $, Column as $i, QueryContext as $n, Operand as $r, CaseValue as $t, TypedExpression as A, defineTable as Ai, StringAggOptions as An, CombinedCondition as Ar, SelectionState as At, TransactionOptions as B, TransactionFailure as Bi, stringAgg as Bn, OneValueRows as Br, ConflictActionRequired as Bt, textOperators as C, Selectable as Ci, Literal as Cn, PrimaryKeyColumn as Cr, SchemaPartRelations as Ct, BaseOperators as D, TableOptions as Di, CountExpression as Dn, WhereCondition as Dr, AnyRecordQuery as Dt, AnyExpression as E, TableKeys as Ei, AggregateOptions as En, WhereCallback as Er, defineSchema as Et, DbMutationState as F, ResultRows as Fi, countDistinct as Fn, not as Fr, FieldTypes as Ft, TestFixture as G, Type as Gi, OrderTerm as Gn, CompileOptions as Gr, InsertMutationState as Gt, TransactionCoordinator as H, AnyType as Hi, OrderColumns as Hn, ResultByRows as Hr, ConflictTarget as Ht, DbOf as I, Connection as Ii, every as In, or as Ir, InitialSqlQueryState as It, TestTransactionOptions as J, TypeOptions as Ji, SelectedRefs as Jn, HasEquality as Jr, Helper as Jt, TestHelpers as K, TypeInput as Ki, OrderTerms as Kn, EqualityOperator as Kr, MutationQuery as Kt, DbQueryState as L, Driver as Li, max as Ln, ExistsValueType as Lr, SqlQuery as Lt, AnyDb as M, RequiredRelationError as Mi, UnfilteredStringAggOptions as Mn, ConditionOperand as Mr, SelectQueryKind as Mt, BindOptions as N, ResultDecodeError as Ni, avg as Nn, Predicate as Nr, AnySqlQuery as Nt, Expression as O, ToColumns as Oi, GroupAggregateExpression as On, WhereFilter as Or, RecordQuery as Ot, Db as P, ResultMode as Pi, count as Pn, and as Pr, DecodedFields as Pt, SynchronousResult as Q, AnyColumn as Qi, ColumnRefs as Qn, ComparisonSignature as Qr, CaseCondition as Qt, Database as R, DriverResult as Ri, min as Rn, FilteredRows as Rr, SqlQueryState as Rt, TextTypeOperators as S, KeyColumns as Si, SelectionUses as Sn, NotAKey as Sr, SchemaPart as St, orderingOperators as T, TableFactoryOptions as Ti, AggregateExpression as Tn, EqValue as Tr, Tables as Tt, OpenedTestFixture as U, BaseType as Ui, OrderDirection as Un, ValueRows as Ur, InitialInsertState as Ut, createDatabase as V, createStatement as Vi, sum as Vn, QueryResult as Vr, ConflictKeyRequired as Vt, PendingTestFixture as W, TextValue as Wi, OrderKey as Wn, CountValueType as Wr, InitialMutationState as Wt, AnyTransformedQuery as X, TypeTransform as Xi, desc as Xn, equalityOperators as Xr, defineHelper as Xt, createTestHelpers as Y, TypeOutput as Yi, asc as Yn, InSignature as Yr, HelperEffect as Yt, NotSynchronous as Z, defineType as Zi, orderBy as Zn, BooleanResult as Zr, CaseBranch as Zt, TRUE as _, AnyTableKeys as _i, NestedQuery as _n, SelectedOperandType as _r, UsedRelation as _t, sql as a, NoOperators as aa, ValuesQuery as ai, caseWhen as an, SingletonInsertMany as ar, Relation as at, TextLengthSignature as b, ColumnShape as bi, SelectionFieldTypes as bn, GroupTerms as br, AnySchema as bt, MatchResult as c, GenericOperatorImplementation as ca, Grouped as ci, least as cn, ConflictUpdateSet as cr, RelationKey as ct, defineExpression as d, QueryStateOf as di, ExpressionValue as dn, UpdateValues as dr, RequiredMember as dt, ColumnAttributes as ea, OperandValue as ei, FollowingOperand as en, RelationRefs as er, TransformedQueryState as et, ConnectionError as f, QueryValueType as fi, GroupOperandValue as fn, UpsertValues as fr, SchemaContext as ft, FALSE as g, AnyTable as gi, MergeSelection as gn, GroupedState as gr, UsableRelation as gt, toDriverError as h, TableQueryState as hi, GroupedRecord as hn, FoundState as hr, TableRelations as ht, param as i, MergeOperators as ia, TypedScalarQuery as ii, TypedOperandOperators as in, SelectQuery as ir, OneRelationKeys as it, UntypedExpression as j, NotFoundError as ji, UnfilteredAggregateOptions as jn, Condition as jr, AnyQuery as jt, ExpressionOperators as k, createTableFactory as ki, GroupValue as kn, WhereValues as kr, RecordQueryState as kt, NotAColumn as l, OperatorSignature as la, InitialQueryState as li, ColumnFieldTypes as ln, InsertValues as lr, RelationKeys as lt, QueryError as m, SingletonQueryState as mi, GroupedField as mn, FoundQueryState as mr, TableContext as mt, SqlTemplate as n, ToColumn as na, OperandUses as ni, TypedOperand as nn, BoundSelectQuery as nr, MergeRelations as nt, ColumnRefKey as o, OperatorDefinitions as oa, EmptyRecord as oi, coalesce as on, from as or, RelationDeclaration as ot, DriverErrorFields as p, SelectQueryState as pi, GroupSelectionResult as pn, FilteredStateRows as pr, SchemaRelations as pt, TestHooks as q, TypeOperators as qi, Ordering as qn, EqualityOperators as qr, MutationQueryState as qt, identifier as r, BoundOperators as ra, ScalarQuery as ri, TypedOperandInput as rn, ResultOf as rr, NoRelations as rt, MatchCheck as s, GenericOperator as sa, FoundKey as si, greatest as sn, ColumnValue as sr, RelationDeclarations as st, toSnakeCase as t, KeyKind as ta, compare as ti, NullSkippingResult as tn, AnySelectQuery as tr, DeclaredRelations as tt, matches as u, defineGenericOperator as ua, QueryState as ui, ExpressionInput as un, UpdateSet as ur, RelationKind as ut, PatternSignature as v, ColumnDefinitions as vi, SelectedFieldTypes as vn, RowLockOptions as vr, many as vt, NumberTypeOperators as w, Table as wi, literal as wn, PrimaryKeyValues as wr, SchemaTables as wt, TextOperators as x, ColumnValues as xi, SelectionResult as xn, KeyCheck as xr, Schema as xt, TextConversionSignature as y, ColumnOperators as yi, Selection as yn, GroupTerm as yr, one as yt, DatabaseOptions as z, SqlStatement as zi, some as zn, OneRow as zr, AnyMutationQuery as zt };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as NoRelations, $i as BoundOperators, $n as ResultOf, $r as ScalarQuery, $t as TypedOperandInput, A as Db, Ai as ResultMode, An as count, Ar as and, At as DecodedFields, Bi as TextValue, Bn as OrderKey, Br as CountValueType, Bt as InitialMutationState, C as BaseOperators, Ci as TableOptions, Cn as CountExpression, Cr as WhereCondition, Ct as AnyRecordQuery, D as UntypedExpression, Di as NotFoundError, Dn as UnfilteredAggregateOptions, Dr as Condition, Dt as AnyQuery, E as TypedExpression, Ei as defineTable, En as StringAggOptions, Er as CombinedCondition, Et as SelectionState, F as DatabaseOptions, Fi as SqlStatement, Fn as some, Fr as OneRow, Ft as AnyMutationQuery, Gi as TypeOutput, Gn as asc, Gr as InSignature, Gt as HelperEffect, Hi as TypeInput, Hn as OrderTerms, Hr as EqualityOperator, Ht as MutationQuery, I as TransactionOptions, Ii as TransactionFailure, In as stringAgg, Ir as OneValueRows, It as ConflictActionRequired, J as SynchronousResult, Ji as AnyColumn, Jn as ColumnRefs, Jr as ComparisonSignature, Jt as CaseCondition, K as AnyTransformedQuery, Ki as TypeTransform, Kn as desc, Kr as equalityOperators, Kt as defineHelper, L as createDatabase, Li as createStatement, Ln as sum, Lr as QueryResult, Lt as ConflictKeyRequired, M as DbOf, Mi as Connection, Mn as every, Mr as or, Mt as InitialSqlQueryState, N as DbQueryState, Ni as Driver, Nn as max, Nr as ExistsValueType, Nt as SqlQuery, O as AnyDb, Oi as RequiredRelationError, On as UnfilteredStringAggOptions, Or as ConditionOperand, Ot as SelectQueryKind, P as Database, Pi as DriverResult, Pn as min, Pr as FilteredRows, Pt as SqlQueryState, Q as MergeRelations, Qi as ToColumn, Qn as BoundSelectQuery, Qr as OperandUses, Qt as TypedOperand, R as TransactionCoordinator, Ri as AnyType, Rn as OrderColumns, Rr as ResultByRows, Rt as ConflictTarget, S as AnyExpression, Si as TableKeys, Sn as AggregateOptions, Sr as WhereCallback, St as defineSchema, T as ExpressionOperators, Ti as createTableFactory, Tn as GroupValue, Tr as WhereValues, Tt as RecordQueryState, Ui as TypeOperators, Un as Ordering, Ur as EqualityOperators, Ut as MutationQueryState, Vi as Type, Vn as OrderTerm, Vr as CompileOptions, Vt as InsertMutationState, Wi as TypeOptions, Wn as SelectedRefs, Wr as HasEquality, Wt as Helper, X as TransformedQueryState, Xi as ColumnAttributes, Xn as RelationRefs, Xr as OperandValue, Xt as FollowingOperand, Y as TransformedQuery, Yi as Column, Yn as QueryContext, Yr as Operand, Yt as CaseValue, Z as DeclaredRelations, Zi as KeyKind, Zn as AnySelectQuery, Zr as compare, Zt as NullSkippingResult, _ as TextOperators, _i as ColumnValues, _n as SelectionResult, _r as KeyCheck, _t as Schema, a as sql, aa as OperatorSignature, ai as InitialQueryState, an as ColumnFieldTypes, ar as InsertValues, at as RelationKeys, b as NumberTypeOperators, bi as Table, bn as literal, br as PrimaryKeyValues, bt as SchemaTables, c as MatchResult, ci as QueryValueType, cn as GroupOperandValue, cr as UpsertValues, ct as SchemaContext, d as defineExpression, di as TableQueryState, dn as GroupedRecord, dr as FoundState, dt as TableRelations, ea as MergeOperators, ei as TypedScalarQuery, en as TypedOperandOperators, er as SelectQuery, et as OneRelationKeys, f as FALSE, fi as AnyTable, fn as MergeSelection, fr as GroupedState, ft as UsableRelation, g as TextLengthSignature, gi as ColumnShape, gn as SelectionFieldTypes, gr as GroupTerms, gt as AnySchema, h as TextConversionSignature, hi as ColumnOperators, hn as Selection, hr as GroupTerm, ht as one, i as param, ia as GenericOperatorImplementation, ii as Grouped, in as least, ir as ConflictUpdateSet, it as RelationKey, j as DbMutationState, ji as ResultRows, jn as countDistinct, jr as not, jt as FieldTypes, k as BindOptions, ki as ResultDecodeError, kn as avg, kr as Predicate, kt as AnySqlQuery, l as NotAColumn, li as SelectQueryState, ln as GroupSelectionResult, lr as FilteredStateRows, lt as SchemaRelations, m as PatternSignature, mi as ColumnDefinitions, mn as SelectedFieldTypes, mr as RowLockOptions, mt as many, n as SqlTemplate, na as OperatorDefinitions, ni as EmptyRecord, nn as coalesce, nr as from, nt as RelationDeclaration, o as ColumnRefKey, oa as defineGenericOperator, oi as QueryState, on as ExpressionInput, or as UpdateSet, ot as RelationKind, p as TRUE, pi as AnyTableKeys, pn as NestedQuery, pr as SelectedOperandType, pt as UsedRelation, q as NotSynchronous, qi as defineType, qn as orderBy, qr as BooleanResult, qt as CaseBranch, r as identifier, ra as GenericOperator, ri as FoundKey, rn as greatest, rr as ColumnValue, rt as RelationDeclarations, s as MatchCheck, si as QueryStateOf, sn as ExpressionValue, sr as UpdateValues, st as RequiredMember, t as toSnakeCase, ta as NoOperators, ti as ValuesQuery, tn as caseWhen, tr as SingletonInsertMany, tt as Relation, u as matches, ui as SingletonQueryState, un as GroupedField, ur as FoundQueryState, ut as TableContext, v as TextTypeOperators, vi as KeyColumns, vn as SelectionUses, vr as NotAKey, vt as SchemaPart, w as Expression, wi as ToColumns, wn as GroupAggregateExpression, wr as WhereFilter, wt as RecordQuery, x as orderingOperators, xi as TableFactoryOptions, xn as AggregateExpression, xr as EqValue, xt as Tables, y as textOperators, yi as Selectable, yn as Literal, yr as PrimaryKeyColumn, yt as SchemaPartRelations, zi as BaseType, zn as OrderDirection, zr as ValueRows, zt as InitialInsertState } from "./index-CLKi9gZL.mjs";
-export { type AggregateExpression, type AggregateOptions, type AnyColumn, type AnyDb, type AnyExpression, type AnyMutationQuery, type AnyQuery, type AnyRecordQuery, type AnySchema, type AnySelectQuery, type AnySqlQuery, type AnyTable, type AnyTableKeys, type AnyTransformedQuery, type AnyType, type BaseOperators, type BaseType, type BindOptions, type BooleanResult, type BoundOperators, type BoundSelectQuery, type CaseBranch, type CaseCondition, type CaseValue, type Column, type ColumnAttributes, type ColumnDefinitions, type ColumnFieldTypes, type ColumnOperators, type ColumnRefKey, type ColumnRefs, type ColumnShape, type ColumnValue, type ColumnValues, type CombinedCondition, type ComparisonSignature, type CompileOptions, type Condition, type ConditionOperand, type ConflictActionRequired, type ConflictKeyRequired, type ConflictTarget, type ConflictUpdateSet, type Connection, type CountExpression, type CountValueType, type Database, type DatabaseOptions, type Db, type DbMutationState, type DbOf, type DbQueryState, type DeclaredRelations, type DecodedFields, type Driver, type DriverResult, type EmptyRecord, type EqValue, type EqualityOperator, type EqualityOperators, type ExistsValueType, type Expression, type ExpressionInput, type ExpressionOperators, type ExpressionValue, FALSE, type FieldTypes, type FilteredRows, type FilteredStateRows, type FollowingOperand, type FoundKey, type FoundQueryState, type FoundState, type GenericOperator, type GenericOperatorImplementation, type GroupAggregateExpression, type GroupOperandValue, type GroupSelectionResult, type GroupTerm, type GroupTerms, type GroupValue, type Grouped, type GroupedField, type GroupedRecord, type GroupedState, type HasEquality, type Helper, type HelperEffect, type InSignature, type InitialInsertState, type InitialMutationState, type InitialQueryState, type InitialSqlQueryState, type InsertMutationState, type InsertValues, type KeyCheck, type KeyColumns, type KeyKind, type Literal, type MatchCheck, type MatchResult, type MergeOperators, type MergeRelations, type MergeSelection, type MutationQuery, type MutationQueryState, type NestedQuery, type NoOperators, type NoRelations, type NotAColumn, type NotAKey, NotFoundError, type NotSynchronous, type NullSkippingResult, type NumberTypeOperators, type OneRelationKeys, type OneRow, type OneValueRows, type Operand, type OperandUses, type OperandValue, type OperatorDefinitions, type OperatorSignature, type OrderColumns, type OrderDirection, type OrderKey, type OrderTerm, type OrderTerms, type Ordering, type PatternSignature, type Predicate, type PrimaryKeyColumn, type PrimaryKeyValues, type QueryContext, type QueryResult, type QueryState, type QueryStateOf, type QueryValueType, type RecordQuery, type RecordQueryState, type Relation, type RelationDeclaration, type RelationDeclarations, type RelationKey, type RelationKeys, type RelationKind, type RelationRefs, type RequiredMember, RequiredRelationError, type ResultByRows, ResultDecodeError, type ResultMode, type ResultOf, type ResultRows, type RowLockOptions, type ScalarQuery, type Schema, type SchemaContext, type SchemaPart, type SchemaPartRelations, type SchemaRelations, type SchemaTables, type SelectQuery, type SelectQueryKind, type SelectQueryState, type Selectable, type SelectedFieldTypes, type SelectedOperandType, type SelectedRefs, type Selection, type SelectionFieldTypes, type SelectionResult, type SelectionState, type SelectionUses, type SingletonInsertMany, type SingletonQueryState, type SqlQuery, type SqlQueryState, type SqlStatement, type SqlTemplate, type StringAggOptions, type SynchronousResult, TRUE, type Table, type TableContext, type TableFactoryOptions, type TableKeys, type TableOptions, type TableQueryState, type TableRelations, type Tables, type TextConversionSignature, type TextLengthSignature, type TextOperators, type TextTypeOperators, type TextValue, type ToColumn, type ToColumns, type TransactionCoordinator, type TransactionFailure, type TransactionOptions, type TransformedQuery, type TransformedQueryState, type Type, type TypeInput, type TypeOperators, type TypeOptions, type TypeOutput, type TypeTransform, type TypedExpression, type TypedOperand, type TypedOperandInput, type TypedOperandOperators, type TypedScalarQuery, type UnfilteredAggregateOptions, type UnfilteredStringAggOptions, type UntypedExpression, type UpdateSet, type UpdateValues, type UpsertValues, type UsableRelation, type UsedRelation, type ValueRows, type ValuesQuery, type WhereCallback, type WhereCondition, type WhereFilter, type WhereValues, 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 };
+import { $ as TransformedQuery, $i as Column, $n as QueryContext, $r as Operand, $t as CaseValue, A as TypedExpression, Ai as defineTable, An as StringAggOptions, Ar as CombinedCondition, At as SelectionState, B as TransactionOptions, Bi as TransactionFailure, Bn as stringAgg, Br as OneValueRows, Bt as ConflictActionRequired, C as textOperators, Ci as Selectable, Cn as Literal, Cr as PrimaryKeyColumn, Ct as SchemaPartRelations, D as BaseOperators, Di as TableOptions, Dn as CountExpression, Dr as WhereCondition, Dt as AnyRecordQuery, E as AnyExpression, Ei as TableKeys, En as AggregateOptions, Er as WhereCallback, Et as defineSchema, F as DbMutationState, Fi as ResultRows, Fn as countDistinct, Fr as not, Ft as FieldTypes, Gi as Type, Gn as OrderTerm, Gr as CompileOptions, Gt as InsertMutationState, H as TransactionCoordinator, Hi as AnyType, Hn as OrderColumns, Hr as ResultByRows, Ht as ConflictTarget, I as DbOf, Ii as Connection, In as every, Ir as or, It as InitialSqlQueryState, Ji as TypeOptions, Jn as SelectedRefs, Jr as HasEquality, Jt as Helper, Ki as TypeInput, Kn as OrderTerms, Kr as EqualityOperator, Kt as MutationQuery, L as DbQueryState, Li as Driver, Ln as max, Lr as ExistsValueType, Lt as SqlQuery, M as AnyDb, Mi as RequiredRelationError, Mn as UnfilteredStringAggOptions, Mr as ConditionOperand, Mt as SelectQueryKind, N as BindOptions, Ni as ResultDecodeError, Nn as avg, Nr as Predicate, Nt as AnySqlQuery, O as Expression, Oi as ToColumns, On as GroupAggregateExpression, Or as WhereFilter, Ot as RecordQuery, P as Db, Pi as ResultMode, Pn as count, Pr as and, Pt as DecodedFields, Q as SynchronousResult, Qi as AnyColumn, Qn as ColumnRefs, Qr as ComparisonSignature, Qt as CaseCondition, R as Database, Ri as DriverResult, Rn as min, Rr as FilteredRows, Rt as SqlQueryState, S as TextTypeOperators, Si as KeyColumns, Sn as SelectionUses, Sr as NotAKey, St as SchemaPart, T as orderingOperators, Ti as TableFactoryOptions, Tn as AggregateExpression, Tr as EqValue, Tt as Tables, Ui as BaseType, Un as OrderDirection, Ur as ValueRows, Ut as InitialInsertState, V as createDatabase, Vi as createStatement, Vn as sum, Vr as QueryResult, Vt as ConflictKeyRequired, Wi as TextValue, Wn as OrderKey, Wr as CountValueType, Wt as InitialMutationState, X as AnyTransformedQuery, Xi as TypeTransform, Xn as desc, Xr as equalityOperators, Xt as defineHelper, Yi as TypeOutput, Yn as asc, Yr as InSignature, Yt as HelperEffect, Z as NotSynchronous, Zi as defineType, Zn as orderBy, Zr as BooleanResult, Zt as CaseBranch, _ as TRUE, _i as AnyTableKeys, _n as NestedQuery, _r as SelectedOperandType, _t as UsedRelation, a as sql, aa as NoOperators, ai as ValuesQuery, an as caseWhen, ar as SingletonInsertMany, at as Relation, b as TextLengthSignature, bi as ColumnShape, bn as SelectionFieldTypes, br as GroupTerms, bt as AnySchema, c as MatchResult, ca as GenericOperatorImplementation, ci as Grouped, cn as least, cr as ConflictUpdateSet, ct as RelationKey, d as defineExpression, di as QueryStateOf, dn as ExpressionValue, dr as UpdateValues, dt as RequiredMember, ea as ColumnAttributes, ei as OperandValue, en as FollowingOperand, er as RelationRefs, et as TransformedQueryState, f as ConnectionError, fi as QueryValueType, fn as GroupOperandValue, fr as UpsertValues, ft as SchemaContext, g as FALSE, gi as AnyTable, gn as MergeSelection, gr as GroupedState, gt as UsableRelation, h as toDriverError, hi as TableQueryState, hn as GroupedRecord, hr as FoundState, ht as TableRelations, i as param, ia as MergeOperators, ii as TypedScalarQuery, in as TypedOperandOperators, ir as SelectQuery, it as OneRelationKeys, j as UntypedExpression, ji as NotFoundError, jn as UnfilteredAggregateOptions, jr as Condition, jt as AnyQuery, k as ExpressionOperators, ki as createTableFactory, kn as GroupValue, kr as WhereValues, kt as RecordQueryState, l as NotAColumn, la as OperatorSignature, li as InitialQueryState, ln as ColumnFieldTypes, lr as InsertValues, lt as RelationKeys, m as QueryError, mi as SingletonQueryState, mn as GroupedField, mr as FoundQueryState, mt as TableContext, n as SqlTemplate, na as ToColumn, ni as OperandUses, nn as TypedOperand, nr as BoundSelectQuery, nt as MergeRelations, o as ColumnRefKey, oa as OperatorDefinitions, oi as EmptyRecord, on as coalesce, or as from, ot as RelationDeclaration, p as DriverErrorFields, pi as SelectQueryState, pn as GroupSelectionResult, pr as FilteredStateRows, pt as SchemaRelations, qi as TypeOperators, qn as Ordering, qr as EqualityOperators, qt as MutationQueryState, r as identifier, ra as BoundOperators, ri as ScalarQuery, rn as TypedOperandInput, rr as ResultOf, rt as NoRelations, s as MatchCheck, sa as GenericOperator, si as FoundKey, sn as greatest, sr as ColumnValue, st as RelationDeclarations, t as toSnakeCase, ta as KeyKind, ti as compare, tn as NullSkippingResult, tr as AnySelectQuery, tt as DeclaredRelations, u as matches, ua as defineGenericOperator, ui as QueryState, un as ExpressionInput, ur as UpdateSet, ut as RelationKind, v as PatternSignature, vi as ColumnDefinitions, vn as SelectedFieldTypes, vr as RowLockOptions, vt as many, w as NumberTypeOperators, wi as Table, wn as literal, wr as PrimaryKeyValues, wt as SchemaTables, x as TextOperators, xi as ColumnValues, xn as SelectionResult, xr as KeyCheck, xt as Schema, y as TextConversionSignature, yi as ColumnOperators, yn as Selection, yr as GroupTerm, yt as one, z as DatabaseOptions, zi as SqlStatement, zn as some, zr as OneRow, zt as AnyMutationQuery } from "./index-B1aH5Ht0.mjs";
+export { type AggregateExpression, type AggregateOptions, type AnyColumn, type AnyDb, type AnyExpression, type AnyMutationQuery, type AnyQuery, type AnyRecordQuery, type AnySchema, type AnySelectQuery, type AnySqlQuery, type AnyTable, type AnyTableKeys, type AnyTransformedQuery, type AnyType, type BaseOperators, type BaseType, type BindOptions, type BooleanResult, type BoundOperators, type BoundSelectQuery, type CaseBranch, type CaseCondition, type CaseValue, type Column, type ColumnAttributes, type ColumnDefinitions, type ColumnFieldTypes, type ColumnOperators, type ColumnRefKey, type ColumnRefs, type ColumnShape, type ColumnValue, type ColumnValues, type CombinedCondition, type ComparisonSignature, type CompileOptions, type Condition, type ConditionOperand, type ConflictActionRequired, type ConflictKeyRequired, type ConflictTarget, type ConflictUpdateSet, type Connection, ConnectionError, type CountExpression, type CountValueType, type Database, type DatabaseOptions, type Db, type DbMutationState, type DbOf, type DbQueryState, type DeclaredRelations, type DecodedFields, type Driver, type DriverErrorFields, type DriverResult, type EmptyRecord, type EqValue, type EqualityOperator, type EqualityOperators, type ExistsValueType, type Expression, type ExpressionInput, type ExpressionOperators, type ExpressionValue, FALSE, type FieldTypes, type FilteredRows, type FilteredStateRows, type FollowingOperand, type FoundKey, type FoundQueryState, type FoundState, type GenericOperator, type GenericOperatorImplementation, type GroupAggregateExpression, type GroupOperandValue, type GroupSelectionResult, type GroupTerm, type GroupTerms, type GroupValue, type Grouped, type GroupedField, type GroupedRecord, type GroupedState, type HasEquality, type Helper, type HelperEffect, type InSignature, type InitialInsertState, type InitialMutationState, type InitialQueryState, type InitialSqlQueryState, type InsertMutationState, type InsertValues, type KeyCheck, type KeyColumns, type KeyKind, type Literal, type MatchCheck, type MatchResult, type MergeOperators, type MergeRelations, type MergeSelection, type MutationQuery, type MutationQueryState, type NestedQuery, type NoOperators, type NoRelations, type NotAColumn, type NotAKey, NotFoundError, type NotSynchronous, type NullSkippingResult, type NumberTypeOperators, type OneRelationKeys, type OneRow, type OneValueRows, type Operand, type OperandUses, type OperandValue, type OperatorDefinitions, type OperatorSignature, type OrderColumns, type OrderDirection, type OrderKey, type OrderTerm, type OrderTerms, type Ordering, type PatternSignature, type Predicate, type PrimaryKeyColumn, type PrimaryKeyValues, type QueryContext, QueryError, type QueryResult, type QueryState, type QueryStateOf, type QueryValueType, type RecordQuery, type RecordQueryState, type Relation, type RelationDeclaration, type RelationDeclarations, type RelationKey, type RelationKeys, type RelationKind, type RelationRefs, type RequiredMember, RequiredRelationError, type ResultByRows, ResultDecodeError, type ResultMode, type ResultOf, type ResultRows, type RowLockOptions, type ScalarQuery, type Schema, type SchemaContext, type SchemaPart, type SchemaPartRelations, type SchemaRelations, type SchemaTables, type SelectQuery, type SelectQueryKind, type SelectQueryState, type Selectable, type SelectedFieldTypes, type SelectedOperandType, type SelectedRefs, type Selection, type SelectionFieldTypes, type SelectionResult, type SelectionState, type SelectionUses, type SingletonInsertMany, type SingletonQueryState, type SqlQuery, type SqlQueryState, type SqlStatement, type SqlTemplate, type StringAggOptions, type SynchronousResult, TRUE, type Table, type TableContext, type TableFactoryOptions, type TableKeys, type TableOptions, type TableQueryState, type TableRelations, type Tables, type TextConversionSignature, type TextLengthSignature, type TextOperators, type TextTypeOperators, type TextValue, type ToColumn, type ToColumns, type TransactionCoordinator, type TransactionFailure, type TransactionOptions, type TransformedQuery, type TransformedQueryState, type Type, type TypeInput, type TypeOperators, type TypeOptions, type TypeOutput, type TypeTransform, type TypedExpression, type TypedOperand, type TypedOperandInput, type TypedOperandOperators, type TypedScalarQuery, type UnfilteredAggregateOptions, type UnfilteredStringAggOptions, type UntypedExpression, type UpdateSet, type UpdateValues, type UpsertValues, type UsableRelation, type UsedRelation, type ValueRows, type ValuesQuery, type WhereCallback, type WhereCondition, type WhereFilter, type WhereValues, 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 };

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 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";
 // 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());
@@ -157,4 +157,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, 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 };

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 { 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";
 /** 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`.

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 { 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 { _ 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
@@ -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,32 @@ 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);
+				let failure;
+				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");
+				} catch (error) {
+					failure = { error };
+					throw error;
+				} finally {
+					await connection.release(failure);
+				}
+			} finally {
+				await own.close();
+			}
+		});
 		it("decodes selected expressions with their types", async () => {
 			const tag = defineTable("pg_tag_test", {
 				id: integer,
@@ -201,6 +245,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(() => {});
@@ -233,7 +304,7 @@ function describeDriverContract(options, runner) {
 				await driver.close();
 			}
 		});
-		if (closesReservedConnections) {
+		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 });
 				try {
@@ -261,7 +332,48 @@ function describeDriverContract(options, runner) {
 					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);
+					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);
+					}
+				} 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 +465,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 { 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";
 /**
  * Creates a one-dimensional array type of `element` values.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kern-orm",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Fully typed relational query builder for PostgreSQL with ambient transactions and single-query relation loading",
   "keywords": [
     "orm",
@@ -42,13 +42,7 @@
   },
   "devDependencies": {
     "@kern-orm/postgres-js": "workspace:*",
-    "kern-orm-0.2.0": "https://registry.npmjs.org/kern-orm/-/kern-orm-0.2.0.tgz",
-    "kern-orm-0.3.0": "https://registry.npmjs.org/kern-orm/-/kern-orm-0.3.0.tgz",
-    "migrations-published": "https://registry.npmjs.org/@kern-orm/migrations/-/migrations-0.3.1.tgz",
-    "node-postgres-published": "https://registry.npmjs.org/@kern-orm/node-postgres/-/node-postgres-0.1.0.tgz",
     "postgres": "catalog:",
-    "postgres-js-published": "https://registry.npmjs.org/@kern-orm/postgres-js/-/postgres-js-0.1.2.tgz",
-    "postgres-js-v3-published": "https://registry.npmjs.org/@kern-orm/postgres-js-v3/-/postgres-js-v3-0.1.2.tgz",
     "typescript-6": "catalog:"
   },
   "engines": {