kern-orm 0.0.0-stage → 0.2.0

package/dist/types.mjs

@@ -0,0 +1,254 @@
+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";
+// 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({
+		sqlType: `${element.sqlType}[]`,
+		castType: `${element.castType}[]`
+	}).transform({
+		decode(text) {
+			const values = parseArray(text);
+			for (let index = 0; index < values.length; index++) {
+				const value = values[index];
+				values[index] = value === null ? null : element.decode(value);
+			}
+			return values;
+		},
+		encode(values) {
+			let text = "{";
+			for (let index = 0; index < values.length; index++) {
+				const value = values[index];
+				text += `${index === 0 ? "" : ","}${formatArrayElement(value === null ? null : element.encode(value))}`;
+			}
+			return `${text}}`;
+		}
+	});
+	return hasEquality(element) ? type.withOperators(equalityOperators) : type;
+}
+/** Parses a one-dimensional array literal, such as `{a,"b c",NULL}`, into the text representations of its elements. */
+function parseArray(text) {
+	const start = text.startsWith("[") ? text.indexOf("=") + 1 : 0;
+	if (text[start] !== "{" || !text.endsWith("}")) throw new Error(`Unsupported array value "${text}"`);
+	const elements = [];
+	const end = text.length - 1;
+	if (start + 1 === end) return elements;
+	let index = start + 1;
+	while (true) {
+		if (text[index] === "{") throw new Error("Multidimensional arrays are not supported");
+		if (text[index] === "\"") {
+			let element = "";
+			index++;
+			while (index < end && text[index] !== "\"") {
+				if (text[index] === "\\") {
+					index++;
+					if (index === end) break;
+				}
+				element += text[index];
+				index++;
+			}
+			if (index === end) throw new Error(`Unterminated quoted element in array value "${text}"`);
+			elements.push(element);
+			index++;
+		} else {
+			let next = text.indexOf(",", index);
+			if (next === -1) next = end;
+			if (next === index) throw new Error(`Malformed array value "${text}"`);
+			const element = text.slice(index, next);
+			elements.push(element === "NULL" ? null : element);
+			index = next;
+		}
+		if (index === end) return elements;
+		if (text[index] !== ",") throw new Error(`Malformed array value "${text}"`);
+		index++;
+	}
+}
+/** Formats the text representation of an array element, quoting it unless it is `NULL`. */
+function formatArrayElement(element) {
+	return element === null ? "NULL" : `"${element.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+// src/type/builtins/binary.ts
+/** Binary data; PostgreSQL represents it in hex, which requires the default `bytea_output` setting. */
+const bytea = /* @__PURE__ */ defineType({ sqlType: "bytea" }).transform({
+	decode: decodeBytea,
+	encode: encodeBytea
+}).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({ sqlType: "timestamptz" }).transform({
+	decode: normalizeTimestamptz,
+	encode: (value) => toPostgresYear(value instanceof Date ? value.toISOString() : value)
+}).withOperators(orderingOperators).withParameters(/* @__PURE__ */ createPrecisionFormatter("timestamptz"));
+/** 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({ sqlType: "timestamp" }).transform({
+	decode: normalizeTimestamp,
+	encode: toPostgresYear
+}).withOperators(orderingOperators).withParameters(/* @__PURE__ */ createPrecisionFormatter("timestamp"));
+/** Calendar date as an ISO 8601 string, such as `2026-01-15`. */
+const date = /* @__PURE__ */ defineType({ sqlType: "date" }).transform({
+	decode: normalizeDate,
+	encode: toPostgresYear
+}).withOperators(orderingOperators);
+/** Time of day as a string with microseconds, such as `10:00:00.000000`. */
+const time = /* @__PURE__ */ defineType({ sqlType: "time" }).transform({ decode: normalizeTime }).withOperators(orderingOperators).withParameters(/* @__PURE__ */ createPrecisionFormatter("time"));
+/** Interval in the PostgreSQL output format, such as `1 day 02:00:00`. */
+const interval = /* @__PURE__ */ defineType({ sqlType: "interval" }).withOperators(orderingOperators);
+function createPrecisionFormatter(name) {
+	return (precision) => formatTypeName(name, precision);
+}
+const timestamptzPattern = /^(\d{4,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,6}))?([+-])(\d{2})(?::(\d{2}))?(?::(\d{2}))?( BC)?$/;
+const timestampPattern = /^(\d{4,})(-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})(?:\.(\d{1,6}))?( BC)?$/;
+const datePattern = /^(\d{4,})(-\d{2}-\d{2})( BC)?$/;
+const timePattern = /^(\d{2}:\d{2}:\d{2})(?:\.(\d{1,6}))?$/;
+/** Leading ISO 8601 year that PostgreSQL does not accept: an expanded year, such as `+010000`, or year `0000`. */
+const isoYearPattern = /^([+-]\d{6,}|0000)(-.*)$/s;
+/** Special date and time values that PostgreSQL returns as they are. */
+const infinities = /* @__PURE__ */ new Set(["infinity", "-infinity"]);
+/**
+* Normalizes a `timestamptz` value to UTC ISO 8601 with microseconds, such as `2026-01-15T07:00:00.123456Z`.
+*
+* The fixed format keeps microseconds that `Date` would lose; the arithmetic avoids `Date`, whose range is narrower than that of PostgreSQL.
+*/
+function normalizeTimestamptz(text) {
+	if (infinities.has(text)) return text;
+	const match = timestamptzPattern.exec(text);
+	if (!match) throw new Error(`Unsupported timestamptz value "${text}"; kern-orm expects DateStyle ISO`);
+	const offset = (match[8] === "-" ? -1 : 1) * (Number(match[9]) * 3600 + Number(match[10] ?? 0) * 60 + Number(match[11] ?? 0));
+	const seconds = countDays(toAstronomicalYear(match[1], match[12]), Number(match[2]), Number(match[3])) * 86400 + Number(match[4]) * 3600 + Number(match[5]) * 60 + Number(match[6]) - offset;
+	const days = Math.floor(seconds / 86400);
+	const time = seconds - days * 86400;
+	return `${formatDate(days)}T${padTwo(Math.floor(time / 3600))}:${padTwo(Math.floor(time / 60) % 60)}:${padTwo(time % 60)}.${padFraction(match[7])}Z`;
+}
+/** Normalizes a `timestamp` value to ISO 8601 without a time zone, such as `2026-01-15T10:00:00.000000`. */
+function normalizeTimestamp(text) {
+	if (infinities.has(text)) return text;
+	const match = timestampPattern.exec(text);
+	if (!match) throw new Error(`Unsupported timestamp value "${text}"; kern-orm expects DateStyle ISO`);
+	return `${formatYear(toAstronomicalYear(match[1], match[5]))}${match[2]}T${match[3]}.${padFraction(match[4])}`;
+}
+/** Normalizes a `date` value to ISO 8601, such as `2026-01-15`. */
+function normalizeDate(text) {
+	if (infinities.has(text)) return text;
+	const match = datePattern.exec(text);
+	if (!match) throw new Error(`Unsupported date value "${text}"; kern-orm expects DateStyle ISO`);
+	return `${formatYear(toAstronomicalYear(match[1], match[3]))}${match[2]}`;
+}
+/** Normalizes a `time` value to `HH:MM:SS.ffffff`. */
+function normalizeTime(text) {
+	const match = timePattern.exec(text);
+	if (!match) throw new Error(`Unsupported time value "${text}"`);
+	return `${match[1]}.${padFraction(match[2])}`;
+}
+/** Converts a leading ISO 8601 year outside 1 to 9999 into the PostgreSQL format: unsigned after 9999 and with a `BC` suffix before 1. */
+function toPostgresYear(text) {
+	const match = isoYearPattern.exec(text);
+	if (!match) return text;
+	const year = Number(match[1]);
+	return year > 0 ? `${year}${match[2]}` : `${String(1 - year).padStart(4, "0")}${match[2]} BC`;
+}
+/** Returns the astronomical year of a PostgreSQL year, where 1 BC is year 0. */
+function toAstronomicalYear(year, era) {
+	return era === void 0 ? Number(year) : 1 - Number(year);
+}
+/** Formats an astronomical year as an ISO 8601 year, expanded with a sign outside 0 to 9999. */
+function formatYear(year) {
+	if (year >= 0 && year <= 9999) return String(year).padStart(4, "0");
+	return `${year < 0 ? "-" : "+"}${String(Math.abs(year)).padStart(6, "0")}`;
+}
+/** Counts the days from 1970-01-01 to a date of an astronomical year. */
+function countDays(year, month, day) {
+	const shifted = month <= 2 ? year - 1 : year;
+	const era = Math.floor(shifted / 400);
+	const yearOfEra = shifted - era * 400;
+	const dayOfYear = Math.floor((153 * (month > 2 ? month - 3 : month + 9) + 2) / 5) + day - 1;
+	const dayOfEra = yearOfEra * 365 + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100) + dayOfYear;
+	return era * 146097 + dayOfEra - 719468;
+}
+/** Formats the date a number of days after 1970-01-01 as an ISO 8601 date. */
+function formatDate(days) {
+	const shifted = days + 719468;
+	const era = Math.floor(shifted / 146097);
+	const dayOfEra = shifted - era * 146097;
+	const yearOfEra = Math.floor((dayOfEra - Math.floor(dayOfEra / 1460) + Math.floor(dayOfEra / 36524) - Math.floor(dayOfEra / 146096)) / 365);
+	const dayOfYear = dayOfEra - (365 * yearOfEra + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100));
+	const shiftedMonth = Math.floor((5 * dayOfYear + 2) / 153);
+	const day = dayOfYear - Math.floor((153 * shiftedMonth + 2) / 5) + 1;
+	const month = shiftedMonth < 10 ? shiftedMonth + 3 : shiftedMonth - 9;
+	return `${formatYear(yearOfEra + era * 400 + (month <= 2 ? 1 : 0))}-${padTwo(month)}-${padTwo(day)}`;
+}
+function padTwo(value) {
+	return value < 10 ? `0${value}` : String(value);
+}
+function padFraction(fraction) {
+	return (fraction ?? "").padEnd(6, "0");
+}
+// 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({
+		sqlType: name,
+		castType: name
+	}).transform({
+		decode: (value) => value,
+		encode: (value) => value
+	}).withOperators(orderingOperators);
+}
+// src/type/builtins/json.ts
+function createJsonType(sqlType) {
+	return defineType({ sqlType }).transform({
+		decode: (text) => JSON.parse(text),
+		encode: stringifyJson
+	});
+}
+function addShape(type) {
+	return Object.freeze({
+		...type,
+		of: () => type
+	});
+}
+/** `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__ */ addShape(/* @__PURE__ */ createJsonType("json"));
+/** `jsonb` values; `jsonb.of<T>()` declares their shape. */
+const jsonb = /* @__PURE__ */ addShape(/* @__PURE__ */ createJsonType("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({ sqlType: "inet" }).withOperators(orderingOperators);
+/** 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");
+/** 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,
+	encode: (value) => String(value)
+}).withOperators(orderingOperators);
+/** 4-byte floating-point number as a `number`. */
+const real = /* @__PURE__ */ defineNumberType("real");
+/** 8-byte floating-point number as a `number`. */
+const doublePrecision = /* @__PURE__ */ defineNumberType("double precision");
+/** Exact number as a decimal string, so that no precision is lost; `numeric.with(precision, scale)` constrains it. */
+const numeric = /* @__PURE__ */ defineType({ sqlType: "numeric" }).transform({
+	decode: (value) => value,
+	encode: (value) => String(value)
+}).withOperators(orderingOperators).withParameters((precision, scale) => formatTypeName("numeric", precision, scale));
+// src/type/builtins/uuid.ts
+/** UUID as a string. */
+const uuid = /* @__PURE__ */ defineType({ sqlType: "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,52 @@
 {
   "name": "kern-orm",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Fully typed relational query builder for PostgreSQL with ambient transactions and single-query relation loading",
+  "keywords": [
+    "orm",
+    "postgres",
+    "postgresql",
+    "query-builder",
+    "sql",
+    "transactions",
+    "typescript"
+  ],
+  "homepage": "https://ilyasemenov.github.io/kern-orm/",
+  "bugs": "https://github.com/IlyaSemenov/kern-orm/issues",
+  "license": "MIT",
+  "author": "Ilya Semenov",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/IlyaSemenov/kern-orm.git",
+    "directory": "packages/kern-orm"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./testing": "./dist/testing.mjs",
+    "./types": "./dist/types.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@kern-orm/postgres-js": "workspace:*",
+    "postgres": "catalog:",
+    "typescript-6": "catalog:"
+  },
+  "engines": {
+    "bun": ">=1.4",
+    "node": ">=24"
+  }
+}