kern-orm 0.8.0 → 0.10.0

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

@@ -1,3 +1,6 @@
+import { SqlQuery } from "kern-db/builder";
+import * as dbTypes from "kern-db/types";
+import { defineType, isType } from "kern-db";
 // src/ast/nodes.ts
 /** Freezes an expression node; nodes are shared between queries and never change. */
 function createNode(node) {
@@ -189,57 +192,46 @@ function markKey(column, keyKind) {
 	});
 }
 // src/type/type.ts
-/** Runtime mark of types, which tells them apart from columns and other objects. */
+/** Runtime mark of types, which tells them apart from columns, types of kern-db without operators, and other objects. */
 const typeBrand = Symbol("kern-orm.type");
+function defineType$1(definition) {
+	return createType(isType(definition) ? definition : defineType(definition), Object.freeze({}));
+}
+/** Tells whether `value` is a type, as opposed to a column, a type of kern-db without operators, or another object. */
+function isType$1(value) {
+	return typeof value === "object" && value !== null && typeBrand in value;
+}
 /**
-* Defines a type whose values are the PostgreSQL text representations as they are.
+* Describes `value`, which a function that takes a type rejected as not a type, for its error: a type of kern-db, which has no operators, with the hints of `kern-orm/types` and `defineType`.
 *
-* `transform` converts them to other values, such as `number[]` for `vector`.
+* It returns `undefined` for a value that is not a type of kern-db; a type of kern-orm is one too, so the caller rejects only values other than types.
 */
-function defineType(options) {
-	if (options.castType === void 0 && options.sqlType.includes("(")) throw new TypeError(`Define the type parameters of "${options.sqlType}" using withParameters(), or set castType`);
-	return createType({
-		sqlType: options.sqlType,
-		castType: options.castType ?? options.sqlType,
-		encode: (value) => value,
-		decode: (text) => text,
-		operators: Object.freeze({}),
-		isNullable: false,
-		formatSqlType: void 0
-	});
-}
-/** Tells whether `value` is a type, as opposed to a column or another object. */
-function isType(value) {
-	return typeof value === "object" && value !== null && typeBrand in value;
+function describeRejectedDbType(value) {
+	return isType(value) ? "a type of kern-db, which has no operators; take a built-in type from kern-orm/types, or create a type from it with defineType() of kern-orm" : void 0;
 }
-function createType(state) {
-	const derive = (changes) => createType({
-		...state,
-		...changes
-	});
-	const { formatSqlType } = state;
+/** Creates the type of the values of `dbType` whose expressions have `operators`. */
+function createType(dbType, operators) {
+	const derive = (derived) => createType(derived, operators);
 	const type = Object.freeze({
-		...state,
+		...dbType,
 		[typeBrand]: true,
+		operators,
 		withOperators(extra) {
-			const operators = { ...state.operators };
+			const merged = { ...operators };
 			for (const name of Object.keys(extra)) {
 				if (name === "then") throw new TypeError("Operator \"then\" is not allowed: it would make expressions thenable");
 				const operator = extra[name];
-				Object.defineProperty(operators, name, {
+				Object.defineProperty(merged, name, {
 					value: isGenericOperator(operator) ? operator : (self, ...args) => operator(getType(self) === type ? self : toExpression(toNode(self), type), ...args),
 					enumerable: true
 				});
 			}
-			return derive({ operators: Object.freeze(operators) });
+			return createType(dbType, Object.freeze(merged));
 		},
-		transform: ({ decode, encode }) => derive({
-			encode: encode ? (value) => state.encode(encode(value)) : state.encode,
-			decode: (text) => decode(state.decode(text))
-		}),
-		withParameters: (format) => derive({ formatSqlType: format }),
-		...formatSqlType && { with: (...parameters) => derive({ sqlType: formatSqlType(...parameters) }) },
-		nullable: () => derive({ isNullable: true }),
+		transform: (options) => derive(dbType.transform(options)),
+		withParameters: (format) => derive(dbType.withParameters(format)),
+		..."with" in dbType && { with: (...parameters) => derive(dbType.with(...parameters)) },
+		nullable: () => derive(dbType.nullable()),
 		of: () => type,
 		columnName: (name) => new Column(type, {
 			name,
@@ -268,10 +260,7 @@ function createType(state) {
 let booleanType;
 /** Returns the shared Boolean type used by built-in expressions and columns. */
 function getBooleanType() {
-	booleanType ??= defineType({ sqlType: "boolean" }).transform({
-		decode: (text) => text === "t",
-		encode: (value) => value ? "t" : "f"
-	}).withOperators(equalityOperators);
+	booleanType ??= defineType$1(dbTypes.boolean).withOperators(equalityOperators);
 	return booleanType;
 }
 // src/expression/expression.ts
@@ -332,7 +321,7 @@ function isExpression(value) {
 function getType(expression) {
 	return expression[expressionType];
 }
-/** Exposes a Boolean node with the shared codec and operators. */
+/** Exposes a Boolean node with the shared Boolean type and its operators. */
 function toBooleanExpression(node) {
 	return toExpression(node, getBooleanType());
 }
@@ -343,16 +332,23 @@ function isOperandSource(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`.
+* 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; it rejects a query of SQL text too.
 */
 function toValueNode(value, type) {
-	if (typeof value === "object" && value !== null && operandNode in value) return value[operandNode]();
+	if (typeof value === "object" && value !== null) {
+		if (operandNode in value) return value[operandNode]();
+		if (value instanceof SqlQuery) rejectSqlQueryOperand();
+	}
 	return createNode({
 		kind: "param",
 		value,
 		type
 	});
 }
+/** Rejects a query of SQL text as an operand of an expression. */
+function rejectSqlQueryOperand() {
+	throw new TypeError("An expression takes a query of one value of a table, such as of get, an aggregate, or exists, not a query of SQL text");
+}
 /** 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);
@@ -400,31 +396,25 @@ 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);
+/** Defines a type from a type of kern-db of numbers with the built-in ordering operators. */
+function defineNumberType(dbType) {
+	return defineType$1(dbType).withOperators(orderingOperators);
 }
 let integerType;
 /** Returns the shared `integer` type used by built-in expressions and columns. */
 function getIntegerType() {
-	integerType ??= defineNumberType("integer");
+	integerType ??= defineNumberType(dbTypes.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);
+/** Defines a type from a type of kern-db of strings with the built-in text operators. */
+function defineTextType(dbType) {
+	return defineType$1(dbType).withOperators(orderingOperators).withOperators(textOperators);
 }
 let textType;
 /** Returns the shared `text` type used by built-in expressions and columns. */
 function getTextType() {
-	textType ??= defineTextType("text");
+	textType ??= defineTextType(dbTypes.text);
 	return textType;
 }
 // src/expression/operators/text.ts
@@ -451,44 +441,11 @@ function createTextConversion(name) {
 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`. */
-function encodeBytea(bytes) {
-	let text = "\\x";
-	for (const byte of bytes) text += hexDigits[byte >> 4] + hexDigits[byte & 15];
-	return text;
-}
-/** Decodes a hex `bytea` literal into bytes. */
-function decodeBytea(text) {
-	if (!text.startsWith("\\x")) throw new Error("Unsupported bytea value; kern-orm expects bytea_output hex");
-	const bytes = new Uint8Array((text.length - 2) / 2);
-	for (let index = 0; index < bytes.length; index++) bytes[index] = readHexDigit(text, 2 + index * 2) << 4 | readHexDigit(text, 3 + index * 2);
-	return bytes;
-}
-/** Reads the hex digit at `index`, in either case. */
-function readHexDigit(text, index) {
-	const code = text.charCodeAt(index);
-	return code <= 57 ? code - 48 : (code | 32) - 87;
-}
-// src/type/codecs/json.ts
-/** Serializes a value as JSON text; values without a JSON representation, such as functions, are rejected. */
-function stringifyJson(value) {
-	const text = JSON.stringify(value);
-	if (text === void 0) throw new TypeError(`Cannot encode ${typeof value} as JSON`);
-	return text;
-}
-// src/type/type-name.ts
-/** Appends type parameters, such as the precision and scale in `numeric(10,2)`, to a type name. */
-function formatTypeName(name, ...parameters) {
-	const defined = parameters.filter((parameter) => parameter !== void 0);
-	return defined.length === 0 ? name : `${name}(${defined.join(",")})`;
-}
 // src/type/builtins/text.ts
 /** Variable-length string without a limit. */
 const text = /* @__PURE__ */ getTextType();
 /** Variable-length string; `varchar.with(length)` limits its length. */
-const varchar = /* @__PURE__ */ defineTextType("varchar").withParameters((length) => formatTypeName("varchar", length));
+const varchar = /* @__PURE__ */ defineTextType(dbTypes.varchar);
 /** 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, 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 };
+const char = /* @__PURE__ */ defineTextType(dbTypes.char);
+export { valuesQueryNode as A, oneNode as B, defineType$1 as C, equalityOperators as D, Column as E, falseNode as F, noFilters as I, noJoins as L, createList as M, createNode as N, hasEquality as O, createSelectNode as P, noOrder as R, getBooleanType as S, isType$1 as T, trueNode as V, toCastValueNode as _, defineNumberType as a, toNode as b, compare as c, getType as d, isExpression as f, toBooleanExpression as g, rejectSqlQueryOperand as h, textOperators as i, defineGenericOperator as j, isEqualityCompatible as k, compareNodes as l, operandNode as m, text as n, getIntegerType as o, isOperandSource as p, varchar as r, orderingOperators as s, char as t, createIsNullNode as u, toExpression as v, describeRejectedDbType as w, toValueNode as x, toFunctionOperandNode as y, noProjections as z };

package/dist/types.d.mts

@@ -1,4 +1,4 @@
-import { E as AnyExpression, Gi as Type, Jr as HasEquality, Kr as EqualityOperator, Qr as ComparisonSignature, S as TextTypeOperators, Ui as BaseType, Yr as InSignature, aa as NoOperators, ia as MergeOperators, oa as OperatorDefinitions, qr as EqualityOperators, sa as GenericOperator, w as NumberTypeOperators, x as TextOperators } from "./index-B1aH5Ht0.mjs";
+import { Qi as Type, Zi as BaseType, da as OperatorDefinitions, di as EqualityOperators, dt as AnyExpression, fa as GenericOperator, fi as HasEquality, gi as ComparisonSignature, ia as Column, la as MergeOperators, lt as NumberTypeOperators, ot as TextOperators, pi as InSignature, st as TextTypeOperators, ua as NoOperators, ui as EqualityOperator } from "./index-aiyU5HR5.mjs";
 /**
  * Creates a one-dimensional array type of `element` values.
  *
@@ -62,7 +62,7 @@ export declare const interval: BaseType<string, string, MergeOperators<NoOperato
   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, {
+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>;
@@ -179,4 +179,4 @@ export declare const uuid: BaseType<string, string, MergeOperators<NoOperators,
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
 }>, undefined>;
-export { enumOf as enum };
+export { type AnyExpression, type BaseType, type Column, type ComparisonSignature, type EqualityOperator, type EqualityOperators, type GenericOperator, type InSignature, type MergeOperators, type NoOperators, type NumberTypeOperators, type TextOperators, type TextTypeOperators, type Type, enumOf as enum };

package/dist/types.mjs

@@ -1,3 +1,63 @@
-import { n as text, r as varchar, t as char } from "./text-CIUxPWPl.mjs";
-import { _ as timestamptz, a as numeric, b as array, c as cidr, d as jsonb, f as enumOf, g as timestamp, h as time, i as integer, l as inet, m as interval, n as bigint, o as real, p as date, r as doublePrecision, s as smallint, t as uuid, u as json, v as boolean, y as bytea } from "./types-D3d35qR2.mjs";
+import { C as defineType, D as equalityOperators, O as hasEquality, S as getBooleanType, a as defineNumberType, n as text, o as getIntegerType, r as varchar, s as orderingOperators, t as char } from "./text-ucmJCsCN.mjs";
+import * as dbTypes from "kern-db/types";
+// src/type/builtins/array.ts
+/**
+* Creates a one-dimensional array type of `element` values.
+*
+* A `NULL` element decodes to `null`; a nullable `element` type, such as `array(text.nullable())`, types such elements.
+* Elements are separated by commas, as in arrays of all built-in types; a custom type with another delimiter, such as `box`, is not supported.
+* An array has `eq`, `ne`, and `in` when its element type has SQL `=`.
+*/
+function array(element) {
+	const type = defineType(dbTypes.array(element));
+	return hasEquality(element) ? type.withOperators(equalityOperators) : type;
+}
+// src/type/builtins/binary.ts
+/** Binary data; PostgreSQL represents it in hex, which requires the default `bytea_output` setting. */
+const bytea = /* @__PURE__ */ defineType(dbTypes.bytea).withOperators(equalityOperators);
+// src/type/builtins/boolean.ts
+/** `boolean` values. */
+const boolean = /* @__PURE__ */ getBooleanType();
+// src/type/builtins/datetime.ts
+/** Point in time as a UTC ISO 8601 string with microseconds, such as `2026-01-15T07:00:00.123456Z`; accepts a `Date` too. */
+const timestamptz = /* @__PURE__ */ defineType(dbTypes.timestamptz).withOperators(orderingOperators);
+/** Date and time without a time zone as an ISO 8601 string with microseconds, such as `2026-01-15T10:00:00.000000`. */
+const timestamp = /* @__PURE__ */ defineType(dbTypes.timestamp).withOperators(orderingOperators);
+/** Calendar date as an ISO 8601 string, such as `2026-01-15`. */
+const date = /* @__PURE__ */ defineType(dbTypes.date).withOperators(orderingOperators);
+/** Time of day as a string with microseconds, such as `10:00:00.000000`. */
+const time = /* @__PURE__ */ defineType(dbTypes.time).withOperators(orderingOperators);
+/** Interval in the PostgreSQL output format, such as `1 day 02:00:00`. */
+const interval = /* @__PURE__ */ defineType(dbTypes.interval).withOperators(orderingOperators);
+// src/type/builtins/enum.ts
+/** Creates a type of an existing PostgreSQL enum; values are ordered as declared in the enum. */
+function enumOf(name, values) {
+	return defineType(dbTypes.enum(name, values)).withOperators(orderingOperators);
+}
+// src/type/builtins/json.ts
+/** `json` values; `json.of<T>()` declares their shape. PostgreSQL has no `=` for `json`, so its expressions have no `eq`, `ne`, or `in`. */
+const json = /* @__PURE__ */ defineType(dbTypes.json);
+/** `jsonb` values; `jsonb.of<T>()` declares their shape. */
+const jsonb = /* @__PURE__ */ defineType(dbTypes.jsonb).withOperators(equalityOperators);
+// src/type/builtins/network.ts
+/** IP address with an optional netmask as a string, such as `192.168.0.1`. */
+const inet = /* @__PURE__ */ defineType(dbTypes.inet).withOperators(orderingOperators);
+/** IP network as a string, such as `10.0.0.0/8`. */
+const cidr = /* @__PURE__ */ defineType(dbTypes.cidr).withOperators(orderingOperators);
+// src/type/builtins/numeric.ts
+/** 2-byte integer as a `number`. */
+const smallint = /* @__PURE__ */ defineNumberType(dbTypes.smallint);
+/** 4-byte integer as a `number`. */
+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(dbTypes.bigint).withOperators(orderingOperators);
+/** 4-byte floating-point number as a `number`. */
+const real = /* @__PURE__ */ defineNumberType(dbTypes.real);
+/** 8-byte floating-point number as a `number`. */
+const doublePrecision = /* @__PURE__ */ defineNumberType(dbTypes.doublePrecision);
+/** Exact number as a decimal string, so that no precision is lost; `numeric.with(precision, scale)` constrains it. */
+const numeric = /* @__PURE__ */ defineType(dbTypes.numeric).withOperators(orderingOperators);
+// src/type/builtins/uuid.ts
+/** UUID as a string. */
+const uuid = /* @__PURE__ */ defineType(dbTypes.uuid).withOperators(orderingOperators);
 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.8.0",
+  "version": "0.10.0",
   "description": "Fully typed relational query builder for PostgreSQL with ambient transactions and single-query relation loading",
   "keywords": [
     "orm",
@@ -18,7 +18,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/IlyaSemenov/kern-orm.git",
-    "directory": "packages/kern-orm"
+    "directory": "packages/orm"
   },
   "files": [
     "README.md",
@@ -29,6 +29,10 @@
   "types": "./dist/index.d.mts",
   "exports": {
     ".": "./dist/index.mjs",
+    "./db": "./dist/db.mjs",
+    "./db/node-postgres": "./dist/db/node-postgres.mjs",
+    "./db/postgres-js": "./dist/db/postgres-js.mjs",
+    "./db/types": "./dist/db/types.mjs",
     "./testing": "./dist/testing.mjs",
     "./types": "./dist/types.mjs",
     "./package.json": "./package.json"
@@ -40,8 +44,11 @@
     "build": "tsdown",
     "prepublishOnly": "bun run build"
   },
+  "dependencies": {
+    "kern-db": "^0.1.0"
+  },
   "devDependencies": {
-    "@kern-orm/postgres-js": "workspace:*",
+    "@kern-orm/test-harness": "workspace:*",
     "postgres": "catalog:",
     "typescript-6": "catalog:"
   },