joist-core 2.3.0-next.96 → 2.3.0-next.98

package/build/queries/skipCondition.d.mts

@@ -0,0 +1,7 @@
+import { ColumnCondition } from "./parsedConditions.mjs";
+//#region src/queries/skipCondition.d.ts
+/** An undefined predicate is pruned by either query parser. */
+declare const skipCondition: ColumnCondition;
+//#endregion
+export { skipCondition };
+//# sourceMappingURL=skipCondition.d.mts.map

package/build/queries/skipCondition.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skipCondition.d.mts","names":[],"sources":["../../src/queries/skipCondition.ts"],"mappings":";;;cAGa,eAAe"}

package/build/queries/skipCondition.js

@@ -0,0 +1,13 @@
+//#region src/queries/skipCondition.ts
+/** An undefined predicate is pruned by either query parser. */
+const skipCondition = {
+	kind: "column",
+	alias: "skip",
+	column: "skip",
+	dbType: "skip",
+	cond: void 0
+};
+//#endregion
+export { skipCondition };
+
+//# sourceMappingURL=skipCondition.js.map

package/build/queries/skipCondition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skipCondition.js","names":[],"sources":["../../src/queries/skipCondition.ts"],"sourcesContent":["import type { ColumnCondition } from \"./parsedConditions.ts\";\n\n/** An undefined predicate is pruned by either query parser. */\nexport const skipCondition: ColumnCondition = {\n  kind: \"column\",\n  alias: \"skip\",\n  column: \"skip\",\n  dbType: \"skip\",\n  cond: undefined as any,\n};\n"],"mappings":";;AAGA,MAAa,gBAAiC;CAC5C,MAAM;CACN,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,MAAM,KAAA;AACR"}

package/build/queries/sql/AliasAssigner.cjs

@@ -0,0 +1,35 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils = require("../../utils.cjs");
+//#region src/queries/sql/AliasAssigner.ts
+var AliasAssigner = class {
+	#aliases = {};
+	constructor(query) {
+		this.getAlias = this.getAlias.bind(this);
+		this.getLiteralAlias = this.getLiteralAlias.bind(this);
+		if (query) for (const table of query.tables) {
+			if (table.alias.includes("_")) continue;
+			const abbrev = require_utils.abbreviation(table.table);
+			const i = this.#aliases[abbrev] || 0;
+			const j = Number(table.alias.replace(abbrev, "")) + 1;
+			this.#aliases[abbrev] = Math.max(i, j);
+		}
+	}
+	/** Returns an abbreviated alias for a table name, e.g. `"books"` → `"b"`, `"book_reviews"` → `"br"`. */
+	getAlias(tableName) {
+		const abbrev = require_utils.abbreviation(tableName);
+		return this.#nextAlias(abbrev);
+	}
+	/** Returns an alias using the name as-is (no abbreviation), e.g. `"prequel"` → `"prequel"`. */
+	getLiteralAlias(name) {
+		return this.#nextAlias(name);
+	}
+	#nextAlias(key) {
+		const i = this.#aliases[key] || 0;
+		this.#aliases[key] = i + 1;
+		return i === 0 ? key : `${key}${i}`;
+	}
+};
+//#endregion
+exports.AliasAssigner = AliasAssigner;
+
+//# sourceMappingURL=AliasAssigner.cjs.map

package/build/queries/sql/AliasAssigner.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AliasAssigner.cjs","names":["abbreviation","#aliases","#nextAlias"],"sources":["../../../src/queries/sql/AliasAssigner.ts"],"sourcesContent":["import { abbreviation } from \"../../utils.ts\";\nimport type { ParsedFindQuery } from \"../find/QueryParser.ts\";\n\nexport class AliasAssigner {\n  #aliases: Record<string, number> = {};\n\n  constructor(query?: ParsedFindQuery) {\n    this.getAlias = this.getAlias.bind(this);\n    this.getLiteralAlias = this.getLiteralAlias.bind(this);\n    // If we're assigning aliases into an existing query, get the current assignments\n    if (query) {\n      for (const table of query.tables) {\n        // Ignore CTI base/sub aliases\n        if (table.alias.includes(\"_\")) continue;\n        const abbrev = abbreviation(table.table);\n        const i = this.#aliases[abbrev] || 0;\n        const j = Number(table.alias.replace(abbrev, \"\")) + 1;\n        this.#aliases[abbrev] = Math.max(i, j);\n      }\n    }\n  }\n\n  /** Returns an abbreviated alias for a table name, e.g. `\"books\"` → `\"b\"`, `\"book_reviews\"` → `\"br\"`. */\n  getAlias(tableName: string): string {\n    const abbrev = abbreviation(tableName);\n    return this.#nextAlias(abbrev);\n  }\n\n  /** Returns an alias using the name as-is (no abbreviation), e.g. `\"prequel\"` → `\"prequel\"`. */\n  getLiteralAlias(name: string): string {\n    return this.#nextAlias(name);\n  }\n\n  #nextAlias(key: string): string {\n    const i = this.#aliases[key] || 0;\n    this.#aliases[key] = i + 1;\n    return i === 0 ? key : `${key}${i}`;\n  }\n}\n"],"mappings":";;;AAGA,IAAa,gBAAb,MAA2B;CACzB,WAAmC,CAAC;CAEpC,YAAY,OAAyB;EACnC,KAAK,WAAW,KAAK,SAAS,KAAK,IAAI;EACvC,KAAK,kBAAkB,KAAK,gBAAgB,KAAK,IAAI;EAErD,IAAI,OACF,KAAK,MAAM,SAAS,MAAM,QAAQ;GAEhC,IAAI,MAAM,MAAM,SAAS,GAAG,GAAG;GAC/B,MAAM,SAASA,cAAAA,aAAa,MAAM,KAAK;GACvC,MAAM,IAAI,KAAKC,SAAS,WAAW;GACnC,MAAM,IAAI,OAAO,MAAM,MAAM,QAAQ,QAAQ,EAAE,CAAC,IAAI;GACpD,KAAKA,SAAS,UAAU,KAAK,IAAI,GAAG,CAAC;EACvC;CAEJ;;CAGA,SAAS,WAA2B;EAClC,MAAM,SAASD,cAAAA,aAAa,SAAS;EACrC,OAAO,KAAKE,WAAW,MAAM;CAC/B;;CAGA,gBAAgB,MAAsB;EACpC,OAAO,KAAKA,WAAW,IAAI;CAC7B;CAEA,WAAW,KAAqB;EAC9B,MAAM,IAAI,KAAKD,SAAS,QAAQ;EAChC,KAAKA,SAAS,OAAO,IAAI;EACzB,OAAO,MAAM,IAAI,MAAM,GAAG,MAAM;CAClC;AACF"}

package/build/queries/sql/AliasAssigner.d.cts

@@ -0,0 +1,13 @@
+import { ParsedFindQuery } from "../find/QueryParser.cjs";
+//#region src/queries/sql/AliasAssigner.d.ts
+declare class AliasAssigner {
+  #private;
+  constructor(query?: ParsedFindQuery);
+  /** Returns an abbreviated alias for a table name, e.g. `"books"` → `"b"`, `"book_reviews"` → `"br"`. */
+  getAlias(tableName: string): string;
+  /** Returns an alias using the name as-is (no abbreviation), e.g. `"prequel"` → `"prequel"`. */
+  getLiteralAlias(name: string): string;
+}
+//#endregion
+export { AliasAssigner };
+//# sourceMappingURL=AliasAssigner.d.cts.map

package/build/queries/sql/AliasAssigner.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AliasAssigner.d.cts","names":[],"sources":["../../../src/queries/sql/AliasAssigner.ts"],"mappings":";;cAGa;;EAGX,YAAY,QAAQ;;EAiBpB,SAAS;;EAMT,gBAAgB"}

package/build/queries/sql/AliasAssigner.d.mts

@@ -0,0 +1,13 @@
+import { ParsedFindQuery } from "../find/QueryParser.mjs";
+//#region src/queries/sql/AliasAssigner.d.ts
+declare class AliasAssigner {
+  #private;
+  constructor(query?: ParsedFindQuery);
+  /** Returns an abbreviated alias for a table name, e.g. `"books"` → `"b"`, `"book_reviews"` → `"br"`. */
+  getAlias(tableName: string): string;
+  /** Returns an alias using the name as-is (no abbreviation), e.g. `"prequel"` → `"prequel"`. */
+  getLiteralAlias(name: string): string;
+}
+//#endregion
+export { AliasAssigner };
+//# sourceMappingURL=AliasAssigner.d.mts.map

package/build/queries/sql/AliasAssigner.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AliasAssigner.d.mts","names":[],"sources":["../../../src/queries/sql/AliasAssigner.ts"],"mappings":";;cAGa;;EAGX,YAAY,QAAQ;;EAiBpB,SAAS;;EAMT,gBAAgB"}

package/build/queries/sql/AliasAssigner.js

@@ -0,0 +1,34 @@
+import { abbreviation } from "../../utils.js";
+//#region src/queries/sql/AliasAssigner.ts
+var AliasAssigner = class {
+	#aliases = {};
+	constructor(query) {
+		this.getAlias = this.getAlias.bind(this);
+		this.getLiteralAlias = this.getLiteralAlias.bind(this);
+		if (query) for (const table of query.tables) {
+			if (table.alias.includes("_")) continue;
+			const abbrev = abbreviation(table.table);
+			const i = this.#aliases[abbrev] || 0;
+			const j = Number(table.alias.replace(abbrev, "")) + 1;
+			this.#aliases[abbrev] = Math.max(i, j);
+		}
+	}
+	/** Returns an abbreviated alias for a table name, e.g. `"books"` → `"b"`, `"book_reviews"` → `"br"`. */
+	getAlias(tableName) {
+		const abbrev = abbreviation(tableName);
+		return this.#nextAlias(abbrev);
+	}
+	/** Returns an alias using the name as-is (no abbreviation), e.g. `"prequel"` → `"prequel"`. */
+	getLiteralAlias(name) {
+		return this.#nextAlias(name);
+	}
+	#nextAlias(key) {
+		const i = this.#aliases[key] || 0;
+		this.#aliases[key] = i + 1;
+		return i === 0 ? key : `${key}${i}`;
+	}
+};
+//#endregion
+export { AliasAssigner };
+
+//# sourceMappingURL=AliasAssigner.js.map

package/build/queries/sql/AliasAssigner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AliasAssigner.js","names":["#aliases","#nextAlias"],"sources":["../../../src/queries/sql/AliasAssigner.ts"],"sourcesContent":["import { abbreviation } from \"../../utils.ts\";\nimport type { ParsedFindQuery } from \"../find/QueryParser.ts\";\n\nexport class AliasAssigner {\n  #aliases: Record<string, number> = {};\n\n  constructor(query?: ParsedFindQuery) {\n    this.getAlias = this.getAlias.bind(this);\n    this.getLiteralAlias = this.getLiteralAlias.bind(this);\n    // If we're assigning aliases into an existing query, get the current assignments\n    if (query) {\n      for (const table of query.tables) {\n        // Ignore CTI base/sub aliases\n        if (table.alias.includes(\"_\")) continue;\n        const abbrev = abbreviation(table.table);\n        const i = this.#aliases[abbrev] || 0;\n        const j = Number(table.alias.replace(abbrev, \"\")) + 1;\n        this.#aliases[abbrev] = Math.max(i, j);\n      }\n    }\n  }\n\n  /** Returns an abbreviated alias for a table name, e.g. `\"books\"` → `\"b\"`, `\"book_reviews\"` → `\"br\"`. */\n  getAlias(tableName: string): string {\n    const abbrev = abbreviation(tableName);\n    return this.#nextAlias(abbrev);\n  }\n\n  /** Returns an alias using the name as-is (no abbreviation), e.g. `\"prequel\"` → `\"prequel\"`. */\n  getLiteralAlias(name: string): string {\n    return this.#nextAlias(name);\n  }\n\n  #nextAlias(key: string): string {\n    const i = this.#aliases[key] || 0;\n    this.#aliases[key] = i + 1;\n    return i === 0 ? key : `${key}${i}`;\n  }\n}\n"],"mappings":";;AAGA,IAAa,gBAAb,MAA2B;CACzB,WAAmC,CAAC;CAEpC,YAAY,OAAyB;EACnC,KAAK,WAAW,KAAK,SAAS,KAAK,IAAI;EACvC,KAAK,kBAAkB,KAAK,gBAAgB,KAAK,IAAI;EAErD,IAAI,OACF,KAAK,MAAM,SAAS,MAAM,QAAQ;GAEhC,IAAI,MAAM,MAAM,SAAS,GAAG,GAAG;GAC/B,MAAM,SAAS,aAAa,MAAM,KAAK;GACvC,MAAM,IAAI,KAAKA,SAAS,WAAW;GACnC,MAAM,IAAI,OAAO,MAAM,MAAM,QAAQ,QAAQ,EAAE,CAAC,IAAI;GACpD,KAAKA,SAAS,UAAU,KAAK,IAAI,GAAG,CAAC;EACvC;CAEJ;;CAGA,SAAS,WAA2B;EAClC,MAAM,SAAS,aAAa,SAAS;EACrC,OAAO,KAAKC,WAAW,MAAM;CAC/B;;CAGA,gBAAgB,MAAsB;EACpC,OAAO,KAAKA,WAAW,IAAI;CAC7B;CAEA,WAAW,KAAqB;EAC9B,MAAM,IAAI,KAAKD,SAAS,QAAQ;EAChC,KAAKA,SAAS,OAAO,IAAI;EACzB,OAAO,MAAM,IAAI,MAAM,GAAG,MAAM;CAClC;AACF"}

package/build/queries/sql/Expr.cjs

@@ -0,0 +1,512 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_queries_sql_keywords = require("./keywords.cjs");
+const require_queries_skipCondition = require("../skipCondition.cjs");
+const require_queries_conditions = require("../conditions.cjs");
+const require_serde_TypeInfo = require("../../serde/TypeInfo.cjs");
+//#region src/queries/sql/Expr.ts
+/**
+* The shared expression protocol for `em.query`.
+*
+* Table columns (`a.first_name`), aggregates (`b.id.count()`), `sql` templates, subquery columns
+* (`bookStats.bookCount`), and scalar subqueries all implement it, so any of them can appear in
+* `select`, `where`, `groupBy`, `having`, `orderBy`, and inside other expressions.
+*
+* This module is a leaf on purpose: `Tables.ts` extends `BaseExpr` at load time, so nothing here may
+* import (at runtime) a module that leads back to `Tables.ts`. Anything that needs metadata, alias
+* binding, or SQL generation for conditions is reached through the `ExprContext` the query parser passes in.
+*/
+const exprBrand = Symbol("joist.expr");
+function isExpr(value) {
+	return typeof value === "object" && value !== null && exprBrand in value;
+}
+/** Every `Expr` is a `BaseExpr` at runtime; this cast keeps `isExpr` a plain type guard so unions narrow. */
+function asNode(expr) {
+	return expr;
+}
+const deferredSym = Symbol("joist.deferredCondition");
+function isDeferredCondition(cond) {
+	return typeof cond === "object" && cond !== null && deferredSym in cond;
+}
+/** Creates a `DeferredCondition` that generates its SQL with `fn` once the query's aliases are known. */
+function deferredCondition(fn) {
+	const cond = require_queries_conditions.brandPredicate({
+		kind: "raw",
+		aliases: [],
+		condition: "<unresolved>",
+		bindings: [],
+		pruneable: false,
+		[deferredSym]: (ctx) => {
+			const { sql, bindings, refs } = fn(ctx);
+			return {
+				...cond,
+				condition: sql,
+				bindings,
+				aliases: refs
+			};
+		}
+	}, "sql");
+	return cond;
+}
+/**
+* Resolve each condition occurrence and snapshot it before resolving the next one. A nested subquery
+* may reuse the same condition under another alias; it must not overwrite this occurrence's SQL.
+*/
+function resolveDeferredConditions(cond, ctx) {
+	if (cond === void 0 || cond === null) return cond;
+	if (isDeferredCondition(cond)) return cond[deferredSym](ctx);
+	else if ("and" in cond && cond.and) return {
+		...cond,
+		and: cond.and.map((c) => resolveDeferredConditions(c, ctx))
+	};
+	else if ("or" in cond && cond.or) return {
+		...cond,
+		or: cond.or.map((c) => resolveDeferredConditions(c, ctx))
+	};
+	return cond;
+}
+/** Concatenates SQL fragments with `sep`, keeping bindings and refs in order. */
+function joinFragments(parts, sep) {
+	return {
+		sql: parts.map((p) => p.sql).join(sep),
+		bindings: parts.flatMap((p) => p.bindings),
+		refs: parts.flatMap((p) => p.refs)
+	};
+}
+/**
+* The methods every expression shares. Subclasses provide `toSql`, and usually `decode`/`encode`.
+*
+* Table columns can override comparisons to apply column-specific conversions. Domain aliases do not
+* implement this protocol.
+*/
+var BaseExpr = class {
+	[exprBrand] = this;
+	/** Only an actual scalar/IN subquery exposes its selected expression, not an ordinary ID expression. */
+	get subquerySelect() {}
+	/** Known SQL representation and logical domain; raw SQL and unmodeled refs remain unknown. */
+	get outputType() {}
+	/** Physical SQL nullability; undefined means unknown, not a NOT NULL guarantee. */
+	get sqlNullable() {}
+	/** The source of a direct column reference, whose value becomes NULL under an unmatched LEFT join. */
+	get sqlSource() {}
+	/** Produces the SQL without the outer parens a subquery normally gets; only differs for subqueries. */
+	toSqlBare(ctx) {
+		return this.toSql(ctx);
+	}
+	/** Converts a result-set value into the domain value, i.e. an int into a tagged id. */
+	decode(value) {
+		return value;
+	}
+	/** Converts a domain value into the database value, i.e. a tagged id into an int, for bindings. */
+	encode(value) {
+		return value;
+	}
+	eq(value) {
+		return this.compare("=", value);
+	}
+	ne(value) {
+		return this.compare("!=", value);
+	}
+	gt(value) {
+		return this.compare(">", value);
+	}
+	gte(value) {
+		return this.compare(">=", value);
+	}
+	lt(value) {
+		return this.compare("<", value);
+	}
+	lte(value) {
+		return this.compare("<=", value);
+	}
+	in(values) {
+		return this.inList("IN", values);
+	}
+	nin(values) {
+		return this.inList("NOT IN", values);
+	}
+	/** Prefixes this expression to a SQL template, retaining bindings and referenced aliases. */
+	is(strings, ...values) {
+		const suffix = new TemplateExpr(strings, values);
+		return deferredCondition((ctx) => joinFragments([this.toSql(ctx), suffix.toSql(ctx)], " "));
+	}
+	count() {
+		return new FnExpr("count", [this], {
+			suffix: "::int",
+			decode: decodeNumber,
+			encode: identity,
+			outputType: {
+				dbType: "int4",
+				domain: Number,
+				arrayElementSafe: true
+			}
+		});
+	}
+	countDistinct() {
+		return new FnExpr("count", [this], {
+			prefix: "DISTINCT ",
+			suffix: "::int",
+			decode: decodeNumber,
+			encode: identity,
+			outputType: {
+				dbType: "int4",
+				domain: Number,
+				arrayElementSafe: true
+			}
+		});
+	}
+	sum() {
+		return new FnExpr("sum", [this], {
+			decode: decodeNumber,
+			encode: identity,
+			outputType: numericAggregateOutputType("sum", this.outputType)
+		});
+	}
+	avg() {
+		return new FnExpr("avg", [this], {
+			decode: decodeNumber,
+			encode: identity,
+			outputType: numericAggregateOutputType("avg", this.outputType)
+		});
+	}
+	min() {
+		return new FnExpr("min", [this], {
+			decode: (v) => this.decode(v),
+			outputType: minMaxOutputType(this.outputType)
+		});
+	}
+	max() {
+		return new FnExpr("max", [this], {
+			decode: (v) => this.decode(v),
+			outputType: minMaxOutputType(this.outputType)
+		});
+	}
+	arrayAgg(options) {
+		return new FnExpr("array_agg", [this], {
+			prefix: options?.distinct ? "DISTINCT " : void 0,
+			aggregate: options,
+			decode: (v) => Array.isArray(v) ? v.map((e) => this.decode(e)) : v,
+			encode: (v) => Array.isArray(v) ? v.map((e) => this.encode(e)) : v,
+			outputType: require_serde_TypeInfo.arrayOutputType(this.outputType)
+		});
+	}
+	stringAgg(delimiter) {
+		return new FnExpr("string_agg", [this, new BindingExpr(delimiter)], { outputType: this.outputType?.domain === String ? {
+			dbType: "text",
+			domain: String,
+			arrayElementSafe: true
+		} : void 0 });
+	}
+	coalesce(fallback) {
+		return new FnExpr("coalesce", [this, new BindingExpr(this.encode(fallback))], {
+			decode: (v) => this.decode(v),
+			outputType: this.outputType
+		});
+	}
+	/** `this op value`, where `value` may be `undefined` (pruned), `null`, another expression, or a literal. */
+	compare(op, value) {
+		if (value === void 0) return require_queries_skipCondition.skipCondition;
+		if (value === null) {
+			const not = op === "=" ? "" : op === "!=" ? "NOT " : fail(`Cannot compare ${op} to null`);
+			return deferredCondition((ctx) => {
+				const left = this.toSql(ctx);
+				return {
+					...left,
+					sql: `${left.sql} IS ${not}NULL`
+				};
+			});
+		}
+		if (isExpr(value)) return deferredCondition((ctx) => joinFragments([this.toSql(ctx), asNode(value).toSql(ctx)], ` ${op} `));
+		return deferredCondition((ctx) => {
+			const left = this.toSql(ctx);
+			return {
+				sql: `${left.sql} ${op} ?`,
+				bindings: [...left.bindings, this.encode(value)],
+				refs: left.refs
+			};
+		});
+	}
+	/** `this IN (subquery)` or `this = ANY(?)` for a list; `NOT IN` / `!= ALL(?)` for `nin`. */
+	inList(op, values) {
+		if (values === void 0) return require_queries_skipCondition.skipCondition;
+		if (isExpr(values)) return deferredCondition((ctx) => {
+			const left = this.toSql(ctx);
+			const right = asNode(values).toSqlBare(ctx);
+			return joinFragments([left, {
+				...right,
+				sql: `(${right.sql})`
+			}], ` ${op} `);
+		});
+		if (!Array.isArray(values)) fail(`Expected an array or subquery for ${op}, got ${values}`);
+		const fn = op === "IN" ? "= ANY(?)" : "!= ALL(?)";
+		return deferredCondition((ctx) => {
+			const left = this.toSql(ctx);
+			return {
+				sql: `${left.sql} ${fn}`,
+				bindings: [...left.bindings, values.map((v) => this.encode(v))],
+				refs: left.refs
+			};
+		});
+	}
+};
+/**
+* A SQL function applied to expressions, i.e. `count(a."id")::int` or `coalesce(bs."n", ?)`.
+*
+* By default decoding is identity and encoding follows the first argument. Callers explicitly supply
+* a decoder and output type when needed (`max(a.id)` is still an id); numeric aggregates supply their
+* own decoder/encoder, since `count(a.id)` is a number, not an id. Unknown functions have no output type.
+*/
+var FnExpr = class extends BaseExpr {
+	name;
+	args;
+	opts;
+	constructor(name, args, opts) {
+		super();
+		this.name = name;
+		this.args = args;
+		this.opts = opts;
+	}
+	get outputType() {
+		return this.opts.outputType;
+	}
+	get sqlNullable() {
+		switch (this.name) {
+			case "count": return false;
+			case "sum":
+			case "avg":
+			case "min":
+			case "max":
+			case "array_agg":
+			case "string_agg": return true;
+			case "coalesce": return this.args[1]?.sqlNullable === false ? false : void 0;
+			default: return;
+		}
+	}
+	/**
+	* Renders function arguments, aggregate ordering, and the filter in SQL binding order.
+	* Keep references from all three so aggregate-only joins are retained.
+	*/
+	toSql(ctx) {
+		const args = joinFragments(this.args.map((a) => a.toSql(ctx)), ", ");
+		const ordering = joinFragments((this.opts.aggregate?.orderBy ?? []).flatMap((entry) => {
+			if (entry === void 0) return [];
+			const fragment = orderByToSql(entry, ctx);
+			return fragment ? [fragment] : [];
+		}), ", ");
+		const filter = this.opts.aggregate?.filter;
+		const condition = filter === void 0 ? void 0 : ctx.conditionToSql(filter);
+		return {
+			sql: `${this.name}(${this.opts.prefix ?? ""}${args.sql}${ordering.sql ? ` ORDER BY ${ordering.sql}` : ""})${condition ? ` FILTER (WHERE ${condition.sql})` : ""}${this.opts.suffix ?? ""}`,
+			bindings: [
+				...args.bindings,
+				...ordering.bindings,
+				...condition?.bindings ?? []
+			],
+			refs: [
+				...args.refs,
+				...ordering.refs,
+				...condition?.refs ?? []
+			]
+		};
+	}
+	decode(value) {
+		if (value === null || value === void 0) return value;
+		return this.opts.decode ? this.opts.decode(value) : value;
+	}
+	encode(value) {
+		return this.opts.encode ? this.opts.encode(value) : this.args[0].encode(value);
+	}
+};
+/** A bound literal, i.e. the `?` in `coalesce(x, ?)`. */
+var BindingExpr = class extends BaseExpr {
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	get sqlNullable() {
+		return this.value === null || this.value === void 0;
+	}
+	toSql() {
+		return {
+			sql: "?",
+			bindings: [this.value],
+			refs: []
+		};
+	}
+};
+/** An unmodeled column on a known source, i.e. `sql.ref(a, "ts_search")`; untracked at the type level. */
+var RefExpr = class extends BaseExpr {
+	handle;
+	column;
+	constructor(handle, column) {
+		super();
+		this.handle = handle;
+		this.column = column;
+	}
+	get sqlSource() {
+		return this.handle;
+	}
+	toSql(ctx) {
+		const alias = ctx.aliasFor(this.handle);
+		return {
+			sql: `${require_queries_sql_keywords.safeKq(alias)}.${require_queries_sql_keywords.safeKq(this.column)}`,
+			bindings: [],
+			refs: [alias]
+		};
+	}
+};
+/**
+* A `sql` tagged template.
+*
+* For an Author table `a` assigned the SQL alias `a1`:
+*
+* ```ts
+* sql`${a.age} * 2`     // Expression: a1.age * 2
+* sql`${a.age.gte(18)}` // Condition: (a1.age >= ?), bindings [18]
+* sql`${"Alice"}`      // Value: ?, bindings ["Alice"]
+* ```
+*/
+var TemplateExpr = class extends BaseExpr {
+	strings;
+	values;
+	constructor(strings, values) {
+		super();
+		this.strings = strings;
+		this.values = values;
+	}
+	toSql(ctx) {
+		const parts = [];
+		this.strings.forEach((s, i) => {
+			parts.push({
+				sql: s,
+				bindings: [],
+				refs: []
+			});
+			if (i < this.values.length) parts.push(interpolationToSql(this.values[i], ctx));
+		});
+		return joinFragments(parts, "");
+	}
+};
+/** Turns one `${...}` of a `sql` template into SQL: an expression, a condition, or a bound value. */
+function interpolationToSql(value, ctx) {
+	if (isExpr(value)) return asNode(value).toSql(ctx);
+	else if (isConditionLike(value)) return ctx.conditionToSql(value) ?? {
+		sql: "true",
+		bindings: [],
+		refs: []
+	};
+	else return {
+		sql: "?",
+		bindings: [value],
+		refs: []
+	};
+}
+/** True for the user-facing condition shapes: `{ and }`, `{ or }`, `ColumnCondition`, `RawCondition`. */
+function isConditionLike(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const v = value;
+	return "and" in v || "or" in v || v.kind === "column" || v.kind === "raw" || v.kind === "exists";
+}
+/**
+* Resolves the SQL result type of supported numeric aggregates; other overloads remain unknown.
+*
+* I.e. `a.age.sum()` has `dbType: "int8"` and Number conversion, while `a.age` has `dbType: "int4"`
+* and identity conversion. Their number domains agree, but SQL types reject a union in either order.
+*/
+function numericAggregateOutputType(name, outputType) {
+	switch (outputType?.dbType) {
+		case "int2":
+		case "int4": return {
+			dbType: name === "sum" ? "int8" : "numeric",
+			domain: Number,
+			arrayElementSafe: true
+		};
+		case "int8":
+		case "numeric": return {
+			dbType: "numeric",
+			domain: Number,
+			arrayElementSafe: true
+		};
+		case "float4": return {
+			dbType: name === "sum" ? "float4" : "float8",
+			domain: Number,
+			arrayElementSafe: true
+		};
+		case "float8": return {
+			dbType: "float8",
+			domain: Number,
+			arrayElementSafe: true
+		};
+		default: return;
+	}
+}
+/** Only known MIN/MAX overloads have predictable output types; varchar/name use the text overload. */
+function minMaxOutputType(outputType) {
+	switch (outputType?.dbType) {
+		case "varchar":
+		case "name": return {
+			...outputType,
+			dbType: "text"
+		};
+		case "int2":
+		case "int4":
+		case "int8":
+		case "numeric":
+		case "float4":
+		case "float8":
+		case "text":
+		case "bpchar":
+		case "date":
+		case "time":
+		case "timetz":
+		case "timestamp":
+		case "timestamptz":
+		case "interval":
+		case "money":
+		case "inet": return outputType;
+		default: return;
+	}
+}
+/** Decodes `count`/`sum`/`avg` results, which Postgres returns as strings for bigint/numeric. */
+function decodeNumber(value) {
+	return typeof value === "string" ? Number(value) : value;
+}
+/** Renders an expression order for either a query or an aggregate, or prunes an undefined order. */
+function orderByToSql(o, ctx) {
+	if (!(o.sort instanceof BaseExpr)) return fail("orderBy must be an expression, i.e. a table column, aggregate, sql`...`, or scalar query(...)");
+	if (Object.keys(o).some((key) => key !== "sort" && key !== "order" && key !== "nulls")) return fail("Expression orderBy entries only accept sort, order, and nulls");
+	if (o.order === void 0) return void 0;
+	if (o.order !== "ASC" && o.order !== "DESC") return fail(`Invalid orderBy direction '${o.order}'`);
+	if (o.nulls !== void 0 && o.nulls !== "first" && o.nulls !== "last") return fail(`Invalid orderBy nulls '${o.nulls}'`);
+	const fragment = o.sort.toSql(ctx);
+	const nulls = o.nulls ? ` NULLS ${o.nulls.toUpperCase()}` : "";
+	return {
+		...fragment,
+		sql: `${fragment.sql} ${o.order}${nulls}`
+	};
+}
+function identity(value) {
+	return value;
+}
+function fail(message) {
+	throw new Error(message);
+}
+//#endregion
+exports.BaseExpr = BaseExpr;
+exports.BindingExpr = BindingExpr;
+exports.FnExpr = FnExpr;
+exports.RefExpr = RefExpr;
+exports.TemplateExpr = TemplateExpr;
+exports.asNode = asNode;
+exports.deferredCondition = deferredCondition;
+exports.deferredSym = deferredSym;
+exports.exprBrand = exprBrand;
+exports.interpolationToSql = interpolationToSql;
+exports.isConditionLike = isConditionLike;
+exports.isDeferredCondition = isDeferredCondition;
+exports.isExpr = isExpr;
+exports.joinFragments = joinFragments;
+exports.orderByToSql = orderByToSql;
+exports.resolveDeferredConditions = resolveDeferredConditions;
+
+//# sourceMappingURL=Expr.cjs.map