kern-orm 0.2.0 → 0.4.0

package/dist/testing.d.mts

@@ -1,2 +1,2 @@
-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";
+import { G as OpenedTestFixture, J as TestHelpers, K as PendingTestFixture, X as TestTransactionOptions, Y as TestHooks, Z as createTestHelpers, q as TestFixture } from "./index--0tyG7sU.mjs";
 export { type OpenedTestFixture, type PendingTestFixture, type TestFixture, type TestHelpers, type TestHooks, type TestTransactionOptions, createTestHelpers };

package/dist/{text-4Xs09pIf.mjs → text-BTFErHIi.mjs}

@@ -71,6 +71,8 @@ function isGenericOperator(operator) {
 // src/expression/operators/equality.ts
 /** Runtime mark of the operators of `equalityOperators`, which tell that a type has SQL `=`. */
 const equalityBrand = Symbol("kern-orm.equality");
+/** Key of the method of a query of a table that returns its node as the values of `in`, or rejects a query of records. */
+const valuesQueryNode = Symbol("kern-orm.valuesQueryNode");
 /**
 * Operators of SQL equality: `eq`, `ne`, and `in`; `orderingOperators` include them.
 *
@@ -80,6 +82,11 @@ const equalityOperators = {
 	eq: defineEqualityOperator((self, value) => compare(self, "=", value)),
 	ne: defineEqualityOperator((self, value) => compare(self, "<>", value)),
 	in: defineEqualityOperator((self, list) => {
+		if (!Array.isArray(list)) return toBooleanExpression(createNode({
+			kind: "inQuery",
+			operand: toNode(self),
+			query: toValuesQueryNode(list)
+		}));
 		if (list.length === 0) return toBooleanExpression(falseNode);
 		const type = getType(self);
 		const nodes = [];
@@ -91,6 +98,11 @@ const equalityOperators = {
 		}));
 	})
 };
+/** Converts a query of values of a table, such as of `pluck`, into the node of the values of `in`, and rejects any other value. */
+function toValuesQueryNode(value) {
+	if (typeof value === "object" && value !== null && valuesQueryNode in value) return value[valuesQueryNode]();
+	throw new TypeError("in takes an array or a query of values of a table, such as of pluck");
+}
 /** Tells whether a type has SQL `=`, given by an operator of `equalityOperators`. */
 function hasEquality(type) {
 	const operators = type.operators;
@@ -258,6 +270,8 @@ function getBooleanType() {
 // src/expression/expression.ts
 const expressionNode = Symbol("kern-orm.expression.node");
 const expressionType = Symbol("kern-orm.expression.type");
+/** Key of the method of an expression and of every class of queries that returns its node as an operand of an expression, or rejects a query that cannot be one. */
+const operandNode = Symbol("kern-orm.operandNode");
 /**
 * Runtime class of every expression.
 *
@@ -267,6 +281,10 @@ var ExpressionObject = class {
 	isNull() {
 		return toBooleanExpression(createIsNullNode(this[expressionNode]));
 	}
+	/** Returns the node of the expression as an operand of another expression. */
+	[operandNode]() {
+		return this[expressionNode];
+	}
 };
 let untypedPrototype;
 /** Prototypes of expressions by their types, with the operators of the type as methods. */
@@ -311,14 +329,37 @@ function getType(expression) {
 function toBooleanExpression(node) {
 	return toExpression(node, getBooleanType());
 }
-/** Converts an expression or a plain value into a node, binding the value as a parameter encoded with `type`. */
+/** Tells whether `value` is an expression or a query, which has the method of `operandNode`, whether or not that method takes it as an operand. */
+function isOperandSource(value) {
+	return typeof value === "object" && value !== null && operandNode in value;
+}
+/**
+* Converts an operand into a node: an expression or a query by the method of `operandNode`, or a plain value, bound as a parameter encoded with `type`.
+*
+* The method of a query takes a query of one value of a table, which lowering replaces with a scalar subquery, or with `EXISTS` for a query of `exists`, and rejects another query, such as of records or of `$query`.
+*/
 function toValueNode(value, type) {
-	return value instanceof ExpressionObject ? value[expressionNode] : createNode({
+	if (typeof value === "object" && value !== null && operandNode in value) return value[operandNode]();
+	return createNode({
 		kind: "param",
 		value,
 		type
 	});
 }
+/** Converts an operand into a node as `toValueNode` does, casting a plain value to `type`, so that its parameter has the type even where nothing else in the statement determines it. */
+function toCastValueNode(value, type) {
+	const node = toValueNode(value, type);
+	return node.kind === "param" ? createNode({
+		kind: "cast",
+		operand: node,
+		type
+	}) : node;
+}
+/** Converts an operand of the function `name` that skips `NULL`, such as the fallback of `coalesce`, into a node as `toValueNode` does, rejecting a plain `null` and `undefined`, which would have no effect or no value. */
+function toFunctionOperandNode(value, type, name) {
+	if (value === null || value === void 0) throw new TypeError(`${name} takes a value other than ${String(value)}`);
+	return toValueNode(value, type);
+}
 /** Creates an `IS NULL` node directly, so that resolving an object condition never calls an `isNull` operator replaced by a type. */
 function createIsNullNode(operand) {
 	return createNode({
@@ -330,7 +371,7 @@ function createIsNullNode(operand) {
 function compare(self, operator, value) {
 	return toBooleanExpression(compareNodes(operator, toNode(self), value, getType(self)));
 }
-/** Creates a comparison node, encoding a plain `right` value with `type`. */
+/** Creates a comparison node, encoding a plain `right` value with `type`; a query of one value becomes its node in an expression, as `toValueNode` describes. */
 function compareNodes(operator, left, right, type) {
 	return createNode({
 		kind: "comparison",
@@ -351,19 +392,58 @@ const orderingOperators = {
 function createComparison(operator) {
 	return defineGenericOperator((self, value) => compare(self, operator, value));
 }
+// src/type/number.ts
+/** Defines a type of numbers with the operators of the built-in ones. */
+function defineNumberType(sqlType) {
+	return defineType({ sqlType }).transform({
+		decode: Number,
+		encode: (value) => String(value)
+	}).withOperators(orderingOperators);
+}
+let integerType;
+/** Returns the shared `integer` type used by built-in expressions and columns. */
+function getIntegerType() {
+	integerType ??= defineNumberType("integer");
+	return integerType;
+}
+// src/type/text.ts
+/** Defines a text type with the operators of the built-in text types. */
+function defineTextType(sqlType, castType) {
+	return defineType({
+		sqlType,
+		castType
+	}).withOperators(orderingOperators).withOperators(textOperators);
+}
+let textType;
+/** Returns the shared `text` type used by built-in expressions and columns. */
+function getTextType() {
+	textType ??= defineTextType("text");
+	return textType;
+}
 // src/expression/operators/text.ts
 /**
-* Operators of text types: pattern matching with `LIKE` and `ILIKE`.
+* Operators of text types: pattern matching with `LIKE` and `ILIKE`, `lower` and `upper`, which convert the case of the text, `trim`, which removes spaces from both of its ends, and `length`, which counts its characters.
 *
 * A string pattern is sent as it is; `param(type, pattern)` encodes it with a type.
 */
 const textOperators = {
 	like: /* @__PURE__ */ createPatternComparison("LIKE"),
-	ilike: /* @__PURE__ */ createPatternComparison("ILIKE")
+	ilike: /* @__PURE__ */ createPatternComparison("ILIKE"),
+	lower: /* @__PURE__ */ createTextConversion("lower"),
+	upper: /* @__PURE__ */ createTextConversion("upper"),
+	trim: /* @__PURE__ */ createTextConversion("btrim"),
+	length: /* @__PURE__ */ defineGenericOperator((self) => callTextFunction("length", self, getIntegerType()))
 };
 function createPatternComparison(operator) {
 	return defineGenericOperator((self, pattern) => toBooleanExpression(compareNodes(operator, toNode(self), pattern, void 0)));
 }
+function createTextConversion(name) {
+	return defineGenericOperator((self) => callTextFunction(name, self, getTextType()));
+}
+/** Calls a SQL function of text whose result has `type`, whatever the type of the expression: a decoder of a transformed type expects values that it encoded rather than results of the function. */
+function callTextFunction(name, self, type) {
+	return toExpression(createList(`${name}(`, [toNode(self)], ")"), type);
+}
 // src/type/codecs/bytea.ts
 const hexDigits = "0123456789abcdef";
 /** Encodes bytes as a hex `bytea` literal, such as `\\x00ff`. */
@@ -398,16 +478,10 @@ function formatTypeName(name, ...parameters) {
 	return defined.length === 0 ? name : `${name}(${defined.join(",")})`;
 }
 // src/type/builtins/text.ts
-function defineTextType(sqlType, castType) {
-	return defineType({
-		sqlType,
-		castType
-	}).withOperators(orderingOperators).withOperators(textOperators);
-}
 /** Variable-length string without a limit. */
-const text = /* @__PURE__ */ defineTextType("text");
+const text = /* @__PURE__ */ getTextType();
 /** Variable-length string; `varchar.with(length)` limits its length. */
 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 { falseNode as A, equalityOperators as C, createList as D, defineGenericOperator as E, oneNode as M, trueNode as N, createNode as O, Column as S, isEqualityCompatible as T, toNode as _, stringifyJson as a, defineType as b, textOperators as c, compareNodes as d, createIsNullNode as f, toExpression as g, toBooleanExpression as h, formatTypeName as i, noFilters as j, createSelectNode as k, orderingOperators as l, isExpression as m, text as n, decodeBytea as o, getType as p, varchar as r, encodeBytea as s, char as t, compare as u, toValueNode as v, hasEquality as w, isType as x, getBooleanType as y };
+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 };

package/dist/types.d.mts

@@ -1,5 +1,4 @@
-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";
+import { Bt as EqualityOperator, C as TextOperators, E as NumberTypeOperators, Fr as Type, Ht as HasEquality, Jr as MergeOperators, Nr as BaseType, O as AnyExpression, Ut as InSignature, Vt as EqualityOperators, Xr as OperatorDefinitions, Yr as NoOperators, Zr as GenericOperator, rr as ComparisonSignature, w as TextTypeOperators } from "./index--0tyG7sU.mjs";
 /**
  * Creates a one-dimensional array type of `element` values.
  *
@@ -14,63 +13,63 @@ export declare const bytea: BaseType<Uint8Array<ArrayBufferLike>, Uint8Array<Arr
 export declare const boolean: BaseType<boolean, boolean, EqualityOperators, undefined>;
 /** Point in time as a UTC ISO 8601 string with microseconds, such as `2026-01-15T07:00:00.123456Z`; accepts a `Date` too. */
 export declare const timestamptz: Type<string, string | Date, MergeOperators<NoOperators, {
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, [precision: number]>;
-/** Date and time without a time zone as an ISO 8601 string with microseconds, such as `2026-01-15T10:00:00.000000`. */
-export declare const timestamp: Type<string, string, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, [precision: number]>;
+/** Date and time without a time zone as an ISO 8601 string with microseconds, such as `2026-01-15T10:00:00.000000`. */
+export declare const timestamp: Type<string, string, MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, [precision: number]>;
-/** Calendar date as an ISO 8601 string, such as `2026-01-15`. */
-export declare const date: BaseType<string, string, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, [precision: number]>;
+/** Calendar date as an ISO 8601 string, such as `2026-01-15`. */
+export declare const date: BaseType<string, string, MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, undefined>;
-/** Time of day as a string with microseconds, such as `10:00:00.000000`. */
-export declare const time: Type<string, string, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, undefined>;
+/** Time of day as a string with microseconds, such as `10:00:00.000000`. */
+export declare const time: Type<string, string, MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, [precision: number]>;
-/** Interval in the PostgreSQL output format, such as `1 day 02:00:00`. */
-export declare const interval: BaseType<string, string, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, [precision: number]>;
+/** Interval in the PostgreSQL output format, such as `1 day 02:00:00`. */
+export declare const interval: BaseType<string, string, MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, undefined>;
-/** Creates a type of an existing PostgreSQL enum; values are ordered as declared in the enum. */
-declare function enumOf<const Values extends readonly string[]>(name: string, _values: Values): BaseType<Values[number], Values[number], MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, undefined>;
+/** Creates a type of an existing PostgreSQL enum; values are ordered as declared in the enum. */
+declare function enumOf<const Values extends readonly string[]>(name: string, _values: Values): BaseType<Values[number], Values[number], MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
 }>, 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> & {
@@ -83,131 +82,106 @@ export declare const json: JsonType<NoOperators>;
 export declare const jsonb: JsonType<MergeOperators<NoOperators, EqualityOperators>>;
 /** 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>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, undefined>;
-/** IP network as a string, such as `10.0.0.0/8`. */
-export declare const cidr: BaseType<string, string, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, undefined>;
+/** IP network as a string, such as `10.0.0.0/8`. */
+export declare const cidr: BaseType<string, string, MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, undefined>;
-/** 2-byte integer as a `number`. */
-export declare const smallint: BaseType<number, number, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, undefined>;
+/** 2-byte integer as a `number`. */
+export declare const smallint: BaseType<number, number, MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, undefined>;
-/** 4-byte integer as a `number`. */
-export declare const integer: BaseType<number, number, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
-  lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
 }>, undefined>;
+/** 4-byte integer as a `number`. */
+export declare const integer: BaseType<number, number, NumberTypeOperators, undefined>;
 /** 8-byte integer as a `bigint`, which keeps values beyond `Number.MAX_SAFE_INTEGER`; accepts a `number` too. */
 export declare const bigint: BaseType<bigint, number | bigint, MergeOperators<NoOperators, {
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, undefined>;
-/** 4-byte floating-point number as a `number`. */
-export declare const real: BaseType<number, number, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, undefined>;
+/** 4-byte floating-point number as a `number`. */
+export declare const real: BaseType<number, number, MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, undefined>;
-/** 8-byte floating-point number as a `number`. */
-export declare const doublePrecision: BaseType<number, number, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, undefined>;
+/** 8-byte floating-point number as a `number`. */
+export declare const doublePrecision: BaseType<number, number, MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, undefined>;
-/** Exact number as a decimal string, so that no precision is lost; `numeric.with(precision, scale)` constrains it. */
-export declare const numeric: Type<string, string | number | bigint, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, undefined>;
+/** Exact number as a decimal string, so that no precision is lost; `numeric.with(precision, scale)` constrains it. */
+export declare const numeric: Type<string, string | number | bigint, MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, [precision: number, scale?: number | undefined]>;
-/** Variable-length string without a limit. */
-export declare const text: BaseType<string, string, MergeOperators<MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, [precision: number, scale?: number | undefined]>;
+/** Variable-length string without a limit. */
+export declare const text: BaseType<string, string, TextTypeOperators, undefined>;
+/** Variable-length string; `varchar.with(length)` limits its length. */
+export declare const varchar: Type<string, string, MergeOperators<MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, {
-  like: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-  ilike: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-}>, undefined>;
-/** Variable-length string; `varchar.with(length)` limits its length. */
-export declare const varchar: Type<string, string, MergeOperators<MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, TextOperators>, [length: number]>;
+/** Fixed-length string that PostgreSQL pads with spaces; `char` alone has length 1, and `char.with(length)` sets the length. */
+export declare const char: Type<string, string, MergeOperators<MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, {
-  like: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-  ilike: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-}>, [length: number]>;
-/** Fixed-length string that PostgreSQL pads with spaces; `char` alone has length 1, and `char.with(length)` sets the length. */
-export declare const char: Type<string, string, MergeOperators<MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
+}>, TextOperators>, [length: number]>;
+/** UUID as a string. */
+export declare const uuid: BaseType<string, string, MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, {
-  like: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-  ilike: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-}>, [length: number]>;
-/** UUID as a string. */
-export declare const uuid: BaseType<string, string, MergeOperators<NoOperators, {
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
-  lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
 }>, undefined>;
 export { enumOf as enum };

package/dist/types.mjs

@@ -1,4 +1,4 @@
-import { C as equalityOperators, a as stringifyJson, b as defineType, i as formatTypeName, l as orderingOperators, n as text, o as decodeBytea, r as varchar, s as encodeBytea, t as char, w as hasEquality, y as getBooleanType } from "./text-4Xs09pIf.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, n as text, o as decodeBytea, r as varchar, s as encodeBytea, t as char, u as getIntegerType } from "./text-BTFErHIi.mjs";
 // src/type/builtins/array.ts
 /**
 * Creates a one-dimensional array type of `element` values.
@@ -224,16 +224,10 @@ const inet = /* @__PURE__ */ defineType({ sqlType: "inet" }).withOperators(order
 /** IP network as a string, such as `10.0.0.0/8`. */
 const cidr = /* @__PURE__ */ defineType({ sqlType: "cidr" }).withOperators(orderingOperators);
 // src/type/builtins/numeric.ts
-function defineNumberType(sqlType) {
-	return defineType({ sqlType }).transform({
-		decode: Number,
-		encode: (value) => String(value)
-	}).withOperators(orderingOperators);
-}
 /** 2-byte integer as a `number`. */
 const smallint = /* @__PURE__ */ defineNumberType("smallint");
 /** 4-byte integer as a `number`. */
-const integer = /* @__PURE__ */ defineNumberType("integer");
+const integer = /* @__PURE__ */ getIntegerType();
 /** 8-byte integer as a `bigint`, which keeps values beyond `Number.MAX_SAFE_INTEGER`; accepts a `number` too. */
 const bigint = /* @__PURE__ */ defineType({ sqlType: "bigint" }).transform({
 	decode: BigInt,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kern-orm",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Fully typed relational query builder for PostgreSQL with ambient transactions and single-query relation loading",
   "keywords": [
     "orm",
@@ -42,7 +42,11 @@
   },
   "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",
     "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": {

package/dist/index-pj2AhTRY.d.mts

@@ -1,134 +0,0 @@
-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>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
-  lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-};
-/** Signature of pattern matching: patterns stay strings even when the text values are transformed. */
-interface PatternSignature extends OperatorSignature {
-  readonly method: <V extends Operand<string>>(pattern: V) => Expression<BooleanResult<this["T"] | OperandValue<V>>>;
-}
-/**
- * Operators of text types: pattern matching with `LIKE` and `ILIKE`.
- *
- * A string pattern is sent as it is; `param(type, pattern)` encodes it with a type.
- */
-declare const textOperators: {
-  like: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-  ilike: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-};
-/**
- * State of the query that the callback of a helper of table `T` with schema context `C` receives: the fields of the query the helper is applied to, and all its rows.
- *
- * It is guaranteed, so that the state that the callback returns tells whether the callback ends the guarantee of the query the helper is applied to.
- */
-interface HelperState<T extends AnyTable, C extends SchemaContext> extends QueryStateOf<T, C> {
-  readonly result: HelperFields<never>;
-  readonly input: never;
-  readonly rows: "many";
-  readonly value: false;
-  readonly uses: never;
-  readonly guaranteed: true;
-  readonly aggregate: false;
-}
-/**
- * Effect of a helper: the fields it selects, its rows mode on a query of many rows, `one` after `take` or `required` and `nullable` or `optional` after the method of the same name, the relations it selects records of, and whether it keeps the guarantee of the row of a query of a required relation.
- *
- * `reads` are the relations of the schema of the helper among them, which its callback may read from the references of the query it is applied to, and `key` is the key of its table there.
- */
-interface HelperEffect {
-  readonly fields: object;
-  readonly rows: ResultRows;
-  readonly uses: UsedRelation;
-  readonly reads: UsedRelation;
-  readonly key: string;
-  readonly guaranteed: boolean;
-}
-/** Effect of a helper whose callback returns a query of state `S`, for each state of a union. */
-type ReadEffect<S extends SelectQueryState> = S extends SelectQueryState ? {
-  readonly fields: { [K in keyof S["result"] as K extends keyof HelperFields ? never : K]: S["result"][K]; };
-  readonly rows: S["rows"];
-  readonly uses: S["uses"];
-  readonly reads: Extract<UsableRelation<S["schema"]["relations"]>, S["uses"]>;
-  readonly key: S["schema"]["key"];
-  readonly guaranteed: S["guaranteed"];
-} : never;
-/** Error of a helper that a query does not accept, or whose callback returns a query it does not accept. */
-interface HelperError<Message extends string> {
-  readonly error: Message;
-}
-/** `unknown` when every result state retains the input marker and returns records, or the error. */
-type CheckResult<S extends SelectQueryState> = [S] extends [{
-  readonly result: HelperFields;
-  readonly value: false;
-}] ? unknown : HelperError<"A helper can filter, select fields, and take one row, but cannot clear the selection or use get, pluck, or aggregates">;
-/** State of a query over table `T` that accepts a helper of effect `E`. */
-type HelperInput<T extends AnyTable, E extends HelperEffect> = QueryStateOf<T, ReadsContext<E>> & ValueCheck<E>;
-/** Constraint of `value` of a query that accepts a helper of effect `E`. */
-type ValueCheck<E extends HelperEffect> = [E extends HelperEffect ? keyof E["fields"] : never] extends [never] ? [Extract<E["rows"], "nullable">] extends [never] ? unknown : RecordRows<"A helper cannot apply nullable to a query made by get, pluck, or an aggregate"> : RecordRows<"A helper cannot select fields on a query made by get, pluck, or an aggregate">;
-/** Constraint of a query whose rows are records, which a query of values fails with error `Message`. */
-interface RecordRows<Message extends string> {
-  readonly value: false | HelperError<Message>;
-}
-/** Schema context of a query that has the relations of its schema that a helper of effect `E` may read. */
-type ReadsContext<E extends HelperEffect> = [E["reads"]] extends [never] ? SchemaContext : SchemaContext<{ readonly [K in E["reads"]["key"]]: { readonly [N in Extract<E["reads"], {
-  readonly key: K;
-}>["name"]]: Extract<E["reads"], {
-  readonly key: K;
-  readonly name: N;
-}>["relation"]; }; }, E["key"]>;
-/** State of a query of state `S` after a helper of effect `E`. */
-type ApplyEffect<S extends SelectQueryState, E extends HelperEffect> = ChangeState<S, {
-  result: [keyof E["fields"]] extends [never] ? S["result"] : MergeSelection<S["result"], E["fields"]>;
-  rows: E["rows"] extends "many" ? EffectRows<S, E> : E["rows"] extends "one" ? OneRow<EffectRows<S, E>> : E["rows"];
-  uses: S["uses"] | E["uses"];
-  guaranteed: E["guaranteed"] extends true ? S["guaranteed"] : false;
-}>;
-/** Rows mode of a query of state `S` after a helper of effect `E` that keeps the rows, before `take`: relaxed as after a filter when the helper ends the guarantee. */
-type EffectRows<S extends SelectQueryState, E extends HelperEffect> = E["guaranteed"] extends true ? S["rows"] : FilteredStateRows<S>;
-/**
- * Helper of `defineHelper` for queries over table `T`: it applies effect `E` to the query it receives with arguments `A` and returns a query of the same kind.
- *
- * Selected fields replace earlier fields under the same keys; a query made by `get`, `pluck`, or an aggregate method does not accept a helper that selects fields.
- */
-type Helper<T extends AnyTable, E extends HelperEffect, A extends unknown[]> = <S extends HelperInput<T, E>, Kind extends SelectQueryKind>(query: SelectQuery<S, Kind>, ...args: A) => E extends HelperEffect ? SelectQuery<ApplyEffect<S, E>, Kind> : never;
-/**
- * Defines a reusable helper of a table that filters, selects fields, and applies `take`, `optional`, `nullable`, and `required`, used with `use` or called with a query.
- *
- * `helper` receives the query it is applied to and any further arguments, and returns the query with its clauses.
- * Defined with a query of a schema, such as `schema.form`, it can select the relations of the table in that schema, and applies to queries whose schema has them.
- * The helper returns a query of the same kind as the one it is applied to, bound to the same `Db` if any.
- */
-declare function defineHelper<T extends AnyTable, R extends SelectQuery<any, SelectQueryKind>, A extends unknown[], C extends SchemaContext = NoRelations>(table: TableOrQuery<T, C>, helper: (query: SelectQuery<HelperState<T, C>, SelectQueryKind>, ...args: A) => R & CheckResult<R["types"]>): Helper<T, ReadEffect<R["types"]>, A>;
-/** Tagged template building a SQL fragment of values `T` that accepts compared values `I`. */
-type SqlTemplate<T, O extends OperatorDefinitions, I = T> = (strings: TemplateStringsArray, ...values: unknown[]) => Expression<T, O, I>;
-/**
- * Builds a SQL fragment.
- *
- * Interpolated expressions such as column references stay structured, a query of a table without clauses, such as `db.form`, becomes the name of the table, and other values become query parameters.
- * The type argument declares the TypeScript type of the fragment and does not convert values at runtime, so the fragment cannot be selected; the fragment has `isNull` and the operators of `equalityOperators` only.
- */
-declare function sql<T = unknown>(strings: TemplateStringsArray, ...values: unknown[]): UntypedExpression<T>;
-/**
- * Creates a template building SQL fragments of `type`.
- *
- * The fragments have the operators of the type and encode compared values with it; the type adds no SQL cast.
- */
-declare function sql<Output, Input, O extends OperatorDefinitions>(type: Type<Output, Input, O, any>): SqlTemplate<Output, O, Input>;
-/**
- * Creates an expression of a query parameter encoded with a type, for a value interpolated into `sql` or compared on its own.
- *
- * With a type, the parameter is cast to it, such as `$1::integer`, so that PostgreSQL applies the operators of the type even where nothing else in the statement determines it.
- * The cast omits type parameters, such as `$1::numeric` for `numeric(10,2)`, so that their precision, scale, or length do not constrain the value.
- *
- * With an expression, such as `param(self, other)` in an operator definition, the type of the expression encodes the value, and the parameter is not cast: PostgreSQL types it by the expression it is used with.
- * `value` may then also be an expression, such as an operand of a generic operator, which is returned as it is, with its own type and nullability.
- */
-declare function param<Output, Input, O extends OperatorDefinitions>(type: Type<Output, Input, O, any>, value: Input): Expression<Output, O, Input>;
-declare function param<E extends AnyExpression, V extends (E extends AnyExpression<infer T, infer I> ? Operand<T, I> : never)>(type: E, value: V): V extends AnyExpression ? V : E;
-export { HelperEffect as a, textOperators as c, Helper as i, orderingOperators as l, param as n, defineHelper as o, sql as r, PatternSignature as s, SqlTemplate as t };