kern-orm 0.3.0 → 0.4.0

package/dist/testing.d.mts

@@ -1,2 +1,2 @@
-import { A as TestFixture, M as TestHooks, N as TestTransactionOptions, O as OpenedTestFixture, P as createTestHelpers, j as TestHelpers, k as PendingTestFixture } from "./index-CNqYlONX.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-BUNl8wpl.mjs → text-BTFErHIi.mjs}

@@ -346,6 +346,20 @@ function toValueNode(value, type) {
 		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({
@@ -378,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`. */
@@ -425,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 { createList as A, isType as C, isEqualityCompatible as D, hasEquality as E, oneNode as F, trueNode as I, createSelectNode as M, falseNode as N, valuesQueryNode as O, noFilters as P, defineType as S, equalityOperators as T, toBooleanExpression as _, stringifyJson as a, toValueNode as b, textOperators as c, compareNodes as d, createIsNullNode as f, operandNode as g, isOperandSource as h, formatTypeName as i, createNode as j, defineGenericOperator 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, toExpression as v, Column as w, getBooleanType as x, toNode 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,4 +1,4 @@
-import { Ar as OperatorDefinitions, Ct as EqualityOperator, Et as InSignature, Ln as ComparisonSignature, Or as MergeOperators, Tt as HasEquality, c as PatternSignature, d as AnyExpression, hr as Type, jr as GenericOperator, kr as NoOperators, pr as BaseType, wt as EqualityOperators } from "./index-CNqYlONX.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.
  *
@@ -111,15 +111,7 @@ export declare const smallint: BaseType<number, number, MergeOperators<NoOperato
   in: EqualityOperator<InSignature>;
 }>, undefined>;
 /** 4-byte integer as a `number`. */
-export declare const integer: 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>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
-}>, undefined>;
+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, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
@@ -161,18 +153,7 @@ export declare const numeric: Type<string, string | number | bigint, MergeOperat
   in: EqualityOperator<InSignature>;
 }>, [precision: number, scale?: number | undefined]>;
 /** Variable-length string without a limit. */
-export declare const text: BaseType<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>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
-}>, {
-  like: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-  ilike: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-}>, undefined>;
+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>>;
@@ -182,10 +163,7 @@ export declare const varchar: Type<string, string, MergeOperators<MergeOperators
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
-}>, {
-  like: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-  ilike: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-}>, [length: number]>;
+}>, 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>>;
@@ -195,10 +173,7 @@ export declare const char: Type<string, string, MergeOperators<MergeOperators<No
   eq: EqualityOperator<ComparisonSignature>;
   ne: EqualityOperator<ComparisonSignature>;
   in: EqualityOperator<InSignature>;
-}>, {
-  like: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-  ilike: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-}>, [length: number]>;
+}>, TextOperators>, [length: number]>;
 /** UUID as a string. */
 export declare const uuid: BaseType<string, string, MergeOperators<NoOperators, {
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;

package/dist/types.mjs

@@ -1,4 +1,4 @@
-import { E as hasEquality, S as defineType, T as equalityOperators, a as stringifyJson, i as formatTypeName, l as orderingOperators, n as text, o as decodeBytea, r as varchar, s as encodeBytea, t as char, x as getBooleanType } from "./text-BUNl8wpl.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.3.0",
+  "version": "0.4.0",
   "description": "Fully typed relational query builder for PostgreSQL with ambient transactions and single-query relation loading",
   "keywords": [
     "orm",
@@ -42,8 +42,11 @@
   },
   "devDependencies": {
     "@kern-orm/postgres-js": "workspace:*",
-    "kern-orm-minimum": "https://registry.npmjs.org/kern-orm/-/kern-orm-0.2.0.tgz",
+    "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": {