kern-orm 0.6.0 → 0.8.0

package/dist/index.d.mts

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

package/dist/{text-Cti9QLK7.mjs → text-CIUxPWPl.mjs}

@@ -240,6 +240,7 @@ function createType(state) {
 		withParameters: (format) => derive({ formatSqlType: format }),
 		...formatSqlType && { with: (...parameters) => derive({ sqlType: formatSqlType(...parameters) }) },
 		nullable: () => derive({ isNullable: true }),
+		of: () => type,
 		columnName: (name) => new Column(type, {
 			name,
 			keyKind: void 0,

package/dist/{types-DfoL8Oi9.mjs → types-D3d35qR2.mjs}

@@ -1,4 +1,4 @@
-import { A as hasEquality, E as defineType, T as getBooleanType, a as stringifyJson, d as orderingOperators, i as formatTypeName, k as equalityOperators, l as defineNumberType, o as decodeBytea, s as encodeBytea, u as getIntegerType } from "./text-Cti9QLK7.mjs";
+import { A as hasEquality, E as defineType, T as getBooleanType, a as stringifyJson, d as orderingOperators, i as formatTypeName, k as equalityOperators, l as defineNumberType, o as decodeBytea, s as encodeBytea, u as getIntegerType } from "./text-CIUxPWPl.mjs";
 // src/type/builtins/array.ts
 /**
 * Creates a one-dimensional array type of `element` values.
@@ -196,10 +196,7 @@ function enumOf(name, _values) {
 	return defineType({
 		sqlType: name,
 		castType: name
-	}).transform({
-		decode: (value) => value,
-		encode: (value) => value
-	}).withOperators(orderingOperators);
+	}).withOperators(orderingOperators).of();
 }
 // src/type/builtins/json.ts
 function createJsonType(sqlType) {
@@ -208,16 +205,10 @@ function createJsonType(sqlType) {
 		encode: stringifyJson
 	});
 }
-function addShape(type) {
-	return Object.freeze({
-		...type,
-		of: () => type
-	});
-}
 /** `json` values; `json.of<T>()` declares their shape. PostgreSQL has no `=` for `json`, so its expressions have no `eq`, `ne`, or `in`. */
-const json = /* @__PURE__ */ addShape(/* @__PURE__ */ createJsonType("json"));
+const json = /* @__PURE__ */ createJsonType("json");
 /** `jsonb` values; `jsonb.of<T>()` declares their shape. */
-const jsonb = /* @__PURE__ */ addShape(/* @__PURE__ */ createJsonType("jsonb").withOperators(equalityOperators));
+const jsonb = /* @__PURE__ */ createJsonType("jsonb").withOperators(equalityOperators);
 // src/type/builtins/network.ts
 /** IP address with an optional netmask as a string, such as `192.168.0.1`. */
 const inet = /* @__PURE__ */ defineType({ sqlType: "inet" }).withOperators(orderingOperators);

package/dist/types.d.mts

@@ -1,4 +1,4 @@
-import { Bi as MergeOperators, Di as Type, Hi as OperatorDefinitions, Lr as ComparisonSignature, Mr as EqualityOperators, Nr as HasEquality, Pr as InSignature, S as AnyExpression, Ti as BaseType, Ui as GenericOperator, Vi as NoOperators, _ as TextOperators, b as NumberTypeOperators, jr as EqualityOperator, v as TextTypeOperators } from "./index-CoKpXcBp.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.
  *
@@ -71,15 +71,10 @@ declare function enumOf<const Values extends readonly string[]>(name: string, _v
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
 }>, undefined>;
-/** JSON type of `unknown` values with operators `O` and `of`, which declares their shape. */
-type JsonType<O extends OperatorDefinitions = NoOperators> = Type<unknown, unknown, O> & {
-  /** Declares the shape of the values, which is not validated at runtime. */
-  of<T>(): Type<T, T, O>;
-};
 /** `json` values; `json.of<T>()` declares their shape. PostgreSQL has no `=` for `json`, so its expressions have no `eq`, `ne`, or `in`. */
-export declare const json: JsonType<NoOperators>;
+export declare const json: BaseType<unknown, {}, NoOperators, undefined>;
 /** `jsonb` values; `jsonb.of<T>()` declares their shape. */
-export declare const jsonb: JsonType<MergeOperators<NoOperators, EqualityOperators>>;
+export declare const jsonb: BaseType<unknown, {}, MergeOperators<NoOperators, EqualityOperators>, undefined>;
 /** IP address with an optional netmask as a string, such as `192.168.0.1`. */
 export declare const inet: BaseType<string, string, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;

package/dist/types.mjs

@@ -1,3 +1,3 @@
-import { n as text, r as varchar, t as char } from "./text-Cti9QLK7.mjs";
-import { _ as timestamptz, a as numeric, b as array, c as cidr, d as jsonb, f as enumOf, g as timestamp, h as time, i as integer, l as inet, m as interval, n as bigint, o as real, p as date, r as doublePrecision, s as smallint, t as uuid, u as json, v as boolean, y as bytea } from "./types-DfoL8Oi9.mjs";
+import { n as text, r as varchar, t as char } from "./text-CIUxPWPl.mjs";
+import { _ as timestamptz, a as numeric, b as array, c as cidr, d as jsonb, f as enumOf, g as timestamp, h as time, i as integer, l as inet, m as interval, n as bigint, o as real, p as date, r as doublePrecision, s as smallint, t as uuid, u as json, v as boolean, y as bytea } from "./types-D3d35qR2.mjs";
 export { array, bigint, boolean, bytea, char, cidr, date, doublePrecision, enumOf as enum, inet, integer, interval, json, jsonb, numeric, real, smallint, text, time, timestamp, timestamptz, uuid, varchar };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kern-orm",
-  "version": "0.6.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": {