kern-orm 0.1.0 → 0.2.0

package/dist/{expression-Bc-s_0qJ.d.mts → expression-tYmWRuKR.d.mts}

@@ -1679,12 +1679,12 @@ declare class TransactionCoordinator {
   /** Executes a script of statements without parameters where `execute` executes a statement. */
   executeScript(text: string): Promise<void>;
   /**
-   * Runs `callback` in a transaction that commits when it resolves and rolls back when it rejects.
+   * Runs `callback` in a transaction that commits when it resolves and rolls back when it rejects, with the settings of `options`.
    *
-   * Inside a transaction, it runs `callback` in a savepoint nested in it.
+   * Inside a transaction, it runs `callback` in a savepoint nested in it, which restores the settings it changed when it ends.
    * A failed cleanup after an error rejects with a `SuppressedError` that keeps the original error in its `suppressed` chain.
    */
-  transaction<T>(callback: () => Promise<T>): Promise<T>;
+  transaction<T>(callback: () => Promise<T>, options?: TransactionOptions): Promise<T>;
   /**
    * Runs `callback` in a transaction that always rolls back, on a coordinator created for tests.
    *
@@ -1754,10 +1754,19 @@ interface Database extends AsyncDisposable {
    *
    * Inside an existing transaction, it starts a nested transaction.
    */
-  transaction<T>(callback: () => Promise<T>): Promise<T>;
+  transaction<T>(callback: () => Promise<T>, options?: TransactionOptions): Promise<T>;
   /** Rolls back the open test fixtures and closes the connections of the driver once the running transactions end. */
   close(): Promise<void>;
 }
+/** Options of `transaction` of a `Database` and `$transaction` of a `Db`. */
+interface TransactionOptions {
+  /**
+   * PostgreSQL schemas where the unqualified names of the statements of the transaction resolve, in their order, such as the schema of a tenant followed by the schema of extensions.
+   *
+   * It applies to the statements of the callback, including those of its nested transactions, until the transaction ends; a nested transaction then restores the search path of the enclosing transaction.
+   */
+  searchPath?: readonly string[];
+}
 /** Options of `createDatabase`. */
 interface DatabaseOptions {
   driver: Driver;
@@ -1792,6 +1801,14 @@ interface DbMutationState<T extends AnyTable, U extends UsedRelation> extends Mu
 }
 interface DbMethods<T extends Tables, R extends SchemaRelations> {
   readonly $schema: Schema<T, R>;
+  /** Database that the `Db` is bound to. */
+  readonly $database: Database;
+  /**
+   * PostgreSQL schema of the tables, or `undefined` for a `Db` bound without `schemaName`.
+   *
+   * Reading it calls the function of `schemaName`, as compiling a query does, such as to resolve the schema of the current tenant.
+   */
+  readonly $schemaName: string | undefined;
   /**
    * Compiles a query over the tables of the schema into SQL text and parameters.
    *
@@ -1833,7 +1850,7 @@ interface DbMethods<T extends Tables, R extends SchemaRelations> {
    *
    * Inside an existing transaction, it starts a nested transaction.
    */
-  $transaction<Result>(callback: () => Promise<Result>): Promise<Result>;
+  $transaction<Result>(callback: () => Promise<Result>, options?: TransactionOptions): Promise<Result>;
 }
 /**
  * `Db` of schema `S`, such as the type of a parameter of code shared by several schemas.
@@ -2088,4 +2105,4 @@ type TypedExpression<T = unknown> = AnyExpression<T> & {
 interface BaseOperators {
   isNull(): Expression<boolean>;
 }
-export { one as $, TextValue as $n, and as $t, SqlQueryState as A, ColumnOperators as An, UpdateValues as At, RelationDeclaration as B, NotFoundError as Bn, orderBy as Bt, AnyQuery as C, Operand as Cn, ResultOf as Ct, FieldTypes as D, AnyTable as Dn, ColumnValue as Dt, DecodedFields as E, CompileOptions as En, from as Et, DeclaredRelations as F, Table as Fn, OrderTerms as Ft, RequiredMember as G, Connection as Gn, WhereCondition as Gt, RelationKey as H, ResultDecodeError as Hn, NotAKey as Ht, MergeRelations as I, TableKeys as In, Ordering as It, TableContext as J, SqlStatement as Jn, defineFilter as Jt, SchemaContext as K, Driver as Kn, WhereFilter as Kt, NoRelations as L, TableOptions as Ln, SelectedRefs as Lt, InitialMutationState as M, ColumnValues as Mn, OrderDirection as Mt, MutationQuery as N, KeyColumns as Nn, OrderKey as Nt, InitialSqlQueryState as O, AnyTableKeys as On, InsertValues as Ot, MutationQueryState as P, Selectable as Pn, OrderTerm as Pt, many as Q, BaseType as Qn, Predicate as Qt, OneRelationKeys as R, ToColumns as Rn, asc as Rt, createTestHelpers as S, ComparisonSignature as Sn, FilteredStateRows as St, AnySqlQuery as T, compare as Tn, TableOrQuery as Tt, RelationKeys as U, ResultMode as Un, PrimaryKeyValues as Ut, RelationDeclarations as V, RequiredRelationError as Vn, KeyCheck as Vt, RelationKind as W, ResultRows as Wn, EqValue as Wt, UsableRelation as X, createStatement as Xn, Condition as Xt, TableRelations as Y, TransactionFailure as Yn, CombinedCondition as Yt, UsedRelation as Z, AnyType as Zn, ConditionOperand as Zt, PendingTestFixture as _, EqualityOperators as _n, GenericOperatorImplementation as _r, SelectionResult as _t, UntypedExpression as a, FilteredRows as an, TypeTransform as ar, Tables as at, TestHooks as b, equalityOperators as bn, BoundSelectQuery as bt, Db as c, QueryResult as cn, Column as cr, RecordQuery as ct, DbQueryState as d, EmptyRecord as dn, ToColumn as dr, ExpressionInput as dt, not as en, Type as er, AnySchema as et, Database as f, InitialQueryState as fn, BoundOperators as fr, ExpressionValue as ft, OpenedTestFixture as g, EqualityOperator as gn, GenericOperator as gr, Selection as gt, TransactionCoordinator as h, SelectQueryState as hn, OperatorDefinitions as hr, NestedQuery as ht, TypedExpression as i, RelationRefs as in, TypeOutput as ir, SchemaTables as it, AnyMutationQuery as j, ColumnShape as jn, OrderColumns as jt, SqlQuery as k, ColumnDefinitions as kn, UpdateSet as kt, DbMutationState as l, ResultByRows as ln, ColumnAttributes as lr, RecordQueryState as lt, createDatabase as m, QueryStateOf as mn, NoOperators as mr, MergeSelection as mt, BaseOperators as n, ColumnRefs as nn, TypeOperators as nr, SchemaPart as nt, AnyDb as o, OneRow as on, defineType as or, defineSchema as ot, DatabaseOptions as p, QueryState as pn, MergeOperators as pr, HelperFields as pt, SchemaRelations as q, DriverResult as qn, WhereValues as qt, Expression as r, QueryContext as rn, TypeOptions as rr, SchemaPartRelations as rt, BindOptions as s, OneValueRows as sn, AnyColumn as sr, AnyRecordQuery as st, AnyExpression as t, or as tn, TypeInput as tr, Schema as tt, DbOf as u, ValueRows as un, KeyKind as ur, SelectionState as ut, TestFixture as v, HasEquality as vn, OperatorSignature as vr, SelectionUses as vt, SelectQueryKind as w, OperandValue as wn, SelectQuery as wt, TestTransactionOptions as x, BooleanResult as xn, ChangeState as xt, TestHelpers as y, InSignature as yn, defineGenericOperator as yr, AnySelectQuery as yt, Relation as z, defineTable as zn, desc as zt };
+export { many as $, BaseType as $n, Predicate as $t, SqlQuery as A, ColumnDefinitions as An, UpdateSet as At, Relation as B, defineTable as Bn, desc as Bt, createTestHelpers as C, ComparisonSignature as Cn, FilteredStateRows as Ct, DecodedFields as D, CompileOptions as Dn, from as Dt, AnySqlQuery as E, compare as En, TableOrQuery as Et, MutationQueryState as F, Selectable as Fn, OrderTerm as Ft, RelationKind as G, ResultRows as Gn, EqValue as Gt, RelationDeclarations as H, RequiredRelationError as Hn, KeyCheck as Ht, DeclaredRelations as I, Table as In, OrderTerms as It, SchemaRelations as J, DriverResult as Jn, WhereValues as Jt, RequiredMember as K, Connection as Kn, WhereCondition as Kt, MergeRelations as L, TableKeys as Ln, Ordering as Lt, AnyMutationQuery as M, ColumnShape as Mn, OrderColumns as Mt, InitialMutationState as N, ColumnValues as Nn, OrderDirection as Nt, FieldTypes as O, AnyTable as On, ColumnValue as Ot, MutationQuery as P, KeyColumns as Pn, OrderKey as Pt, UsedRelation as Q, AnyType as Qn, ConditionOperand as Qt, NoRelations as R, TableOptions as Rn, SelectedRefs as Rt, TestTransactionOptions as S, BooleanResult as Sn, ChangeState as St, SelectQueryKind as T, OperandValue as Tn, SelectQuery as Tt, RelationKey as U, ResultDecodeError as Un, NotAKey as Ut, RelationDeclaration as V, NotFoundError as Vn, orderBy as Vt, RelationKeys as W, ResultMode as Wn, PrimaryKeyValues as Wt, TableRelations as X, TransactionFailure as Xn, CombinedCondition as Xt, TableContext as Y, SqlStatement as Yn, defineFilter as Yt, UsableRelation as Z, createStatement as Zn, Condition as Zt, OpenedTestFixture as _, EqualityOperator as _n, GenericOperator as _r, Selection as _t, UntypedExpression as a, RelationRefs as an, TypeOutput as ar, SchemaTables as at, TestHelpers as b, InSignature as bn, defineGenericOperator as br, AnySelectQuery as bt, Db as c, OneValueRows as cn, AnyColumn as cr, AnyRecordQuery as ct, DbQueryState as d, ValueRows as dn, KeyKind as dr, SelectionState as dt, and as en, TextValue as er, one as et, Database as f, EmptyRecord as fn, ToColumn as fr, ExpressionInput as ft, TransactionCoordinator as g, SelectQueryState as gn, OperatorDefinitions as gr, NestedQuery as gt, createDatabase as h, QueryStateOf as hn, NoOperators as hr, MergeSelection as ht, TypedExpression as i, QueryContext as in, TypeOptions as ir, SchemaPartRelations as it, SqlQueryState as j, ColumnOperators as jn, UpdateValues as jt, InitialSqlQueryState as k, AnyTableKeys as kn, InsertValues as kt, DbMutationState as l, QueryResult as ln, Column as lr, RecordQuery as lt, TransactionOptions as m, QueryState as mn, MergeOperators as mr, HelperFields as mt, BaseOperators as n, or as nn, TypeInput as nr, Schema as nt, AnyDb as o, FilteredRows as on, TypeTransform as or, Tables as ot, DatabaseOptions as p, InitialQueryState as pn, BoundOperators as pr, ExpressionValue as pt, SchemaContext as q, Driver as qn, WhereFilter as qt, Expression as r, ColumnRefs as rn, TypeOperators as rr, SchemaPart as rt, BindOptions as s, OneRow as sn, defineType as sr, defineSchema as st, AnyExpression as t, not as tn, Type as tr, AnySchema as tt, DbOf as u, ResultByRows as un, ColumnAttributes as ur, RecordQueryState as ut, PendingTestFixture as v, EqualityOperators as vn, GenericOperatorImplementation as vr, SelectionResult as vt, AnyQuery as w, Operand as wn, ResultOf as wt, TestHooks as x, equalityOperators as xn, BoundSelectQuery as xt, TestFixture as y, HasEquality as yn, OperatorSignature as yr, SelectionUses as yt, OneRelationKeys as z, ToColumns as zn, asc as zt };

package/dist/{index-Chr-UK_t.d.mts → index-pj2AhTRY.d.mts}

@@ -1,4 +1,4 @@
-import { Cn as Operand, Dn as AnyTable, K as SchemaContext, L as NoRelations, Sn as ComparisonSignature, St as FilteredStateRows, Tt as TableOrQuery, Wn as ResultRows, X as UsableRelation, Z as UsedRelation, a as UntypedExpression, er as Type, gn as EqualityOperator, gr as GenericOperator, hn as SelectQueryState, hr as OperatorDefinitions, mn as QueryStateOf, mt as MergeSelection, on as OneRow, pt as HelperFields, r as Expression, t as AnyExpression, vr as OperatorSignature, w as SelectQueryKind, wn as OperandValue, wt as SelectQuery, xn as BooleanResult, xt as ChangeState, yn as InSignature } from "./expression-Bc-s_0qJ.mjs";
+import { Cn as ComparisonSignature, Ct as FilteredStateRows, Et as TableOrQuery, Gn as ResultRows, On as AnyTable, Q as UsedRelation, R as NoRelations, Sn as BooleanResult, St as ChangeState, T as SelectQueryKind, Tn as OperandValue, Tt as SelectQuery, Z as UsableRelation, _n as EqualityOperator, _r as GenericOperator, a as UntypedExpression, bn as InSignature, gn as SelectQueryState, gr as OperatorDefinitions, hn as QueryStateOf, ht as MergeSelection, mt as HelperFields, q as SchemaContext, r as Expression, sn as OneRow, t as AnyExpression, tr as Type, wn as Operand, yr as OperatorSignature } from "./expression-tYmWRuKR.mjs";
 /** Operators of ordered types: those of `equalityOperators`, and `lt`, `lte`, `gt`, and `gte` comparing with operands of the expression type. */
 declare const orderingOperators: {
   eq: EqualityOperator<ComparisonSignature>;

package/dist/index.d.mts

@@ -1,3 +1,3 @@
-import { $ as one, $n as TextValue, $t as and, A as SqlQueryState, An as ColumnOperators, At as UpdateValues, B as RelationDeclaration, Bn as NotFoundError, Bt as orderBy, C as AnyQuery, Cn as Operand, Ct as ResultOf, D as FieldTypes, Dn as AnyTable, Dt as ColumnValue, E as DecodedFields, En as CompileOptions, Et as from, F as DeclaredRelations, Fn as Table, Ft as OrderTerms, G as RequiredMember, Gn as Connection, Gt as WhereCondition, H as RelationKey, Hn as ResultDecodeError, Ht as NotAKey, I as MergeRelations, In as TableKeys, It as Ordering, J as TableContext, Jn as SqlStatement, Jt as defineFilter, K as SchemaContext, Kn as Driver, Kt as WhereFilter, L as NoRelations, Ln as TableOptions, Lt as SelectedRefs, M as InitialMutationState, Mn as ColumnValues, Mt as OrderDirection, N as MutationQuery, Nn as KeyColumns, Nt as OrderKey, O as InitialSqlQueryState, On as AnyTableKeys, Ot as InsertValues, P as MutationQueryState, Pn as Selectable, Pt as OrderTerm, Q as many, Qn as BaseType, Qt as Predicate, R as OneRelationKeys, Rn as ToColumns, Rt as asc, Sn as ComparisonSignature, St as FilteredStateRows, T as AnySqlQuery, Tn as compare, U as RelationKeys, Un as ResultMode, Ut as PrimaryKeyValues, V as RelationDeclarations, Vn as RequiredRelationError, Vt as KeyCheck, W as RelationKind, Wn as ResultRows, Wt as EqValue, X as UsableRelation, Xn as createStatement, Xt as Condition, Y as TableRelations, Yn as TransactionFailure, Yt as CombinedCondition, Z as UsedRelation, Zn as AnyType, Zt as ConditionOperand, _n as EqualityOperators, _r as GenericOperatorImplementation, _t as SelectionResult, a as UntypedExpression, an as FilteredRows, ar as TypeTransform, at as Tables, bn as equalityOperators, bt as BoundSelectQuery, c as Db, cn as QueryResult, cr as Column, ct as RecordQuery, d as DbQueryState, dn as EmptyRecord, dr as ToColumn, dt as ExpressionInput, en as not, er as Type, et as AnySchema, f as Database, fn as InitialQueryState, fr as BoundOperators, ft as ExpressionValue, gn as EqualityOperator, gr as GenericOperator, gt as Selection, h as TransactionCoordinator, hn as SelectQueryState, hr as OperatorDefinitions, ht as NestedQuery, i as TypedExpression, in as RelationRefs, ir as TypeOutput, it as SchemaTables, j as AnyMutationQuery, jn as ColumnShape, jt as OrderColumns, k as SqlQuery, kn as ColumnDefinitions, kt as UpdateSet, l as DbMutationState, ln as ResultByRows, lr as ColumnAttributes, lt as RecordQueryState, m as createDatabase, mn as QueryStateOf, mr as NoOperators, mt as MergeSelection, n as BaseOperators, nn as ColumnRefs, nr as TypeOperators, nt as SchemaPart, o as AnyDb, on as OneRow, or as defineType, ot as defineSchema, p as DatabaseOptions, pn as QueryState, pr as MergeOperators, q as SchemaRelations, qn as DriverResult, qt as WhereValues, r as Expression, rn as QueryContext, rr as TypeOptions, rt as SchemaPartRelations, s as BindOptions, sn as OneValueRows, sr as AnyColumn, st as AnyRecordQuery, t as AnyExpression, tn as or, tr as TypeInput, tt as Schema, u as DbOf, un as ValueRows, ur as KeyKind, ut as SelectionState, vn as HasEquality, vr as OperatorSignature, vt as SelectionUses, w as SelectQueryKind, wn as OperandValue, wt as SelectQuery, xn as BooleanResult, yn as InSignature, yr as defineGenericOperator, yt as AnySelectQuery, z as Relation, zn as defineTable, zt as desc } from "./expression-Bc-s_0qJ.mjs";
-import { a as HelperEffect, c as textOperators, i as Helper, l as orderingOperators, n as param, o as defineHelper, r as sql, s as PatternSignature, t as SqlTemplate } from "./index-Chr-UK_t.mjs";
-export { type AnyColumn, type AnyDb, type AnyExpression, type AnyMutationQuery, type AnyQuery, type AnyRecordQuery, type AnySchema, type AnySelectQuery, type AnySqlQuery, type AnyTable, type AnyTableKeys, type AnyType, type BaseOperators, type BaseType, type BindOptions, type BooleanResult, type BoundOperators, type BoundSelectQuery, type Column, type ColumnAttributes, type ColumnDefinitions, type ColumnOperators, type ColumnRefs, type ColumnShape, type ColumnValue, type ColumnValues, type CombinedCondition, type ComparisonSignature, type CompileOptions, type Condition, type ConditionOperand, type Connection, 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 Expression, type ExpressionInput, type ExpressionValue, type FieldTypes, type FilteredRows, type FilteredStateRows, type GenericOperator, type GenericOperatorImplementation, type HasEquality, type Helper, type HelperEffect, type InSignature, type InitialMutationState, type InitialQueryState, type InitialSqlQueryState, type InsertValues, type KeyCheck, type KeyColumns, type KeyKind, type MergeOperators, type MergeRelations, type MergeSelection, type MutationQuery, type MutationQueryState, type NestedQuery, type NoOperators, type NoRelations, type NotAKey, NotFoundError, type OneRelationKeys, type OneRow, type OneValueRows, type Operand, 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 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 Schema, type SchemaContext, type SchemaPart, type SchemaPartRelations, type SchemaRelations, type SchemaTables, type SelectQuery, type SelectQueryKind, type SelectQueryState, type Selectable, type SelectedRefs, type Selection, type SelectionResult, type SelectionState, type SelectionUses, type SqlQuery, type SqlQueryState, type SqlStatement, type SqlTemplate, type Table, type TableContext, type TableKeys, type TableOptions, type TableRelations, type Tables, type TextValue, type ToColumn, type ToColumns, type TransactionCoordinator, type TransactionFailure, type Type, type TypeInput, type TypeOperators, type TypeOptions, type TypeOutput, type TypeTransform, type TypedExpression, type UntypedExpression, type UpdateSet, type UpdateValues, type UsableRelation, type UsedRelation, type ValueRows, type WhereCondition, type WhereFilter, type WhereValues, and, asc, compare, createDatabase, createStatement, defineFilter, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, from, many, not, one, or, orderBy, orderingOperators, param, sql, textOperators };
+import { $ as many, $n as BaseType, $t as Predicate, A as SqlQuery, An as ColumnDefinitions, At as UpdateSet, B as Relation, Bn as defineTable, Bt as desc, Cn as ComparisonSignature, Ct as FilteredStateRows, D as DecodedFields, Dn as CompileOptions, Dt as from, E as AnySqlQuery, En as compare, F as MutationQueryState, Fn as Selectable, Ft as OrderTerm, G as RelationKind, Gn as ResultRows, Gt as EqValue, H as RelationDeclarations, Hn as RequiredRelationError, Ht as KeyCheck, I as DeclaredRelations, In as Table, It as OrderTerms, J as SchemaRelations, Jn as DriverResult, Jt as WhereValues, K as RequiredMember, Kn as Connection, Kt as WhereCondition, L as MergeRelations, Ln as TableKeys, Lt as Ordering, M as AnyMutationQuery, Mn as ColumnShape, Mt as OrderColumns, N as InitialMutationState, Nn as ColumnValues, Nt as OrderDirection, O as FieldTypes, On as AnyTable, Ot as ColumnValue, P as MutationQuery, Pn as KeyColumns, Pt as OrderKey, Q as UsedRelation, Qn as AnyType, Qt as ConditionOperand, R as NoRelations, Rn as TableOptions, Rt as SelectedRefs, Sn as BooleanResult, T as SelectQueryKind, Tn as OperandValue, Tt as SelectQuery, U as RelationKey, Un as ResultDecodeError, Ut as NotAKey, V as RelationDeclaration, Vn as NotFoundError, Vt as orderBy, W as RelationKeys, Wn as ResultMode, Wt as PrimaryKeyValues, X as TableRelations, Xn as TransactionFailure, Xt as CombinedCondition, Y as TableContext, Yn as SqlStatement, Yt as defineFilter, Z as UsableRelation, Zn as createStatement, Zt as Condition, _n as EqualityOperator, _r as GenericOperator, _t as Selection, a as UntypedExpression, an as RelationRefs, ar as TypeOutput, at as SchemaTables, bn as InSignature, br as defineGenericOperator, bt as AnySelectQuery, c as Db, cn as OneValueRows, cr as AnyColumn, ct as AnyRecordQuery, d as DbQueryState, dn as ValueRows, dr as KeyKind, dt as SelectionState, en as and, er as TextValue, et as one, f as Database, fn as EmptyRecord, fr as ToColumn, ft as ExpressionInput, g as TransactionCoordinator, gn as SelectQueryState, gr as OperatorDefinitions, gt as NestedQuery, h as createDatabase, hn as QueryStateOf, hr as NoOperators, ht as MergeSelection, i as TypedExpression, in as QueryContext, ir as TypeOptions, it as SchemaPartRelations, j as SqlQueryState, jn as ColumnOperators, jt as UpdateValues, k as InitialSqlQueryState, kn as AnyTableKeys, kt as InsertValues, l as DbMutationState, ln as QueryResult, lr as Column, lt as RecordQuery, m as TransactionOptions, mn as QueryState, mr as MergeOperators, n as BaseOperators, nn as or, nr as TypeInput, nt as Schema, o as AnyDb, on as FilteredRows, or as TypeTransform, ot as Tables, p as DatabaseOptions, pn as InitialQueryState, pr as BoundOperators, pt as ExpressionValue, q as SchemaContext, qn as Driver, qt as WhereFilter, r as Expression, rn as ColumnRefs, rr as TypeOperators, rt as SchemaPart, s as BindOptions, sn as OneRow, sr as defineType, st as defineSchema, t as AnyExpression, tn as not, tr as Type, tt as AnySchema, u as DbOf, un as ResultByRows, ur as ColumnAttributes, ut as RecordQueryState, vn as EqualityOperators, vr as GenericOperatorImplementation, vt as SelectionResult, w as AnyQuery, wn as Operand, wt as ResultOf, xn as equalityOperators, xt as BoundSelectQuery, yn as HasEquality, yr as OperatorSignature, yt as SelectionUses, z as OneRelationKeys, zn as ToColumns, zt as asc } from "./expression-tYmWRuKR.mjs";
+import { a as HelperEffect, c as textOperators, i as Helper, l as orderingOperators, n as param, o as defineHelper, r as sql, s as PatternSignature, t as SqlTemplate } from "./index-pj2AhTRY.mjs";
+export { type AnyColumn, type AnyDb, type AnyExpression, type AnyMutationQuery, type AnyQuery, type AnyRecordQuery, type AnySchema, type AnySelectQuery, type AnySqlQuery, type AnyTable, type AnyTableKeys, type AnyType, type BaseOperators, type BaseType, type BindOptions, type BooleanResult, type BoundOperators, type BoundSelectQuery, type Column, type ColumnAttributes, type ColumnDefinitions, type ColumnOperators, type ColumnRefs, type ColumnShape, type ColumnValue, type ColumnValues, type CombinedCondition, type ComparisonSignature, type CompileOptions, type Condition, type ConditionOperand, type Connection, 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 Expression, type ExpressionInput, type ExpressionValue, type FieldTypes, type FilteredRows, type FilteredStateRows, type GenericOperator, type GenericOperatorImplementation, type HasEquality, type Helper, type HelperEffect, type InSignature, type InitialMutationState, type InitialQueryState, type InitialSqlQueryState, type InsertValues, type KeyCheck, type KeyColumns, type KeyKind, type MergeOperators, type MergeRelations, type MergeSelection, type MutationQuery, type MutationQueryState, type NestedQuery, type NoOperators, type NoRelations, type NotAKey, NotFoundError, type OneRelationKeys, type OneRow, type OneValueRows, type Operand, 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 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 Schema, type SchemaContext, type SchemaPart, type SchemaPartRelations, type SchemaRelations, type SchemaTables, type SelectQuery, type SelectQueryKind, type SelectQueryState, type Selectable, type SelectedRefs, type Selection, type SelectionResult, type SelectionState, type SelectionUses, type SqlQuery, type SqlQueryState, type SqlStatement, type SqlTemplate, type Table, type TableContext, type TableKeys, type TableOptions, type TableRelations, type Tables, type TextValue, type ToColumn, type ToColumns, type TransactionCoordinator, type TransactionFailure, type TransactionOptions, type Type, type TypeInput, type TypeOperators, type TypeOptions, type TypeOutput, type TypeTransform, type TypedExpression, type UntypedExpression, type UpdateSet, type UpdateValues, type UsableRelation, type UsedRelation, type ValueRows, type WhereCondition, type WhereFilter, type WhereValues, and, asc, compare, createDatabase, createStatement, defineFilter, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, from, many, not, one, or, orderBy, orderingOperators, param, sql, textOperators };

package/dist/index.mjs

@@ -2753,12 +2753,17 @@ function bindSchema(schema, database, options = {}) {
 	const relations = schema[schemaRelations];
 	const definitions = collectDefinitions(relations);
 	const { schemaName } = options;
+	const resolveSchemaName = () => typeof schemaName === "function" ? schemaName() : schemaName;
 	function compile(query) {
 		if (query.db !== void 0 && query.db !== db) throw new Error("Cannot run a query bound to another Db");
-		return compileStatement(lowerStatement(query.node, definitions, db), { schemaName: typeof schemaName === "function" ? schemaName() : schemaName }, tables, db);
+		return compileStatement(lowerStatement(query.node, definitions, db), { schemaName: resolveSchemaName() }, tables, db);
 	}
 	const methods = {
 		$schema: schema,
+		$database: database,
+		get $schemaName() {
+			return resolveSchemaName();
+		},
 		$compile(query) {
 			const { text, parameters } = compile(query);
 			return createStatement(text, parameters);
@@ -2775,7 +2780,7 @@ function bindSchema(schema, database, options = {}) {
 			if (parameters.length > 0) throw new Error("A script takes no values, since it has no parameters; interpolate only tables and sql fragments without values");
 			return database.script(text);
 		},
-		$transaction: (callback) => database.transaction(callback)
+		$transaction: (callback, options) => database.transaction(callback, options)
 	};
 	const contexts = createQueryContexts(Object.keys(schema.$tables), relations);
 	const db = defineEntries(methods, schema.$tables, (key) => bindQuery(startQuery(schema.$tables[key], contexts[key]), db));
@@ -2833,16 +2838,17 @@ var TransactionCoordinator = class {
 		return createUnavailableError(level, operation) ?? level.connection;
 	}
 	/**
-	* Runs `callback` in a transaction that commits when it resolves and rolls back when it rejects.
+	* Runs `callback` in a transaction that commits when it resolves and rolls back when it rejects, with the settings of `options`.
 	*
-	* Inside a transaction, it runs `callback` in a savepoint nested in it.
+	* Inside a transaction, it runs `callback` in a savepoint nested in it, which restores the settings it changed when it ends.
 	* A failed cleanup after an error rejects with a `SuppressedError` that keeps the original error in its `suppressed` chain.
 	*/
-	transaction(callback) {
+	transaction(callback, options) {
+		const settings = getLevelSettings(options);
 		const parent = this.#storage.getStore();
-		if (parent) return this.#runNested(parent, callback, true);
+		if (parent) return this.#runNested(parent, callback, true, void 0, settings);
 		if (this.#closed) return Promise.reject(createDatabaseClosedError("start a transaction"));
-		return this.test ? Promise.reject(new Error(describeOutsideTest("start a transaction"))) : this.#runRoot(callback, true);
+		return this.test ? Promise.reject(new Error(describeOutsideTest("start a transaction"))) : this.#runRoot(callback, true, void 0, settings);
 	}
 	/**
 	* Runs `callback` in a transaction that always rolls back, on a coordinator created for tests.
@@ -3081,7 +3087,7 @@ var TransactionCoordinator = class {
 		signal?.throwIfAborted();
 		return this.#startNested(fixture, signal);
 	}
-	async #runRoot(callback, commits, signal) {
+	async #runRoot(callback, commits, signal, settings) {
 		const connection = await (signal ? acquireUnlessAborted(this.driver, signal) : this.driver.acquire());
 		if (signal?.aborted) throw (await releaseConnection(connection, void 0, { error: signal.reason })).error;
 		const level = createLevel(connection, void 0);
@@ -3095,22 +3101,28 @@ var TransactionCoordinator = class {
 				failure: { error }
 			};
 		}
+		if (!outcome && settings) try {
+			await applySettings(level, settings);
+		} catch (error) {
+			outcome = await getEndedOutcome(this.#end(level, false), error);
+		}
 		outcome ??= await this.#run(level, callback, commits, signal);
 		const rejection = await releaseConnection(connection, outcome.failure, outcome.rejection);
 		if (rejection) throw rejection.error;
 		return outcome.result;
 	}
-	async #runNested(parent, callback, commits, signal) {
+	async #runNested(parent, callback, commits, signal, settings) {
 		const unavailable = createUnavailableError(parent, "start a nested transaction");
 		if (unavailable) throw unavailable;
-		return this.#runStarted(await this.#startNested(parent, signal), callback, commits, signal);
+		return this.#runStarted(await this.#startNested(parent, signal, settings), callback, commits, signal);
 	}
 	/**
-	* Reserves a nested level of `parent` and sends its `SAVEPOINT`, rejecting when it fails.
+	* Reserves a nested level of `parent`, sends its `SAVEPOINT`, and applies its `settings`, rejecting when one of them fails.
 	*
+	* A level whose settings fail rolls back to its savepoint first.
 	* The failure suppresses the reason of `signal` when the signal aborted before it.
 	*/
-	async #startNested(parent, signal) {
+	async #startNested(parent, signal, settings) {
 		const level = createLevel(parent.connection, parent);
 		parent.child = level;
 		try {
@@ -3122,6 +3134,11 @@ var TransactionCoordinator = class {
 			}
 			throw suppressAbortReason(combineRejections({ error }, await level.cleanup).error, signal);
 		}
+		if (settings) try {
+			await applySettings(level, settings);
+		} catch (error) {
+			throw suppressAbortReason(combineRejections({ error }, await this.#end(level, false)).error, signal);
+		}
 		return level;
 	}
 	/** Runs `callback` in a started level, returning its result or throwing its rejection. */
@@ -3202,9 +3219,50 @@ function createLevel(connection, parent) {
 		child: void 0,
 		rollbackOnly: void 0,
 		cleanup: void 0,
-		endedBy: void 0
+		endedBy: void 0,
+		restore: void 0
 	};
 }
+/** Settings of a level of `transaction` with `options`, or `undefined` when it has none. */
+function getLevelSettings(options) {
+	return options?.searchPath ? [{
+		name: "search_path",
+		value: options.searchPath.map(quoteIdentifier).join(", ")
+	}] : void 0;
+}
+/**
+* Applies `settings` to a level whose `BEGIN` or `SAVEPOINT` completed, unless its cleanup has started.
+*
+* A nested level first reads the values they replace, which it restores before its `RELEASE`: PostgreSQL keeps a setting of a released savepoint until the transaction ends, while `ROLLBACK TO` restores it itself.
+*/
+async function applySettings(level, settings) {
+	if (level.cleanup) return;
+	if (level.parent) {
+		let text = "SELECT";
+		const names = [];
+		for (const { name } of settings) {
+			names.push(name);
+			text += `${names.length > 1 ? "," : ""} current_setting($${names.length})`;
+		}
+		const values = (await level.connection.execute(createStatement(text, names))).rows[0];
+		level.restore = createSettingStatement(settings.map(({ name }, index) => ({
+			name,
+			value: values[index]
+		})));
+		if (level.cleanup) return;
+	}
+	await level.connection.execute(createSettingStatement(settings));
+}
+/** Creates the statement that sets `settings` until the transaction ends or rolls back to an earlier savepoint, as `SET LOCAL` does. */
+function createSettingStatement(settings) {
+	let text = "SELECT";
+	const parameters = [];
+	for (const { name, value } of settings) {
+		parameters.push(name, value);
+		text += `${parameters.length > 2 ? "," : ""} set_config($${parameters.length - 1}, $${parameters.length}, true)`;
+	}
+	return createStatement(text, parameters);
+}
 /** Name of the savepoint of a nested level; a level has at most one nested level, so the depth makes it unique. */
 function getSavepointName(level) {
 	return `kern_${level.depth}`;
@@ -3315,11 +3373,16 @@ async function endTransaction(connection, commit) {
 		};
 	}
 }
-/** Ends the savepoint of a nested level, releasing it on commit and rolling back to it otherwise. */
+/**
+* Ends the savepoint of a nested level, releasing it on commit and rolling back to it otherwise.
+*
+* Before a release, it restores the settings that the level changed; a rollback restores them itself.
+*/
 async function endSavepoint(level, commit) {
 	const name = getSavepointName(level);
 	try {
 		if (!commit) await level.connection.execute(createStatement(`ROLLBACK TO SAVEPOINT ${name}`));
+		else if (level.restore) await level.connection.execute(level.restore);
 		await level.connection.execute(createStatement(`RELEASE SAVEPOINT ${name}`));
 		return {};
 	} catch (error) {
@@ -3346,7 +3409,7 @@ function createDatabase({ driver, test }) {
 		query: (strings, ...values) => getTablelessDb().$query(strings, ...values),
 		script: (script, ...values) => typeof script === "string" ? coordinator.executeScript(script) : getTablelessDb().$script(script, ...values),
 		execute: (statement) => coordinator.execute(statement),
-		transaction: (callback) => coordinator.transaction(callback),
+		transaction: (callback, options) => coordinator.transaction(callback, options),
 		close: () => coordinator.close(),
 		[Symbol.asyncDispose]: () => coordinator.close()
 	};

package/dist/testing.d.mts

@@ -1,2 +1,2 @@
-import { S as createTestHelpers, _ as PendingTestFixture, b as TestHooks, g as OpenedTestFixture, v as TestFixture, x as TestTransactionOptions, y as TestHelpers } from "./expression-Bc-s_0qJ.mjs";
+import { C as createTestHelpers, S as TestTransactionOptions, _ as OpenedTestFixture, b as TestHelpers, v as PendingTestFixture, x as TestHooks, y as TestFixture } from "./expression-tYmWRuKR.mjs";
 export { type OpenedTestFixture, type PendingTestFixture, type TestFixture, type TestHelpers, type TestHooks, type TestTransactionOptions, createTestHelpers };

package/dist/types.d.mts

@@ -1,5 +1,5 @@
-import { Qn as BaseType, Sn as ComparisonSignature, _n as EqualityOperators, er as Type, gn as EqualityOperator, gr as GenericOperator, hr as OperatorDefinitions, mr as NoOperators, pr as MergeOperators, t as AnyExpression, vn as HasEquality, yn as InSignature } from "./expression-Bc-s_0qJ.mjs";
-import { s as PatternSignature } from "./index-Chr-UK_t.mjs";
+import { $n as BaseType, Cn as ComparisonSignature, _n as EqualityOperator, _r as GenericOperator, bn as InSignature, gr as OperatorDefinitions, hr as NoOperators, mr as MergeOperators, t as AnyExpression, tr as Type, vn as EqualityOperators, yn as HasEquality } from "./expression-tYmWRuKR.mjs";
+import { s as PatternSignature } from "./index-pj2AhTRY.mjs";
 /**
  * Creates a one-dimensional array type of `element` values.
  *

package/package.json

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