@voltro/database 0.84.0 → 0.86.0

package/dist/predicate.js

@@ -0,0 +1,266 @@
+import { columnComparisonOperators as e, columnRef as t, isColumnReference as n } from "./columnReference.js";
+import { authoredError as r } from "./dbCause.js";
+import { compareDecimal as i } from "./decimalComparison.js";
+//#region src/predicate.ts
+var a = (e, t) => ({
+	column: e,
+	op: "eq",
+	value: t
+}), o = (e, t) => ({
+	column: e,
+	op: "neq",
+	value: t
+}), s = (e, t) => ({
+	column: e,
+	op: "gt",
+	value: t
+}), c = (e, t) => ({
+	column: e,
+	op: "gte",
+	value: t
+}), l = (e, t) => ({
+	column: e,
+	op: "lt",
+	value: t
+}), u = (e, t) => ({
+	column: e,
+	op: "lte",
+	value: t
+}), d = (e, t) => ({
+	column: e,
+	op: "in",
+	value: t
+}), f = (e, t) => ({
+	column: e,
+	op: "notIn",
+	value: t
+}), p = (e, t) => ({
+	column: e,
+	op: "contains",
+	value: t
+}), m = (e, t) => ({
+	column: e,
+	op: "startsWith",
+	value: t
+}), h = (e, t) => ({
+	column: e,
+	op: "arrayContains",
+	value: t
+}), g = (e, t) => ({
+	column: e,
+	op: "arrayOverlaps",
+	value: t
+}), _ = (e, t) => ({
+	column: e,
+	op: "arrayHas",
+	value: t
+}), v = {
+	column: "id",
+	op: "in",
+	value: []
+}, y = (e) => ({
+	column: e,
+	op: "isNull"
+}), b = (e) => ({
+	column: e,
+	op: "isNotNull"
+}), x = (e, t) => ({
+	column: e,
+	op: "spatial",
+	value: t
+}), S = (...e) => ({ and: e }), C = (...e) => ({ or: e }), w = (e) => ({ not: e }), T = (e, ...t) => {
+	if (t.length === 0) throw r(`jsonField("${e}"): at least one path segment is required`);
+	let n = (n, r) => ({
+		column: e,
+		path: t,
+		op: n,
+		value: r
+	});
+	return {
+		eq: (e) => n("eq", e),
+		neq: (e) => n("neq", e),
+		gt: (e) => n("gt", e),
+		gte: (e) => n("gte", e),
+		lt: (e) => n("lt", e),
+		lte: (e) => n("lte", e),
+		inSet: (e) => n("in", e),
+		notInSet: (e) => n("notIn", e),
+		contains: (e) => n("contains", e),
+		startsWith: (e) => n("startsWith", e),
+		isNull: () => n("isNull"),
+		isNotNull: () => n("isNotNull")
+	};
+}, E = (e) => "descriptor" in e ? e.descriptor : e, D = (e, t) => ({
+	column: e,
+	op: "subquery-in",
+	subquery: E(t)
+}), O = (e, t) => ({
+	column: e,
+	op: "subquery-not-in",
+	subquery: E(t)
+}), k = (e) => ({
+	op: "exists",
+	subquery: E(e)
+}), A = (e) => ({
+	op: "not-exists",
+	subquery: E(e)
+}), j = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/, M = (e) => {
+	if (e instanceof Date) return e.getTime();
+	if (typeof e == "string" && j.test(e)) {
+		let t = Date.parse(e);
+		return Number.isNaN(t) ? void 0 : t;
+	}
+}, N = (e, t) => {
+	if (!(e instanceof Date) && !(t instanceof Date)) return;
+	let n = M(e), r = M(t);
+	return n === void 0 || r === void 0 ? void 0 : [n, r];
+}, P = (e, t) => {
+	if (e === t) return !0;
+	if (e instanceof Uint8Array && t instanceof Uint8Array) {
+		if (e.length !== t.length) return !1;
+		for (let n = 0; n < e.length; n += 1) if (e[n] !== t[n]) return !1;
+		return !0;
+	}
+	let n = N(e, t);
+	return n !== void 0 && n[0] === n[1];
+}, F = (e, t) => {
+	if (e == null || t == null) return null;
+	let n = N(e, t);
+	if (n !== void 0) return n[0] === n[1] ? 0 : n[0] > n[1] ? 1 : -1;
+	let r = e instanceof Date ? e.getTime() : e, i = t instanceof Date ? t.getTime() : t;
+	return typeof r == typeof i ? r === i ? 0 : r > i ? 1 : -1 : null;
+}, I = (e, t, n = null, r = {}) => z(e, t, n, r) === !0, L = (e, t = null, n = {}) => {
+	let r = /* @__PURE__ */ new Map(), i = (e) => {
+		if ("not" in e) {
+			i(e.not);
+			return;
+		}
+		if ("and" in e) {
+			e.and.forEach(i);
+			return;
+		}
+		if ("or" in e) {
+			e.or.forEach(i);
+			return;
+		}
+		if (e.op !== "in" && e.op !== "notIn" || n[e.column]?.type === "decimal") return;
+		let t = Object.getOwnPropertyDescriptor(e, "value");
+		if (t === void 0 || !("value" in t)) return;
+		let a = t.value;
+		if (!Array.isArray(a) || a.length < 16 || Object.getPrototypeOf(a) !== Array.prototype) return;
+		let o = Object.getOwnPropertyDescriptor(a, "some");
+		if (o !== void 0 && (!("value" in o) || o.value !== Array.prototype.some)) return;
+		for (let e = 0; e < a.length; e++) {
+			let t = Object.getOwnPropertyDescriptor(a, e);
+			if (t !== void 0 && !("value" in t)) return;
+		}
+		if (a.some((e) => typeof e == "object" && !!e)) return;
+		let s = Array.prototype.filter.call(a, (e) => !(typeof e == "number" && Number.isNaN(e)));
+		r.set(e, new Set(s));
+	};
+	return i(e), (i) => z(e, i, t, n, r) === !0;
+}, R = (e, t, n) => {
+	if (e.length < 128 || t.length < 16 || Object.getPrototypeOf(e) !== Array.prototype || Object.getPrototypeOf(t) !== Array.prototype || Object.getOwnPropertyDescriptor(e, "includes") !== void 0 || Object.getOwnPropertyDescriptor(t, n) !== void 0) return;
+	for (let n of [e, t]) for (let e = 0; e < n.length; e += 1) {
+		let t = Object.getOwnPropertyDescriptor(n, String(e));
+		if (t === void 0 || !("value" in t)) return;
+	}
+	let r = /* @__PURE__ */ new Set();
+	for (let t = 0; t < e.length; t += 1) r.add(e[t]);
+	return r;
+}, z = (t, a, o = null, s = {}, c) => {
+	if (!a) return !1;
+	if ("not" in t) {
+		let e = z(t.not, a, o, s, c);
+		return e === null ? null : !e;
+	}
+	if ("and" in t) {
+		let e = !1;
+		for (let n of t.and) {
+			let t = z(n, a, o, s, c);
+			if (t === !1) return !1;
+			t === null && (e = !0);
+		}
+		return !e || null;
+	}
+	if ("or" in t) {
+		let e = !1;
+		for (let n of t.or) {
+			let t = z(n, a, o, s, c);
+			if (t === !0) return !0;
+			t === null && (e = !0);
+		}
+		return e ? null : !1;
+	}
+	if (t.op === "subquery-in" || t.op === "subquery-not-in") {
+		if (!o) return !1;
+		let e = o.get(t.subquery);
+		if (!(e instanceof Set)) return !1;
+		let n = a[t.column], r = s[t.column]?.type === "decimal" ? [...e].some((e) => i(n, e) === 0) : e.has(n);
+		return t.op === "subquery-in" ? r : !r;
+	}
+	if (t.op === "exists" || t.op === "not-exists") {
+		if (!o) return !1;
+		let e = o.get(t.subquery), n = typeof e == "number" ? e > 0 : e instanceof Set && e.size > 0;
+		return t.op === "exists" ? n : !n;
+	}
+	let l = t, u = a[l.column], d = n(l.value) ? l.value : void 0;
+	if (d !== void 0 && (!e.some((e) => e === l.op) || l.path !== void 0)) throw r("Column references require a scalar comparison without a JSON path");
+	let f = d === void 0 ? l.value : a[d.column];
+	if (d !== void 0 && (u == null || f == null)) return null;
+	let p = s[l.column]?.type === "decimal", m = c?.get(t);
+	if (m !== void 0 && !(u instanceof Date) && !(u instanceof Uint8Array)) {
+		let e = typeof u == "number" && Number.isNaN(u) ? !1 : m.has(u);
+		return l.op === "in" ? e : !e;
+	}
+	let h = (e, t) => p && e != null && t != null ? i(e, t) === 0 : P(e, t), g = p ? i : F;
+	switch (l.op) {
+		case "eq": return h(u, f);
+		case "neq": return !h(u, f);
+		case "gt": return (g(u, f) ?? -1) > 0;
+		case "gte": return (g(u, f) ?? -1) >= 0;
+		case "lt": return (g(u, f) ?? 1) < 0;
+		case "lte": return (g(u, f) ?? 1) <= 0;
+		case "in": return Array.isArray(f) && f.some((e) => h(u, e));
+		case "notIn": return Array.isArray(f) && !f.some((e) => h(u, e));
+		case "contains": return typeof u == "string" && typeof f == "string" && u.toLowerCase().includes(f.toLowerCase());
+		case "startsWith": return typeof u == "string" && typeof f == "string" && u.startsWith(f);
+		case "arrayContains": {
+			let e = Array.isArray(u) ? u : [], t = Array.isArray(f) ? f : [];
+			if (e.length < 128 || t.length < 16) return t.every((t) => e.includes(t));
+			let n, r = 0;
+			return t.every((i) => (++r === 5 && (n = R(e, t, "every")), n === void 0 ? e.includes(i) : n.has(i)));
+		}
+		case "arrayOverlaps": {
+			let e = Array.isArray(u) ? u : [], t = Array.isArray(f) ? f : [];
+			if (e.length < 128 || t.length < 16) return t.some((t) => e.includes(t));
+			let n, r = 0;
+			return t.some((i) => (++r === 5 && (n = R(e, t, "some")), n === void 0 ? e.includes(i) : n.has(i)));
+		}
+		case "arrayHas": return Array.isArray(u) && u.includes(f);
+		case "isNull": return u == null;
+		case "isNotNull": return u != null;
+		case "spatial": throw r("@voltro/plugin-postgis: spatial predicates (ST_DWithin / ST_Contains / ST_Within / ST_Intersects / bbox &&) are not evaluable in-memory — use them in one-shot ctx.store.query reads, not reactive subscriptions.");
+	}
+}, B = function* (e) {
+	if ("not" in e) yield* B(e.not);
+	else if ("and" in e) for (let t of e.and) yield* B(t);
+	else if ("or" in e) for (let t of e.or) yield* B(t);
+	else e.op === "subquery-in" || e.op === "subquery-not-in" ? yield {
+		kind: "in",
+		descriptor: e.subquery
+	} : (e.op === "exists" || e.op === "not-exists") && (yield {
+		kind: "exists",
+		descriptor: e.subquery
+	});
+}, V = function* (e, t = !0) {
+	if ("not" in e) yield* V(e.not, !1);
+	else if ("and" in e) for (let n of e.and) yield* V(n, t);
+	else if ("or" in e) for (let t of e.or) yield* V(t, !1);
+	else e.op !== "subquery-in" && e.op !== "subquery-not-in" && e.op !== "exists" && e.op !== "not-exists" && (yield {
+		...e,
+		conjunctive: t && !n(e.value)
+	});
+};
+//#endregion
+export { v as MATCHES_NO_ROWS, S as and, h as arrayContains, _ as arrayHas, g as arrayOverlaps, B as collectSubqueries, t as columnRef, p as contains, a as eq, I as evaluatePredicate, k as exists, s as gt, c as gte, d as inSet, D as inSubquery, n as isColumnReference, b as isNotNull, y as isNull, T as jsonField, l as lt, u as lte, o as neq, w as not, A as notExists, f as notInSet, O as notInSubquery, C as or, L as preparePredicate, x as spatialPredicate, m as startsWith, V as walkLeaves };

package/dist/predicateCoercion.js

@@ -0,0 +1,13 @@
+//#region src/predicateCoercion.ts
+var e = /* @__PURE__ */ new Set(["timestamp", "date"]), t = /^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2})?/, n = (n, r) => {
+	if (n === void 0 || r == null || !e.has(n) || r instanceof Date) return r;
+	if (typeof r == "number" && Number.isFinite(r)) return new Date(r);
+	if (typeof r == "string" && t.test(r)) {
+		if (/:\d{2}\.\d{4,}/.test(r)) return r;
+		let e = new Date(r);
+		return Number.isNaN(e.getTime()) ? r : e;
+	}
+	return r;
+}, r = (t, r) => t === void 0 || !e.has(t) ? r : r.map((e) => n(t, e));
+//#endregion
+export { n as coercePredicateValue, r as coercePredicateValues };

package/dist/projectedColumn.js

@@ -0,0 +1,37 @@
+import { getTable as e } from "./tableRegistry.js";
+//#region src/projectedColumn.ts
+var t = (t, n) => {
+	let r = t.lastIndexOf("."), i = r < 0 ? t : t.slice(r + 1), a = r < 0 ? void 0 : t.slice(0, r), o = a === void 0 || a === n.alias || a === n.table, s = o ? void 0 : n.joins?.find((e) => e.alias === a), c = o ? n.table : s?.table, l = o ? n.sourceTable : s?.sourceTable;
+	return (l?.tableName === c ? l : c === void 0 ? void 0 : e(c))?.fields[i];
+}, n = (n) => {
+	for (let e of [
+		"joins",
+		"alias",
+		"table",
+		"sourceTable"
+	]) {
+		let r = Object.getOwnPropertyDescriptor(n, e);
+		if (r === void 0 ? e in n : !("value" in r)) return (e) => t(e, n);
+	}
+	let r = n.joins;
+	if (r === void 0 || r.length < 8 || Object.getPrototypeOf(r) !== Array.prototype || r.find !== Array.prototype.find || r[Symbol.iterator] !== Array.prototype[Symbol.iterator]) return (e) => t(e, n);
+	let i = /* @__PURE__ */ new Map();
+	for (let e = 0; e < r.length; e++) {
+		let a = Object.getOwnPropertyDescriptor(r, e);
+		if (a === void 0 || !("value" in a)) return (e) => t(e, n);
+		let o = a.value;
+		for (let e of ["table", "sourceTable"]) {
+			let r = Object.getOwnPropertyDescriptor(o, e);
+			if (r === void 0 ? e in o : !("value" in r)) return (e) => t(e, n);
+		}
+		let s = Object.getOwnPropertyDescriptor(o, "alias");
+		if (s === void 0 || !("value" in s) || typeof s.value != "string") return (e) => t(e, n);
+		i.has(s.value) || i.set(s.value, o);
+	}
+	return (t) => {
+		let r = t.lastIndexOf("."), a = r < 0 ? t : t.slice(r + 1), o = r < 0 ? void 0 : t.slice(0, r), s = o === void 0 || o === n.alias || o === n.table, c = s ? void 0 : i.get(o), l = s ? n.table : c?.table, u = s ? n.sourceTable : c?.sourceTable;
+		return (u?.tableName === l ? u : l === void 0 ? void 0 : e(l))?.fields[a];
+	};
+};
+//#endregion
+export { n as prepareProjectedColumn, t as projectedColumn };

package/dist/queryBuilder.js

@@ -0,0 +1,382 @@
+import { getTable as e, registerTable as t } from "./tableRegistry.js";
+//#region src/queryBuilder.ts
+var n = (e) => e.order ?? [], r = (e) => ({
+	op: "count",
+	alias: e ?? "count"
+}), i = (e, t) => ({
+	op: "count-distinct",
+	column: e,
+	alias: t ?? `count_distinct_${e}`
+}), a = (e, t) => ({
+	op: "sum",
+	column: e,
+	alias: t ?? `sum_${e}`
+}), o = (e, t) => ({
+	op: "avg",
+	column: e,
+	alias: t ?? `avg_${e}`
+}), s = (e, t) => ({
+	op: "min",
+	column: e,
+	alias: t ?? `min_${e}`
+}), c = (e, t) => ({
+	op: "max",
+	column: e,
+	alias: t ?? `max_${e}`
+}), l = (e, t) => ({
+	op: "column",
+	column: e,
+	alias: t ?? e
+}), u = (e) => (...t) => {
+	if (t.length < 2) throw Error(`${e}: requires at least two queries`);
+	return w({
+		table: t[0].descriptor.table,
+		predicate: void 0,
+		order: [],
+		take: void 0,
+		skip: void 0,
+		projection: void 0,
+		setOp: {
+			kind: e,
+			queries: t.map((e) => e.descriptor)
+		}
+	});
+}, d = u("union"), f = u("union-all"), p = u("intersect"), m = u("except"), h = (e) => ({ over: (t) => ({
+	...e,
+	window: t
+}) }), g = (e = "rowNumber") => h({
+	op: "window-row-number",
+	alias: e
+}), _ = (e = "rank") => h({
+	op: "window-rank",
+	alias: e
+}), v = (e = "denseRank") => h({
+	op: "window-dense-rank",
+	alias: e
+}), y = (e, t = 1, n) => h({
+	op: "window-lag",
+	column: e,
+	alias: n ?? `lag_${e}`,
+	offset: t
+}), b = (e, t = 1, n) => h({
+	op: "window-lead",
+	column: e,
+	alias: n ?? `lead_${e}`,
+	offset: t
+}), x = (e, t) => h({
+	op: "window-sum-over",
+	column: e,
+	alias: t ?? `sum_${e}_over`
+}), S = (e, t) => h({
+	op: "window-avg-over",
+	column: e,
+	alias: t ?? `avg_${e}_over`
+}), C = (t, n, r) => {
+	let i = r?.find((e) => e.name === n) ?? e(t)?.appliedFullText?.find((e) => e.name === n);
+	if (i === void 0) throw Error(`.matching('${n}', ...): no full-text index named '${n}' is declared on table '${t}'. Declare it with \`table(...).fullTextIndex('${n}', [columns])\` first.`);
+	return {
+		columns: i.columns,
+		...i.config === void 0 ? {} : { config: i.config },
+		...i.weights === void 0 ? {} : { weights: i.weights }
+	};
+}, w = (e) => ({
+	descriptor: e,
+	where(t) {
+		let n = e.predicate ? { and: [e.predicate, t] } : t;
+		return w({
+			...e,
+			predicate: n
+		});
+	},
+	orderBy(t, n = "asc") {
+		return w({
+			...e,
+			order: [...e.order, {
+				column: t,
+				direction: n
+			}]
+		});
+	},
+	limit(t) {
+		return w({
+			...e,
+			take: t
+		});
+	},
+	offset(t) {
+		return w({
+			...e,
+			skip: t
+		});
+	},
+	select(...t) {
+		return w({
+			...e,
+			projection: t
+		});
+	},
+	using(t) {
+		return w({
+			...e,
+			usingIndex: t
+		});
+	},
+	withDeleted() {
+		return w({
+			...e,
+			includeDeleted: !0
+		});
+	},
+	forUpdate() {
+		return w({
+			...e,
+			lock: "update"
+		});
+	},
+	unscoped() {
+		return w({
+			...e,
+			crossTenant: !0
+		});
+	},
+	with(t) {
+		let n = {
+			...e.eager ?? {},
+			...t
+		};
+		return w({
+			...e,
+			eager: n
+		});
+	},
+	count() {
+		return w({
+			...e,
+			projection: void 0,
+			aggregations: [{
+				op: "count",
+				alias: "count"
+			}]
+		});
+	},
+	aggregate(t) {
+		let n = Object.entries(t).map(([e, t]) => ({
+			...t,
+			alias: e
+		}));
+		return w({
+			...e,
+			projection: void 0,
+			aggregations: n
+		});
+	},
+	matching(t, n, r) {
+		let i = C(e.table, t, e.fullTextIndexes);
+		return w({
+			...e,
+			fullTextSearch: {
+				indexName: t,
+				query: n,
+				columns: i.columns,
+				...r?.prefix === !0 ? { prefix: !0 } : {},
+				...i.config === void 0 ? {} : { config: i.config },
+				...i.weights === void 0 ? {} : { weights: i.weights }
+			}
+		});
+	},
+	rankBy(t) {
+		let n = e.fullTextSearch;
+		if (n === void 0) throw Error(".rankBy() requires a preceding .matching(...) clause — there is no full-text search to rank on this query.");
+		return w({
+			...e,
+			fullTextSearch: {
+				...n,
+				rank: {
+					alias: t?.alias ?? "rank",
+					order: t?.order ?? !0
+				}
+			}
+		});
+	},
+	nearestNeighbours(t, n, r) {
+		if (typeof t == "string" && Array.isArray(n)) {
+			let i = {
+				column: t,
+				queryVector: n,
+				distance: r?.distance ?? "cosine",
+				...e.annClause?.ef === void 0 ? {} : { ef: e.annClause.ef }
+			};
+			return w({
+				...e,
+				annClause: i
+			});
+		}
+		if (typeof t == "string" && typeof n == "number") {
+			let r = {
+				column: "",
+				queryText: t,
+				distance: "cosine",
+				...e.annClause?.ef === void 0 ? {} : { ef: e.annClause.ef }
+			};
+			return w({
+				...e,
+				annClause: r,
+				take: n
+			});
+		}
+		throw Error("nearestNeighbours: call as (column, queryVector, options?) or (queryString, k).");
+	},
+	efSearch(t) {
+		let n = e.annClause ?? {
+			column: "",
+			distance: "cosine"
+		};
+		return w({
+			...e,
+			annClause: {
+				...n,
+				ef: t
+			}
+		});
+	},
+	use(t) {
+		return w({ ...t(e) });
+	},
+	distinct() {
+		return w({
+			...e,
+			distinct: !0
+		});
+	},
+	distinctOn(t) {
+		return w({
+			...e,
+			distinctOn: [...t]
+		});
+	},
+	as(t) {
+		return w({
+			...e,
+			alias: t
+		});
+	},
+	innerJoin(t, n, r) {
+		let i = typeof t == "string" ? t : t.tableName, a = [...e.joins ?? [], {
+			kind: "inner",
+			table: i,
+			alias: n,
+			on: r,
+			...typeof t == "string" ? {} : { sourceTable: t }
+		}];
+		return w({
+			...e,
+			joins: a
+		});
+	},
+	leftJoin(t, n, r) {
+		let i = typeof t == "string" ? t : t.tableName, a = [...e.joins ?? [], {
+			kind: "left",
+			table: i,
+			alias: n,
+			on: r,
+			...typeof t == "string" ? {} : { sourceTable: t }
+		}];
+		return w({
+			...e,
+			joins: a
+		});
+	},
+	selectJoined(t) {
+		let n = Object.entries(t).map(([e, t]) => ({
+			outputKey: e,
+			source: t
+		}));
+		return w({
+			...e,
+			projection: void 0,
+			joinedProjection: n
+		});
+	},
+	withCte(t, n) {
+		let r = e.ctes ?? [];
+		if (r.some((e) => e.name === t)) throw Error(`Query.withCte: duplicate CTE name '${t}'`);
+		return w({
+			...e,
+			ctes: [...r, {
+				name: t,
+				descriptor: n
+			}]
+		});
+	},
+	recursiveCte(t, n) {
+		let r = e.ctes ?? [];
+		if (r.some((e) => e.name === t)) throw Error(`Query.recursiveCte: duplicate CTE name '${t}'`);
+		return w({
+			...e,
+			ctes: [...r, {
+				name: t,
+				descriptor: n,
+				recursive: !0
+			}]
+		});
+	},
+	groupBy(t) {
+		let n = e.groupBy ? [...e.groupBy, ...t] : [...t];
+		return w({
+			...e,
+			groupBy: n
+		});
+	},
+	having(t) {
+		let n = e.having ? { and: [e.having, t] } : t;
+		return w({
+			...e,
+			having: n
+		});
+	},
+	exists() {
+		return w({
+			...e,
+			projection: void 0,
+			aggregations: [{
+				op: "count",
+				alias: "__exists__"
+			}],
+			take: 1
+		});
+	}
+});
+function T(e) {
+	return w({
+		table: e.tableName,
+		predicate: void 0,
+		order: [],
+		take: void 0,
+		skip: void 0,
+		projection: void 0,
+		fullTextIndexes: e.appliedFullText,
+		sourceTable: e
+	});
+}
+var E = (e, t, n) => D(e, "id", t, n), D = (e, t, n, r, i = "asc") => {
+	let a = [...e.order.filter((e) => e.column !== t), {
+		column: t,
+		direction: i
+	}], o = n === void 0 ? void 0 : {
+		column: t,
+		op: i === "desc" ? "lt" : "gt",
+		value: n
+	}, s = o === void 0 ? e.predicate : e.predicate === void 0 ? o : { and: [e.predicate, o] };
+	return {
+		...e,
+		predicate: s,
+		order: a,
+		take: r
+	};
+}, O = (e) => {
+	let n = {};
+	for (let [r, i] of Object.entries(e)) t(i), n[r] = T(i);
+	return n;
+};
+//#endregion
+export { o as avg, S as avgOver, l as column, r as count, i as countDistinct, O as databaseHandle, v as denseRank, m as except, p as intersect, y as lag, b as lead, c as max, s as min, n as orderClausesOf, D as paginateBy, E as paginateById, T as queryFor, _ as rank, C as resolveFullTextIndex, g as rowNumber, a as sum, x as sumOver, d as union, f as unionAll };

package/dist/rawSql.js

@@ -0,0 +1,8 @@
+//#region src/rawSql.ts
+var e = (e, ...t) => ({
+	_tag: "RawSqlFragment",
+	strings: [...e],
+	values: [...t]
+}), t = (e) => typeof e == "object" && !!e && e._tag === "RawSqlFragment";
+//#endregion
+export { t as isRawSqlFragment, e as sql };