kern-orm 0.5.0 → 0.6.0

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as InitialSqlQueryState, $n as EmptyRecord, $r as KeyKind, $t as Predicate, A as AnyDb, An as SchemaPartRelations, Ar as RequiredRelationError, At as UpdateSet, B as TransactionCoordinator, Bn as MergeSelection, Br as AnyType, Bt as desc, C as orderingOperators, Cn as UsableRelation, Cr as Selectable, Ct as ScalarQuery, D as ExpressionOperators, Dn as AnySchema, Dr as ToColumns, Dt as from, E as Expression, En as one, Er as TableOptions, Et as ValuesQuery, F as DbQueryState, Fn as RecordQuery, Fr as Driver, Ft as OrderTerm, Gn as FilteredRows, Gr as TypeOperators, Gt as EqValue, Hn as Selection, Hr as TextValue, Ht as KeyCheck, I as Database, In as RecordQueryState, Ir as DriverResult, It as OrderTerms, J as AnyQuery, Jn as QueryResult, Jr as TypeTransform, Jt as WhereFilter, Kn as OneRow, Kr as TypeOptions, Kt as WhereCallback, L as DatabaseOptions, Ln as SelectionState, Lr as SqlStatement, Lt as Ordering, M as Db, Mn as Tables, Mr as ResultMode, Mt as OrderColumns, N as DbMutationState, Nn as defineSchema, Nr as ResultRows, Nt as OrderDirection, O as TypedExpression, On as Schema, Or as defineTable, Ot as ColumnValue, P as DbOf, Pn as AnyRecordQuery, Pr as Connection, Pt as OrderKey, Q as FieldTypes, Qn as literal, Qr as ColumnAttributes, Qt as ConditionOperand, R as TransactionOptions, Rn as ExpressionInput, Rr as TransactionFailure, Rt as SelectedRefs, S as NumberTypeOperators, Sn as TableRelations, Sr as KeyColumns, St as ResultOf, T as BaseOperators, Tn as many, Tr as TableKeys, Tt as TypedScalarQuery, Un as SelectionResult, Ur as Type, Ut as NotAKey, Vn as NestedQuery, Vr as BaseType, Vt as orderBy, Wn as SelectionUses, Wr as TypeInput, Wt as PrimaryKeyValues, X as AnySqlQuery, Xn as ValueRows, Xr as AnyColumn, Xt as CombinedCondition, Y as SelectQueryKind, Yn as ResultByRows, Yr as defineType, Yt as WhereValues, Z as DecodedFields, Zn as Literal, Zr as Column, Zt as Condition, _ as TextConversionSignature, _n as RelationKind, _r as AnyTableKeys, _t as least, a as Helper, ai as GenericOperator, an as QueryContext, ar as EqualityOperator, at as MutationQueryState, b as TextTypeOperators, bn as SchemaRelations, br as ColumnShape, bt as FilteredStateRows, c as ColumnRefKey, ci as defineGenericOperator, cn as DeclaredRelations, cr as InSignature, ct as CaseValue, d as NotAColumn, dn as OneRelationKeys, dr as ComparisonSignature, dt as TypedOperand, ei as ToColumn, en as and, er as InitialQueryState, et as SqlQuery, f as matches, fn as Relation, fr as Operand, ft as TypedOperandInput, g as PatternSignature, gn as RelationKeys, gr as AnyTable, gt as greatest, h as TRUE, hn as RelationKey, hr as CompileOptions, ht as coalesce, i as sql, ii as OperatorDefinitions, in as ColumnRefs, ir as SelectQueryState, it as MutationQuery, j as BindOptions, jn as SchemaTables, jr as ResultDecodeError, jt as UpdateValues, k as UntypedExpression, kn as SchemaPart, kr as NotFoundError, kt as InsertValues, l as MatchCheck, ln as MergeRelations, lr as equalityOperators, lt as FollowingOperand, m as FALSE, mn as RelationDeclarations, mr as compare, mt as caseWhen, n as identifier, ni as MergeOperators, nn as or, nr as QueryStateOf, nt as AnyMutationQuery, o as HelperEffect, oi as GenericOperatorImplementation, on as RelationRefs, or as EqualityOperators, ot as CaseBranch, p as defineExpression, pn as RelationDeclaration, pr as OperandValue, pt as TypedOperandOperators, qn as OneValueRows, qr as TypeOutput, qt as WhereCondition, r as param, ri as NoOperators, rn as ExistsValueType, rr as QueryValueType, rt as InitialMutationState, s as defineHelper, si as OperatorSignature, sn as CountValueType, sr as HasEquality, st as CaseCondition, t as SqlTemplate, ti as BoundOperators, tn as not, tr as QueryState, tt as SqlQueryState, u as MatchResult, un as NoRelations, ur as BooleanResult, ut as NullSkippingResult, v as TextLengthSignature, vn as RequiredMember, vr as ColumnDefinitions, vt as AnySelectQuery, w as AnyExpression, wn as UsedRelation, wr as Table, wt as SelectQuery, x as textOperators, xn as TableContext, xr as ColumnValues, xt as OperandUses, y as TextOperators, yn as SchemaContext, yr as ColumnOperators, yt as BoundSelectQuery, z as createDatabase, zn as ExpressionValue, zr as createStatement, zt as asc } from "./index-Cag6_erK.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 CaseBranch, type CaseCondition, type CaseValue, type Column, type ColumnAttributes, type ColumnDefinitions, 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 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 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 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 ScalarQuery, 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, TRUE, type Table, type TableContext, 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 Type, type TypeInput, type TypeOperators, type TypeOptions, type TypeOutput, type TypeTransform, type TypedExpression, type TypedOperand, type TypedOperandInput, type TypedOperandOperators, type TypedScalarQuery, type UntypedExpression, type UpdateSet, type UpdateValues, type UsableRelation, type UsedRelation, type ValueRows, type ValuesQuery, type WhereCallback, type WhereCondition, type WhereFilter, type WhereValues, and, asc, caseWhen, coalesce, compare, createDatabase, createStatement, defineExpression, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, from, greatest, identifier, least, literal, many, matches, not, one, or, orderBy, orderingOperators, param, sql, textOperators };
+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 };

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { B as trueNode, 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, _ 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-BTFErHIi.mjs";
-import { C as not, S as isColumnValues, T as combineNodes, _ as NotFoundError, a as defineSchema, b as literal, c as requireDerived, d as orderBy, f as many, g as defineTable, h as matchColumn, i as sql, l as asc, m as createStatement, n as identifier, o as SelectQuery, p as one, r as param, s as from, t as createDatabase, u as desc, v as RequiredRelationError, w as or, x as and, y as ResultDecodeError } from "./database-BJ0hNYrF.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-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";
 // 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());
@@ -42,18 +42,91 @@ function toCaseConditionNode(condition) {
 }
 /** Creates the expression of the call of the SQL function `name`, of the type of its first operand. */
 function callFunction(name, first, rest) {
-	const expression = toTypedExpression(first, name);
+	const expression = toTypedExpression(first, `The first operand of ${name}`);
 	const type = getType(expression);
 	const operands = [toNode(expression)];
 	for (const value of rest) operands.push(toFunctionOperandNode(value, type, name));
 	return toExpression(createList(`${name}(`, operands, ")"), type);
 }
-/** Converts the first operand of the function `name` into an expression with a type, rejecting any other value. */
-function toTypedExpression(value, name) {
+/** Converts an operand, which the error names as `subject`, into an expression with a type, rejecting any other value. */
+function toTypedExpression(value, subject) {
 	const expression = value instanceof SelectQuery ? value.expr() : value;
-	if (!isExpression(expression) || getType(expression) === void 0) throw new TypeError(`The first operand of ${name} must be a query of one value of a table or an expression with a type to decode the result; build a sql fragment with a type, such as sql(t.integer)`);
+	if (!isExpression(expression) || getType(expression) === void 0) throw new TypeError(`${subject} must be a query of one value of a table or an expression with a type to decode the result; build a sql fragment with a type, such as sql(t.integer)`);
 	return expression;
 }
+// src/expression/aggregates.ts
+function count(...values) {
+	if (values.length === 0) return toExpression(countProjection.expression, countType);
+	const first = values[0];
+	if (values.length === 1 && isOptions(first)) {
+		const filter = readFilter(first, "count");
+		return toExpression(filter === void 0 ? countProjection.expression : createCountCall(filter), countType);
+	}
+	return callAggregate("count", first, values[1]);
+}
+function countDistinct(value, options) {
+	return callAggregate("countDistinct", value, options);
+}
+function min(value, options) {
+	return callAggregate("min", value, options);
+}
+function max(value, options) {
+	return callAggregate("max", value, options);
+}
+function sum(value, options) {
+	return callAggregate("sum", value, options);
+}
+function avg(value, options) {
+	return callAggregate("avg", value, options);
+}
+function every(value, options) {
+	return callAggregate("every", value, options);
+}
+function some(value, options) {
+	return callAggregate("some", value, options);
+}
+function stringAgg(value, delimiter, options) {
+	if (typeof delimiter !== "string") throw new TypeError("The delimiter of stringAgg must be a string");
+	return callAggregate("stringAgg", value, options, delimiter);
+}
+/**
+* Creates the expression of the aggregate of `method` over the values of `value`, of the type that decodes its value, with the options of `options`.
+*
+* `delimiter` is the delimiter of `stringAgg`, whose options also take `orderBy`.
+*/
+function callAggregate(method, value, options, delimiter) {
+	const expression = toTypedExpression(value, `The argument of ${method}`);
+	const filter = readFilter(options, method);
+	let orderBy = noOrder;
+	const terms = method === "stringAgg" ? options?.orderBy : void 0;
+	if (terms !== void 0) {
+		const order = [];
+		addTerms(order, terms, "The option orderBy of stringAgg takes");
+		orderBy = order;
+	}
+	return toExpression(createAggregateCall(method, toNode(expression), delimiter, orderBy, filter), toAggregateType(method, getType(expression)));
+}
+/** Tells whether `value` is an object of options rather than an argument: a plain object, of this or another realm, other than an expression. */
+function isOptions(value) {
+	if (typeof value !== "object" || value === null || isOperandSource(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || Object.getPrototypeOf(prototype) === null;
+}
+/**
+* Returns the node of the condition of `options`, the options of the aggregate function `method`, or `undefined` without options or a condition.
+*
+* It rejects options other than a plain object and a key other than the options of `method`, so that an object of column values passed instead of an argument fails rather than leaving the rows unfiltered.
+* It rejects a condition other than an expression or a query of one value, such as an object of column values, which has no table to resolve against there.
+*/
+function readFilter(options, method) {
+	if (options === void 0) return;
+	if (!isOptions(options)) throw new TypeError(`The options of ${method} must be a plain object`);
+	for (const key of Object.keys(options)) if (key !== "filter" && (key !== "orderBy" || method !== "stringAgg")) throw new TypeError(`${method} has no option ${JSON.stringify(key)}`);
+	const { filter } = options;
+	if (filter === void 0) return;
+	if (!isOperandSource(filter)) throw new TypeError(`The filter of ${method} must be an expression or a query of one Boolean value`);
+	return filter[operandNode]();
+}
 // src/query/reusable-expression.ts
 function defineExpression(_table, expression) {
 	return expression;
@@ -74,4 +147,14 @@ function matches(columns, values) {
 function defineHelper(_table, helper) {
 	return (query, ...args) => requireDerived(query, helper(query, ...args), "The callback of a helper");
 }
-export { FALSE, NotFoundError, RequiredRelationError, ResultDecodeError, TRUE, and, asc, caseWhen, coalesce, compare, createDatabase, createStatement, defineExpression, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, from, greatest, identifier, least, literal, many, matches, not, one, or, orderBy, orderingOperators, param, sql, textOperators };
+// src/table/snake-case.ts
+const wordStart = /(?<=[\p{Ll}\p{N}])(?=\p{Lu})|(?<=\p{Lu})(?=\p{Lu}(?!s$)\p{Ll})/gu;
+/**
+* Converts a column key to snake case, such as `form_id` for `formId`, for the `columnName` option of `createTableFactory`.
+*
+* A run of capital letters is one word, such as `user_id` for `userID`, and digits stay in their word, such as `line2`.
+*/
+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 };

package/dist/testing.d.mts

@@ -1,4 +1,4 @@
-import { Fr as Driver, G as TestHooks, H as PendingTestFixture, K as TestTransactionOptions, U as TestFixture, V as OpenedTestFixture, W as TestHelpers, q as createTestHelpers } from "./index-Cag6_erK.mjs";
+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";
 /** 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. */

package/dist/testing.mjs

@@ -1,6 +1,6 @@
-import { n as text, t as char } from "./text-BTFErHIi.mjs";
-import { a as defineSchema, g as defineTable, i as sql, m as createStatement, r as param, t as createDatabase, x as and } from "./database-BJ0hNYrF.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-D9LtZ9W-.mjs";
+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 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. */
@@ -142,6 +142,15 @@ function describeDriverContract(options, runner) {
 			assert.deepEqual(selected.columns, ["id", "label"]);
 			assert.deepEqual(selected.rows, []);
 		});
+		it("reports no command for a statement without a command tag", async () => {
+			for (const text of ["", "-- only a comment"]) {
+				const { command, count, columns, rows } = await database.execute(createStatement(text));
+				assert.equal(command, null);
+				assert.equal(count, 0);
+				assert.deepEqual(columns, []);
+				assert.deepEqual(rows, []);
+			}
+		});
 		it("infers the types of parameters from the statement", async () => {
 			assert.equal(await selectValue("SELECT $1::integer + $2", ["1", "2"]), "3");
 			assert.equal(await selectValue("SELECT $1", ["text"]), "text");

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

@@ -21,6 +21,12 @@ function createList(prefix, items, suffix) {
 }
 /** Filters of a query without conditions. */
 const noFilters = /* @__PURE__ */ Object.freeze({});
+/** Order without sort keys. */
+const noOrder = /* @__PURE__ */ Object.freeze([]);
+/** Joins of a query that reads only its source. */
+const noJoins = /* @__PURE__ */ Object.freeze([]);
+/** Projections of a query that selects nothing, such as the query of `EXISTS`. */
+const noProjections = /* @__PURE__ */ Object.freeze([]);
 /** Creates a query of all rows of `from` with `projections`. */
 function createSelectNode(from, projections = []) {
 	return Object.freeze({
@@ -484,4 +490,4 @@ const text = /* @__PURE__ */ getTextType();
 const varchar = /* @__PURE__ */ defineTextType("varchar").withParameters((length) => formatTypeName("varchar", length));
 /** Fixed-length string that PostgreSQL pads with spaces; `char` alone has length 1, and `char.with(length)` sets the length. */
 const char = /* @__PURE__ */ defineTextType("char", "bpchar").withParameters((length) => formatTypeName("char", length));
-export { hasEquality as A, trueNode as B, toNode as C, isType as D, defineType as E, createNode as F, createSelectNode as I, falseNode as L, valuesQueryNode as M, defineGenericOperator as N, Column as O, createList as P, noFilters as R, toFunctionOperandNode as S, getBooleanType as T, isOperandSource as _, stringifyJson as a, toCastValueNode as b, textOperators as c, orderingOperators as d, compare as f, isExpression as g, getType as h, formatTypeName as i, isEqualityCompatible as j, equalityOperators as k, defineNumberType as l, createIsNullNode as m, text as n, decodeBytea as o, compareNodes as p, varchar as r, encodeBytea as s, char as t, getIntegerType as u, operandNode as v, toValueNode as w, toExpression as x, toBooleanExpression as y, oneNode as z };
+export { hasEquality as A, noOrder as B, toNode as C, isType as D, defineType as E, createNode as F, oneNode as H, createSelectNode as I, falseNode as L, valuesQueryNode as M, defineGenericOperator as N, Column as O, createList as P, noFilters as R, toFunctionOperandNode as S, getBooleanType as T, trueNode as U, noProjections as V, isOperandSource as _, stringifyJson as a, toCastValueNode as b, textOperators as c, orderingOperators as d, compare as f, isExpression as g, getType as h, formatTypeName as i, isEqualityCompatible as j, equalityOperators as k, defineNumberType as l, createIsNullNode as m, text as n, decodeBytea as o, compareNodes as p, varchar as r, encodeBytea as s, char as t, getIntegerType as u, operandNode as v, toValueNode as w, toExpression as x, toBooleanExpression as y, noJoins as z };

package/dist/{types-D9LtZ9W-.mjs → types-DfoL8Oi9.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-BTFErHIi.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-Cti9QLK7.mjs";
 // src/type/builtins/array.ts
 /**
 * Creates a one-dimensional array type of `element` values.

package/dist/types.d.mts

@@ -1,4 +1,4 @@
-import { S as NumberTypeOperators, Ur as Type, Vr as BaseType, ai as GenericOperator, ar as EqualityOperator, b as TextTypeOperators, cr as InSignature, dr as ComparisonSignature, ii as OperatorDefinitions, ni as MergeOperators, or as EqualityOperators, ri as NoOperators, sr as HasEquality, w as AnyExpression, y as TextOperators } from "./index-Cag6_erK.mjs";
+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";
 /**
  * Creates a one-dimensional array type of `element` values.
  *

package/dist/types.mjs

@@ -1,3 +1,3 @@
-import { n as text, r as varchar, t as char } from "./text-BTFErHIi.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-D9LtZ9W-.mjs";
+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";
 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.5.0",
+  "version": "0.6.0",
   "description": "Fully typed relational query builder for PostgreSQL with ambient transactions and single-query relation loading",
   "keywords": [
     "orm",
@@ -45,6 +45,7 @@
     "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",