joist-core 2.3.0 → 2.4.0

package/build/queries/sql/expressions/least.d.mts

@@ -0,0 +1,21 @@
+import { ParsedExpression, ResultCodec } from "./types.mjs";
+import { ExprContext, SqlFragment } from "../Expr.mjs";
+//#region src/queries/sql/expressions/least.d.ts
+/** Values whose smallest non-null member is selected by PostgreSQL. */
+interface LeastInput {
+  readonly least: readonly unknown[];
+}
+/** A LEAST comparison with at least one value. */
+interface ParsedLeastExpression {
+  kind: "least";
+  values: [ParsedExpression, ...ParsedExpression[]];
+}
+/** Parses LEAST values and requires at least one operand. */
+declare function parseLeastExpression(input: unknown): ParsedLeastExpression;
+/** Renders the values compared by LEAST. */
+declare function leastToSql(parsed: ParsedLeastExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment;
+/** LEAST ignores nulls, so one non-null value guarantees a non-null result. */
+declare function leastNullable(parsed: ParsedLeastExpression): boolean | undefined;
+//#endregion
+export { LeastInput, ParsedLeastExpression, leastNullable, leastToSql, parseLeastExpression };
+//# sourceMappingURL=least.d.mts.map

package/build/queries/sql/expressions/least.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"least.d.mts","names":[],"sources":["../../../../src/queries/sql/expressions/least.ts"],"mappings":";;;;UAMiB;WACN;;;UAIM;EACf;EACA,SAAS,qBAAqB;;;iBAIhB,qBAAqB,iBAAiB;;iBAKtC,WAAW,QAAQ,uBAAuB,KAAK,aAAa,OAAO,cAAc;;iBAKjF,cAAc,QAAQ"}

package/build/queries/sql/expressions/least.js

@@ -0,0 +1,22 @@
+import { parseNonEmptyOperands } from "./parseExpression.js";
+import { expressionNullable, functionToSql } from "./expression.js";
+//#region src/queries/sql/expressions/least.ts
+/** Parses LEAST values and requires at least one operand. */
+function parseLeastExpression(input) {
+	return {
+		kind: "least",
+		values: parseNonEmptyOperands(input, "LEAST")
+	};
+}
+/** Renders the values compared by LEAST. */
+function leastToSql(parsed, ctx, codec) {
+	return functionToSql("LEAST", parsed.values, ctx, codec);
+}
+/** LEAST ignores nulls, so one non-null value guarantees a non-null result. */
+function leastNullable(parsed) {
+	return parsed.values.some((value) => expressionNullable(value) === false) ? false : void 0;
+}
+//#endregion
+export { leastNullable, leastToSql, parseLeastExpression };
+
+//# sourceMappingURL=least.js.map

package/build/queries/sql/expressions/least.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"least.js","names":[],"sources":["../../../../src/queries/sql/expressions/least.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"src/queries/sql/Expr.ts\";\nimport { expressionNullable, functionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { parseNonEmptyOperands } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** Values whose smallest non-null member is selected by PostgreSQL. */\nexport interface LeastInput {\n  readonly least: readonly unknown[];\n}\n\n/** A LEAST comparison with at least one value. */\nexport interface ParsedLeastExpression {\n  kind: \"least\";\n  values: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses LEAST values and requires at least one operand. */\nexport function parseLeastExpression(input: unknown): ParsedLeastExpression {\n  return { kind: \"least\", values: parseNonEmptyOperands(input, \"LEAST\") };\n}\n\n/** Renders the values compared by LEAST. */\nexport function leastToSql(parsed: ParsedLeastExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"LEAST\", parsed.values, ctx, codec);\n}\n\n/** LEAST ignores nulls, so one non-null value guarantees a non-null result. */\nexport function leastNullable(parsed: ParsedLeastExpression): boolean | undefined {\n  return parsed.values.some((value) => expressionNullable(value) === false) ? false : undefined;\n}\n"],"mappings":";;;;AAiBA,SAAgB,qBAAqB,OAAuC;CAC1E,OAAO;EAAE,MAAM;EAAS,QAAQ,sBAAsB,OAAO,OAAO;CAAE;AACxE;;AAGA,SAAgB,WAAW,QAA+B,KAAkB,OAAiC;CAC3G,OAAO,cAAc,SAAS,OAAO,QAAQ,KAAK,KAAK;AACzD;;AAGA,SAAgB,cAAc,QAAoD;CAChF,OAAO,OAAO,OAAO,MAAM,UAAU,mBAAmB,KAAK,MAAM,KAAK,IAAI,QAAQ,KAAA;AACtF"}

package/build/queries/sql/expressions/nullIf.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_queries_sql_expressions_parseExpression = require("./parseExpression.cjs");
+const require_queries_sql_expressions_expression = require("./expression.cjs");
+//#region src/queries/sql/expressions/nullIf.ts
+/** Parses exactly two NULLIF operands into their distinct roles. */
+function parseNullIfExpression(input) {
+	if (!Array.isArray(input) || input.length !== 2) throw new Error("NULLIF needs exactly two values");
+	return {
+		kind: "nullIf",
+		value: require_queries_sql_expressions_parseExpression.parseExpression(input[0]),
+		equals: require_queries_sql_expressions_parseExpression.parseExpression(input[1])
+	};
+}
+/** Renders the returned value before its equality comparison operand. */
+function nullIfToSql(parsed, ctx, codec) {
+	return require_queries_sql_expressions_expression.functionToSql("NULLIF", [parsed.value, parsed.equals], ctx, codec);
+}
+/** NULLIF can return SQL NULL when its operands match. */
+function nullIfNullable() {
+	return true;
+}
+//#endregion
+exports.nullIfNullable = nullIfNullable;
+exports.nullIfToSql = nullIfToSql;
+exports.parseNullIfExpression = parseNullIfExpression;
+
+//# sourceMappingURL=nullIf.cjs.map

package/build/queries/sql/expressions/nullIf.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullIf.cjs","names":["parseExpression","functionToSql"],"sources":["../../../../src/queries/sql/expressions/nullIf.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"src/queries/sql/Expr.ts\";\nimport { functionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { parseExpression } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** A value and the value it must equal for NULLIF to return SQL NULL. */\nexport interface NullIfInput {\n  readonly nullIf: readonly unknown[];\n}\n\n/** NULLIF returns value unless it matches equals. */\nexport interface ParsedNullIfExpression {\n  kind: \"nullIf\";\n  value: ParsedExpression;\n  equals: ParsedExpression;\n}\n\n/** Parses exactly two NULLIF operands into their distinct roles. */\nexport function parseNullIfExpression(input: unknown): ParsedNullIfExpression {\n  if (!Array.isArray(input) || input.length !== 2) throw new Error(\"NULLIF needs exactly two values\");\n  return { kind: \"nullIf\", value: parseExpression(input[0]), equals: parseExpression(input[1]) };\n}\n\n/** Renders the returned value before its equality comparison operand. */\nexport function nullIfToSql(parsed: ParsedNullIfExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"NULLIF\", [parsed.value, parsed.equals], ctx, codec);\n}\n\n/** NULLIF can return SQL NULL when its operands match. */\nexport function nullIfNullable(): true {\n  return true;\n}\n"],"mappings":";;;;;AAkBA,SAAgB,sBAAsB,OAAwC;CAC5E,IAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,iCAAiC;CAClG,OAAO;EAAE,MAAM;EAAU,OAAOA,gDAAAA,gBAAgB,MAAM,EAAE;EAAG,QAAQA,gDAAAA,gBAAgB,MAAM,EAAE;CAAE;AAC/F;;AAGA,SAAgB,YAAY,QAAgC,KAAkB,OAAiC;CAC7G,OAAOC,2CAAAA,cAAc,UAAU,CAAC,OAAO,OAAO,OAAO,MAAM,GAAG,KAAK,KAAK;AAC1E;;AAGA,SAAgB,iBAAuB;CACrC,OAAO;AACT"}

package/build/queries/sql/expressions/nullIf.d.cts

@@ -0,0 +1,22 @@
+import { ParsedExpression, ResultCodec } from "./types.cjs";
+import { ExprContext, SqlFragment } from "../Expr.cjs";
+//#region src/queries/sql/expressions/nullIf.d.ts
+/** A value and the value it must equal for NULLIF to return SQL NULL. */
+interface NullIfInput {
+  readonly nullIf: readonly unknown[];
+}
+/** NULLIF returns value unless it matches equals. */
+interface ParsedNullIfExpression {
+  kind: "nullIf";
+  value: ParsedExpression;
+  equals: ParsedExpression;
+}
+/** Parses exactly two NULLIF operands into their distinct roles. */
+declare function parseNullIfExpression(input: unknown): ParsedNullIfExpression;
+/** Renders the returned value before its equality comparison operand. */
+declare function nullIfToSql(parsed: ParsedNullIfExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment;
+/** NULLIF can return SQL NULL when its operands match. */
+declare function nullIfNullable(): true;
+//#endregion
+export { NullIfInput, ParsedNullIfExpression, nullIfNullable, nullIfToSql, parseNullIfExpression };
+//# sourceMappingURL=nullIf.d.cts.map

package/build/queries/sql/expressions/nullIf.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullIf.d.cts","names":[],"sources":["../../../../src/queries/sql/expressions/nullIf.ts"],"mappings":";;;;UAMiB;WACN;;;UAIM;EACf;EACA,OAAO;EACP,QAAQ;;;iBAIM,sBAAsB,iBAAiB;;iBAMvC,YAAY,QAAQ,wBAAwB,KAAK,aAAa,OAAO,cAAc;;iBAKnF"}

package/build/queries/sql/expressions/nullIf.d.mts

@@ -0,0 +1,22 @@
+import { ParsedExpression, ResultCodec } from "./types.mjs";
+import { ExprContext, SqlFragment } from "../Expr.mjs";
+//#region src/queries/sql/expressions/nullIf.d.ts
+/** A value and the value it must equal for NULLIF to return SQL NULL. */
+interface NullIfInput {
+  readonly nullIf: readonly unknown[];
+}
+/** NULLIF returns value unless it matches equals. */
+interface ParsedNullIfExpression {
+  kind: "nullIf";
+  value: ParsedExpression;
+  equals: ParsedExpression;
+}
+/** Parses exactly two NULLIF operands into their distinct roles. */
+declare function parseNullIfExpression(input: unknown): ParsedNullIfExpression;
+/** Renders the returned value before its equality comparison operand. */
+declare function nullIfToSql(parsed: ParsedNullIfExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment;
+/** NULLIF can return SQL NULL when its operands match. */
+declare function nullIfNullable(): true;
+//#endregion
+export { NullIfInput, ParsedNullIfExpression, nullIfNullable, nullIfToSql, parseNullIfExpression };
+//# sourceMappingURL=nullIf.d.mts.map

package/build/queries/sql/expressions/nullIf.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullIf.d.mts","names":[],"sources":["../../../../src/queries/sql/expressions/nullIf.ts"],"mappings":";;;;UAMiB;WACN;;;UAIM;EACf;EACA,OAAO;EACP,QAAQ;;;iBAIM,sBAAsB,iBAAiB;;iBAMvC,YAAY,QAAQ,wBAAwB,KAAK,aAAa,OAAO,cAAc;;iBAKnF"}

package/build/queries/sql/expressions/nullIf.js

@@ -0,0 +1,24 @@
+import { parseExpression } from "./parseExpression.js";
+import { functionToSql } from "./expression.js";
+//#region src/queries/sql/expressions/nullIf.ts
+/** Parses exactly two NULLIF operands into their distinct roles. */
+function parseNullIfExpression(input) {
+	if (!Array.isArray(input) || input.length !== 2) throw new Error("NULLIF needs exactly two values");
+	return {
+		kind: "nullIf",
+		value: parseExpression(input[0]),
+		equals: parseExpression(input[1])
+	};
+}
+/** Renders the returned value before its equality comparison operand. */
+function nullIfToSql(parsed, ctx, codec) {
+	return functionToSql("NULLIF", [parsed.value, parsed.equals], ctx, codec);
+}
+/** NULLIF can return SQL NULL when its operands match. */
+function nullIfNullable() {
+	return true;
+}
+//#endregion
+export { nullIfNullable, nullIfToSql, parseNullIfExpression };
+
+//# sourceMappingURL=nullIf.js.map

package/build/queries/sql/expressions/nullIf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullIf.js","names":[],"sources":["../../../../src/queries/sql/expressions/nullIf.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"src/queries/sql/Expr.ts\";\nimport { functionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { parseExpression } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** A value and the value it must equal for NULLIF to return SQL NULL. */\nexport interface NullIfInput {\n  readonly nullIf: readonly unknown[];\n}\n\n/** NULLIF returns value unless it matches equals. */\nexport interface ParsedNullIfExpression {\n  kind: \"nullIf\";\n  value: ParsedExpression;\n  equals: ParsedExpression;\n}\n\n/** Parses exactly two NULLIF operands into their distinct roles. */\nexport function parseNullIfExpression(input: unknown): ParsedNullIfExpression {\n  if (!Array.isArray(input) || input.length !== 2) throw new Error(\"NULLIF needs exactly two values\");\n  return { kind: \"nullIf\", value: parseExpression(input[0]), equals: parseExpression(input[1]) };\n}\n\n/** Renders the returned value before its equality comparison operand. */\nexport function nullIfToSql(parsed: ParsedNullIfExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"NULLIF\", [parsed.value, parsed.equals], ctx, codec);\n}\n\n/** NULLIF can return SQL NULL when its operands match. */\nexport function nullIfNullable(): true {\n  return true;\n}\n"],"mappings":";;;;AAkBA,SAAgB,sBAAsB,OAAwC;CAC5E,IAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,iCAAiC;CAClG,OAAO;EAAE,MAAM;EAAU,OAAO,gBAAgB,MAAM,EAAE;EAAG,QAAQ,gBAAgB,MAAM,EAAE;CAAE;AAC/F;;AAGA,SAAgB,YAAY,QAAgC,KAAkB,OAAiC;CAC7G,OAAO,cAAc,UAAU,CAAC,OAAO,OAAO,OAAO,MAAM,GAAG,KAAK,KAAK;AAC1E;;AAGA,SAAgB,iBAAuB;CACrC,OAAO;AACT"}

package/build/queries/sql/expressions/parseExpression.cjs

@@ -0,0 +1,75 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_queries_sql_Expr = require("../Expr.cjs");
+const require_utils = require("../../../utils.cjs");
+const require_queries_sql_expressions_case = require("./case.cjs");
+const require_queries_sql_expressions_coalesce = require("./coalesce.cjs");
+const require_queries_sql_expressions_greatest = require("./greatest.cjs");
+const require_queries_sql_expressions_least = require("./least.cjs");
+const require_queries_sql_expressions_nullIf = require("./nullIf.cjs");
+const require_queries_sql_expressions_arrayAgg = require("./arrayAgg.cjs");
+//#region src/queries/sql/expressions/parseExpression.ts
+const exprNames = [
+	"coalesce",
+	"nullIf",
+	"greatest",
+	"least"
+];
+/** Requires an expression object at the root before parsing its nested operands. */
+function parseExpressionInput(input) {
+	if (!isObject(input) || !("case" in input) && !("arrayAgg" in input) && !exprNames.some((name) => name in input)) throw new Error("expr expects an object with arrayAgg, case, coalesce, nullIf, greatest, or least");
+	return parseExpression(input);
+}
+/**
+* Parses expression inputs into a ParsedExpression, validating their shape and copying operand arrays.
+* Nested expressions stay together so their literals can use a column's codec from another branch.
+* I.e. COALESCE(Book.id, CASE ... THEN "b:9" END) must encode "b:9" as an integer.
+*/
+function parseExpression(input) {
+	if (input instanceof require_queries_sql_Expr.BaseExpr) return input;
+	if (input === void 0) throw new Error("Use null for a SQL NULL value");
+	const name = isObject(input) ? exprNames.find((name) => name in input) : void 0;
+	if (name && isObject(input)) {
+		checkKeys(input, [name]);
+		switch (name) {
+			case "coalesce": return require_queries_sql_expressions_coalesce.parseCoalesceExpression(input.coalesce);
+			case "nullIf": return require_queries_sql_expressions_nullIf.parseNullIfExpression(input.nullIf);
+			case "greatest": return require_queries_sql_expressions_greatest.parseGreatestExpression(input.greatest);
+			case "least": return require_queries_sql_expressions_least.parseLeastExpression(input.least);
+			default: return require_utils.assertNever(name);
+		}
+	}
+	if (isObject(input) && "arrayAgg" in input) {
+		checkKeys(input, ["arrayAgg"]);
+		return require_queries_sql_expressions_arrayAgg.parseArrayAggExpression(input.arrayAgg);
+	}
+	if (isObject(input) && "case" in input) {
+		checkKeys(input, ["case"]);
+		return require_queries_sql_expressions_case.parseCaseExpression(input.case);
+	}
+	return {
+		kind: "literal",
+		value: input
+	};
+}
+/** Validates and copies a nonempty operand array, preserving its first element in the parsed type. */
+function parseNonEmptyOperands(input, name) {
+	if (!Array.isArray(input) || input.length === 0) throw new Error(`${name} needs at least one value`);
+	const [first, ...rest] = input;
+	return [parseExpression(first), ...rest.map((operand) => parseExpression(operand))];
+}
+/** Rejects misspelled or mixed expression keys rather than silently ignoring them. */
+function checkKeys(value, allowed) {
+	for (const key of Reflect.ownKeys(value)) if (typeof key !== "string" || !allowed.includes(key)) throw new Error(`Unknown expression key '${String(key)}'`);
+}
+/** Narrows expression input objects without treating null as an object. */
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+exports.checkKeys = checkKeys;
+exports.isObject = isObject;
+exports.parseExpression = parseExpression;
+exports.parseExpressionInput = parseExpressionInput;
+exports.parseNonEmptyOperands = parseNonEmptyOperands;
+
+//# sourceMappingURL=parseExpression.cjs.map

package/build/queries/sql/expressions/parseExpression.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseExpression.cjs","names":["BaseExpr","parseCoalesceExpression","parseNullIfExpression","parseGreatestExpression","parseLeastExpression","assertNever","parseArrayAggExpression","parseCaseExpression"],"sources":["../../../../src/queries/sql/expressions/parseExpression.ts"],"sourcesContent":["import { BaseExpr } from \"src/queries/sql/Expr.ts\";\nimport { parseArrayAggExpression } from \"src/queries/sql/expressions/arrayAgg.ts\";\nimport { parseCaseExpression } from \"src/queries/sql/expressions/case.ts\";\nimport { parseCoalesceExpression } from \"src/queries/sql/expressions/coalesce.ts\";\nimport { parseGreatestExpression } from \"src/queries/sql/expressions/greatest.ts\";\nimport { parseLeastExpression } from \"src/queries/sql/expressions/least.ts\";\nimport { parseNullIfExpression } from \"src/queries/sql/expressions/nullIf.ts\";\nimport type { ExprName, ParsedExpression } from \"src/queries/sql/expressions/types.ts\";\nimport { assertNever } from \"src/utils.ts\";\n\n// These expressions take operand arrays; CASE uses WHEN/THEN entries instead.\nconst exprNames = [\"coalesce\", \"nullIf\", \"greatest\", \"least\"] as const satisfies readonly ExprName[];\n\n/** Requires an expression object at the root before parsing its nested operands. */\nexport function parseExpressionInput(input: unknown): ParsedExpression {\n  if (!isObject(input) || (!(\"case\" in input) && !(\"arrayAgg\" in input) && !exprNames.some((name) => name in input))) {\n    throw new Error(\"expr expects an object with arrayAgg, case, coalesce, nullIf, greatest, or least\");\n  }\n  return parseExpression(input);\n}\n\n/**\n * Parses expression inputs into a ParsedExpression, validating their shape and copying operand arrays.\n * Nested expressions stay together so their literals can use a column's codec from another branch.\n * I.e. COALESCE(Book.id, CASE ... THEN \"b:9\" END) must encode \"b:9\" as an integer.\n */\nexport function parseExpression(input: unknown): ParsedExpression {\n  if (input instanceof BaseExpr) return input;\n  if (input === undefined) throw new Error(\"Use null for a SQL NULL value\");\n  const name = isObject(input) ? exprNames.find((name) => name in input) : undefined;\n  if (name && isObject(input)) {\n    checkKeys(input, [name]);\n    switch (name) {\n      case \"coalesce\":\n        return parseCoalesceExpression(input.coalesce);\n      case \"nullIf\":\n        return parseNullIfExpression(input.nullIf);\n      case \"greatest\":\n        return parseGreatestExpression(input.greatest);\n      case \"least\":\n        return parseLeastExpression(input.least);\n      default:\n        return assertNever(name);\n    }\n  }\n  if (isObject(input) && \"arrayAgg\" in input) {\n    checkKeys(input, [\"arrayAgg\"]);\n    return parseArrayAggExpression(input.arrayAgg);\n  }\n  if (isObject(input) && \"case\" in input) {\n    checkKeys(input, [\"case\"]);\n    return parseCaseExpression(input.case);\n  }\n  return { kind: \"literal\", value: input };\n}\n\n/** Validates and copies a nonempty operand array, preserving its first element in the parsed type. */\nexport function parseNonEmptyOperands(input: unknown, name: string): [ParsedExpression, ...ParsedExpression[]] {\n  if (!Array.isArray(input) || input.length === 0) throw new Error(`${name} needs at least one value`);\n  // Validation above guarantees a first operand; keep that guarantee in the parsed type.\n  const [first, ...rest] = input;\n  return [parseExpression(first), ...rest.map((operand) => parseExpression(operand))];\n}\n\n/** Rejects misspelled or mixed expression keys rather than silently ignoring them. */\nexport function checkKeys(value: object, allowed: string[]): void {\n  for (const key of Reflect.ownKeys(value)) {\n    if (typeof key !== \"string\" || !allowed.includes(key)) throw new Error(`Unknown expression key '${String(key)}'`);\n  }\n}\n\n/** Narrows expression input objects without treating null as an object. */\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null;\n}\n"],"mappings":";;;;;;;;;;AAWA,MAAM,YAAY;CAAC;CAAY;CAAU;CAAY;AAAO;;AAG5D,SAAgB,qBAAqB,OAAkC;CACrE,IAAI,CAAC,SAAS,KAAK,KAAM,EAAE,UAAU,UAAU,EAAE,cAAc,UAAU,CAAC,UAAU,MAAM,SAAS,QAAQ,KAAK,GAC9G,MAAM,IAAI,MAAM,kFAAkF;CAEpG,OAAO,gBAAgB,KAAK;AAC9B;;;;;;AAOA,SAAgB,gBAAgB,OAAkC;CAChE,IAAI,iBAAiBA,yBAAAA,UAAU,OAAO;CACtC,IAAI,UAAU,KAAA,GAAW,MAAM,IAAI,MAAM,+BAA+B;CACxE,MAAM,OAAO,SAAS,KAAK,IAAI,UAAU,MAAM,SAAS,QAAQ,KAAK,IAAI,KAAA;CACzE,IAAI,QAAQ,SAAS,KAAK,GAAG;EAC3B,UAAU,OAAO,CAAC,IAAI,CAAC;EACvB,QAAQ,MAAR;GACE,KAAK,YACH,OAAOC,yCAAAA,wBAAwB,MAAM,QAAQ;GAC/C,KAAK,UACH,OAAOC,uCAAAA,sBAAsB,MAAM,MAAM;GAC3C,KAAK,YACH,OAAOC,yCAAAA,wBAAwB,MAAM,QAAQ;GAC/C,KAAK,SACH,OAAOC,sCAAAA,qBAAqB,MAAM,KAAK;GACzC,SACE,OAAOC,cAAAA,YAAY,IAAI;EAC3B;CACF;CACA,IAAI,SAAS,KAAK,KAAK,cAAc,OAAO;EAC1C,UAAU,OAAO,CAAC,UAAU,CAAC;EAC7B,OAAOC,yCAAAA,wBAAwB,MAAM,QAAQ;CAC/C;CACA,IAAI,SAAS,KAAK,KAAK,UAAU,OAAO;EACtC,UAAU,OAAO,CAAC,MAAM,CAAC;EACzB,OAAOC,qCAAAA,oBAAoB,MAAM,IAAI;CACvC;CACA,OAAO;EAAE,MAAM;EAAW,OAAO;CAAM;AACzC;;AAGA,SAAgB,sBAAsB,OAAgB,MAAyD;CAC7G,IAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,GAAG,KAAK,0BAA0B;CAEnG,MAAM,CAAC,OAAO,GAAG,QAAQ;CACzB,OAAO,CAAC,gBAAgB,KAAK,GAAG,GAAG,KAAK,KAAK,YAAY,gBAAgB,OAAO,CAAC,CAAC;AACpF;;AAGA,SAAgB,UAAU,OAAe,SAAyB;CAChE,KAAK,MAAM,OAAO,QAAQ,QAAQ,KAAK,GACrC,IAAI,OAAO,QAAQ,YAAY,CAAC,QAAQ,SAAS,GAAG,GAAG,MAAM,IAAI,MAAM,2BAA2B,OAAO,GAAG,EAAE,EAAE;AAEpH;;AAGA,SAAgB,SAAS,OAAkD;CACzE,OAAO,OAAO,UAAU,YAAY,UAAU;AAChD"}

package/build/queries/sql/expressions/parseExpression.d.cts

@@ -0,0 +1,19 @@
+import { ParsedExpression } from "./types.cjs";
+//#region src/queries/sql/expressions/parseExpression.d.ts
+/** Requires an expression object at the root before parsing its nested operands. */
+declare function parseExpressionInput(input: unknown): ParsedExpression;
+/**
+ * Parses expression inputs into a ParsedExpression, validating their shape and copying operand arrays.
+ * Nested expressions stay together so their literals can use a column's codec from another branch.
+ * I.e. COALESCE(Book.id, CASE ... THEN "b:9" END) must encode "b:9" as an integer.
+ */
+declare function parseExpression(input: unknown): ParsedExpression;
+/** Validates and copies a nonempty operand array, preserving its first element in the parsed type. */
+declare function parseNonEmptyOperands(input: unknown, name: string): [ParsedExpression, ...ParsedExpression[]];
+/** Rejects misspelled or mixed expression keys rather than silently ignoring them. */
+declare function checkKeys(value: object, allowed: string[]): void;
+/** Narrows expression input objects without treating null as an object. */
+declare function isObject(value: unknown): value is Record<string, unknown>;
+//#endregion
+export { checkKeys, isObject, parseExpression, parseExpressionInput, parseNonEmptyOperands };
+//# sourceMappingURL=parseExpression.d.cts.map

package/build/queries/sql/expressions/parseExpression.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseExpression.d.cts","names":[],"sources":["../../../../src/queries/sql/expressions/parseExpression.ts"],"mappings":";;;iBAcgB,qBAAqB,iBAAiB;;;;;;iBAYtC,gBAAgB,iBAAiB;;iBA+BjC,sBAAsB,gBAAgB,gBAAgB,qBAAqB;;iBAQ3E,UAAU,eAAe;;iBAOzB,SAAS,iBAAiB,SAAS"}

package/build/queries/sql/expressions/parseExpression.d.mts

@@ -0,0 +1,19 @@
+import { ParsedExpression } from "./types.mjs";
+//#region src/queries/sql/expressions/parseExpression.d.ts
+/** Requires an expression object at the root before parsing its nested operands. */
+declare function parseExpressionInput(input: unknown): ParsedExpression;
+/**
+ * Parses expression inputs into a ParsedExpression, validating their shape and copying operand arrays.
+ * Nested expressions stay together so their literals can use a column's codec from another branch.
+ * I.e. COALESCE(Book.id, CASE ... THEN "b:9" END) must encode "b:9" as an integer.
+ */
+declare function parseExpression(input: unknown): ParsedExpression;
+/** Validates and copies a nonempty operand array, preserving its first element in the parsed type. */
+declare function parseNonEmptyOperands(input: unknown, name: string): [ParsedExpression, ...ParsedExpression[]];
+/** Rejects misspelled or mixed expression keys rather than silently ignoring them. */
+declare function checkKeys(value: object, allowed: string[]): void;
+/** Narrows expression input objects without treating null as an object. */
+declare function isObject(value: unknown): value is Record<string, unknown>;
+//#endregion
+export { checkKeys, isObject, parseExpression, parseExpressionInput, parseNonEmptyOperands };
+//# sourceMappingURL=parseExpression.d.mts.map

package/build/queries/sql/expressions/parseExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseExpression.d.mts","names":[],"sources":["../../../../src/queries/sql/expressions/parseExpression.ts"],"mappings":";;;iBAcgB,qBAAqB,iBAAiB;;;;;;iBAYtC,gBAAgB,iBAAiB;;iBA+BjC,sBAAsB,gBAAgB,gBAAgB,qBAAqB;;iBAQ3E,UAAU,eAAe;;iBAOzB,SAAS,iBAAiB,SAAS"}

package/build/queries/sql/expressions/parseExpression.js

@@ -0,0 +1,70 @@
+import { BaseExpr } from "../Expr.js";
+import { assertNever } from "../../../utils.js";
+import { parseCaseExpression } from "./case.js";
+import { parseCoalesceExpression } from "./coalesce.js";
+import { parseGreatestExpression } from "./greatest.js";
+import { parseLeastExpression } from "./least.js";
+import { parseNullIfExpression } from "./nullIf.js";
+import { parseArrayAggExpression } from "./arrayAgg.js";
+//#region src/queries/sql/expressions/parseExpression.ts
+const exprNames = [
+	"coalesce",
+	"nullIf",
+	"greatest",
+	"least"
+];
+/** Requires an expression object at the root before parsing its nested operands. */
+function parseExpressionInput(input) {
+	if (!isObject(input) || !("case" in input) && !("arrayAgg" in input) && !exprNames.some((name) => name in input)) throw new Error("expr expects an object with arrayAgg, case, coalesce, nullIf, greatest, or least");
+	return parseExpression(input);
+}
+/**
+* Parses expression inputs into a ParsedExpression, validating their shape and copying operand arrays.
+* Nested expressions stay together so their literals can use a column's codec from another branch.
+* I.e. COALESCE(Book.id, CASE ... THEN "b:9" END) must encode "b:9" as an integer.
+*/
+function parseExpression(input) {
+	if (input instanceof BaseExpr) return input;
+	if (input === void 0) throw new Error("Use null for a SQL NULL value");
+	const name = isObject(input) ? exprNames.find((name) => name in input) : void 0;
+	if (name && isObject(input)) {
+		checkKeys(input, [name]);
+		switch (name) {
+			case "coalesce": return parseCoalesceExpression(input.coalesce);
+			case "nullIf": return parseNullIfExpression(input.nullIf);
+			case "greatest": return parseGreatestExpression(input.greatest);
+			case "least": return parseLeastExpression(input.least);
+			default: return assertNever(name);
+		}
+	}
+	if (isObject(input) && "arrayAgg" in input) {
+		checkKeys(input, ["arrayAgg"]);
+		return parseArrayAggExpression(input.arrayAgg);
+	}
+	if (isObject(input) && "case" in input) {
+		checkKeys(input, ["case"]);
+		return parseCaseExpression(input.case);
+	}
+	return {
+		kind: "literal",
+		value: input
+	};
+}
+/** Validates and copies a nonempty operand array, preserving its first element in the parsed type. */
+function parseNonEmptyOperands(input, name) {
+	if (!Array.isArray(input) || input.length === 0) throw new Error(`${name} needs at least one value`);
+	const [first, ...rest] = input;
+	return [parseExpression(first), ...rest.map((operand) => parseExpression(operand))];
+}
+/** Rejects misspelled or mixed expression keys rather than silently ignoring them. */
+function checkKeys(value, allowed) {
+	for (const key of Reflect.ownKeys(value)) if (typeof key !== "string" || !allowed.includes(key)) throw new Error(`Unknown expression key '${String(key)}'`);
+}
+/** Narrows expression input objects without treating null as an object. */
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+export { checkKeys, isObject, parseExpression, parseExpressionInput, parseNonEmptyOperands };
+
+//# sourceMappingURL=parseExpression.js.map

package/build/queries/sql/expressions/parseExpression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseExpression.js","names":[],"sources":["../../../../src/queries/sql/expressions/parseExpression.ts"],"sourcesContent":["import { BaseExpr } from \"src/queries/sql/Expr.ts\";\nimport { parseArrayAggExpression } from \"src/queries/sql/expressions/arrayAgg.ts\";\nimport { parseCaseExpression } from \"src/queries/sql/expressions/case.ts\";\nimport { parseCoalesceExpression } from \"src/queries/sql/expressions/coalesce.ts\";\nimport { parseGreatestExpression } from \"src/queries/sql/expressions/greatest.ts\";\nimport { parseLeastExpression } from \"src/queries/sql/expressions/least.ts\";\nimport { parseNullIfExpression } from \"src/queries/sql/expressions/nullIf.ts\";\nimport type { ExprName, ParsedExpression } from \"src/queries/sql/expressions/types.ts\";\nimport { assertNever } from \"src/utils.ts\";\n\n// These expressions take operand arrays; CASE uses WHEN/THEN entries instead.\nconst exprNames = [\"coalesce\", \"nullIf\", \"greatest\", \"least\"] as const satisfies readonly ExprName[];\n\n/** Requires an expression object at the root before parsing its nested operands. */\nexport function parseExpressionInput(input: unknown): ParsedExpression {\n  if (!isObject(input) || (!(\"case\" in input) && !(\"arrayAgg\" in input) && !exprNames.some((name) => name in input))) {\n    throw new Error(\"expr expects an object with arrayAgg, case, coalesce, nullIf, greatest, or least\");\n  }\n  return parseExpression(input);\n}\n\n/**\n * Parses expression inputs into a ParsedExpression, validating their shape and copying operand arrays.\n * Nested expressions stay together so their literals can use a column's codec from another branch.\n * I.e. COALESCE(Book.id, CASE ... THEN \"b:9\" END) must encode \"b:9\" as an integer.\n */\nexport function parseExpression(input: unknown): ParsedExpression {\n  if (input instanceof BaseExpr) return input;\n  if (input === undefined) throw new Error(\"Use null for a SQL NULL value\");\n  const name = isObject(input) ? exprNames.find((name) => name in input) : undefined;\n  if (name && isObject(input)) {\n    checkKeys(input, [name]);\n    switch (name) {\n      case \"coalesce\":\n        return parseCoalesceExpression(input.coalesce);\n      case \"nullIf\":\n        return parseNullIfExpression(input.nullIf);\n      case \"greatest\":\n        return parseGreatestExpression(input.greatest);\n      case \"least\":\n        return parseLeastExpression(input.least);\n      default:\n        return assertNever(name);\n    }\n  }\n  if (isObject(input) && \"arrayAgg\" in input) {\n    checkKeys(input, [\"arrayAgg\"]);\n    return parseArrayAggExpression(input.arrayAgg);\n  }\n  if (isObject(input) && \"case\" in input) {\n    checkKeys(input, [\"case\"]);\n    return parseCaseExpression(input.case);\n  }\n  return { kind: \"literal\", value: input };\n}\n\n/** Validates and copies a nonempty operand array, preserving its first element in the parsed type. */\nexport function parseNonEmptyOperands(input: unknown, name: string): [ParsedExpression, ...ParsedExpression[]] {\n  if (!Array.isArray(input) || input.length === 0) throw new Error(`${name} needs at least one value`);\n  // Validation above guarantees a first operand; keep that guarantee in the parsed type.\n  const [first, ...rest] = input;\n  return [parseExpression(first), ...rest.map((operand) => parseExpression(operand))];\n}\n\n/** Rejects misspelled or mixed expression keys rather than silently ignoring them. */\nexport function checkKeys(value: object, allowed: string[]): void {\n  for (const key of Reflect.ownKeys(value)) {\n    if (typeof key !== \"string\" || !allowed.includes(key)) throw new Error(`Unknown expression key '${String(key)}'`);\n  }\n}\n\n/** Narrows expression input objects without treating null as an object. */\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null;\n}\n"],"mappings":";;;;;;;;;AAWA,MAAM,YAAY;CAAC;CAAY;CAAU;CAAY;AAAO;;AAG5D,SAAgB,qBAAqB,OAAkC;CACrE,IAAI,CAAC,SAAS,KAAK,KAAM,EAAE,UAAU,UAAU,EAAE,cAAc,UAAU,CAAC,UAAU,MAAM,SAAS,QAAQ,KAAK,GAC9G,MAAM,IAAI,MAAM,kFAAkF;CAEpG,OAAO,gBAAgB,KAAK;AAC9B;;;;;;AAOA,SAAgB,gBAAgB,OAAkC;CAChE,IAAI,iBAAiB,UAAU,OAAO;CACtC,IAAI,UAAU,KAAA,GAAW,MAAM,IAAI,MAAM,+BAA+B;CACxE,MAAM,OAAO,SAAS,KAAK,IAAI,UAAU,MAAM,SAAS,QAAQ,KAAK,IAAI,KAAA;CACzE,IAAI,QAAQ,SAAS,KAAK,GAAG;EAC3B,UAAU,OAAO,CAAC,IAAI,CAAC;EACvB,QAAQ,MAAR;GACE,KAAK,YACH,OAAO,wBAAwB,MAAM,QAAQ;GAC/C,KAAK,UACH,OAAO,sBAAsB,MAAM,MAAM;GAC3C,KAAK,YACH,OAAO,wBAAwB,MAAM,QAAQ;GAC/C,KAAK,SACH,OAAO,qBAAqB,MAAM,KAAK;GACzC,SACE,OAAO,YAAY,IAAI;EAC3B;CACF;CACA,IAAI,SAAS,KAAK,KAAK,cAAc,OAAO;EAC1C,UAAU,OAAO,CAAC,UAAU,CAAC;EAC7B,OAAO,wBAAwB,MAAM,QAAQ;CAC/C;CACA,IAAI,SAAS,KAAK,KAAK,UAAU,OAAO;EACtC,UAAU,OAAO,CAAC,MAAM,CAAC;EACzB,OAAO,oBAAoB,MAAM,IAAI;CACvC;CACA,OAAO;EAAE,MAAM;EAAW,OAAO;CAAM;AACzC;;AAGA,SAAgB,sBAAsB,OAAgB,MAAyD;CAC7G,IAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,GAAG,KAAK,0BAA0B;CAEnG,MAAM,CAAC,OAAO,GAAG,QAAQ;CACzB,OAAO,CAAC,gBAAgB,KAAK,GAAG,GAAG,KAAK,KAAK,YAAY,gBAAgB,OAAO,CAAC,CAAC;AACpF;;AAGA,SAAgB,UAAU,OAAe,SAAyB;CAChE,KAAK,MAAM,OAAO,QAAQ,QAAQ,KAAK,GACrC,IAAI,OAAO,QAAQ,YAAY,CAAC,QAAQ,SAAS,GAAG,GAAG,MAAM,IAAI,MAAM,2BAA2B,OAAO,GAAG,EAAE,EAAE;AAEpH;;AAGA,SAAgB,SAAS,OAAkD;CACzE,OAAO,OAAO,UAAU,YAAY,UAAU;AAChD"}

package/build/queries/sql/expressions/types.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/build/queries/sql/expressions/types.d.cts

@@ -0,0 +1,114 @@
+import { ArrayAggExpressionOptions, ArrayAggInput, ParsedArrayAggExpression } from "./arrayAgg.cjs";
+import { CaseArmValue, CaseInput, CheckCase, ParsedCaseExpression } from "./case.cjs";
+import { CoalesceInput, ParsedCoalesceExpression } from "./coalesce.cjs";
+import { GreatestInput, ParsedGreatestExpression } from "./greatest.cjs";
+import { LeastInput, ParsedLeastExpression } from "./least.cjs";
+import { NullIfInput, ParsedNullIfExpression } from "./nullIf.cjs";
+import { CompatibleValue, MaybeNull, QueryJoinList } from "../query.cjs";
+import { BaseExpr, Expr, ExprBrand, ExprLike, exprBrand } from "../Expr.cjs";
+//#region src/queries/sql/expressions/types.d.ts
+/** Each operation owns its input fields; the combined input permits exactly one operation. */
+interface ExprInputs {
+  case: CaseInput;
+  arrayAgg: ArrayAggInput;
+  coalesce: CoalesceInput;
+  nullIf: NullIfInput;
+  greatest: GreatestInput;
+  least: LeastInput;
+}
+type ExprName = Exclude<keyof ExprInputs, "case" | "arrayAgg">;
+type ExprArgsInput = { [K in ExprName]: { readonly [P in K]: readonly unknown[]; }; }[ExprName];
+type ExprArgs<V> = Extract<V[keyof V & ExprName], readonly unknown[]>;
+/** An expression object used in select or passed to expr, i.e. { coalesce: [a.last_name, a.first_name] }. */
+type ExprInput = { [K in keyof ExprInputs]: ExprInputs[K] & { readonly [P in Exclude<keyof ExprInputs | "else", K>]?: never; }; }[keyof ExprInputs];
+declare const inputBrand: unique symbol;
+/** Retains the input object so query results can account for LEFT joins in each candidate separately. */
+type ExprFromInput<I> = Expr<InputResult<I, []>, ExpressionSources<I>> & {
+  readonly [inputBrand]: I;
+};
+/**
+ * Computes the SQL expression type, including null from LEFT joins.
+ * I.e. Book.title is string | null when Book is LEFT-joined; COALESCE(Book.title, "Unknown") is string.
+ */
+type ExpressionValue<V, J extends QueryJoinList> = unknown extends V ? V : V extends {
+  readonly [inputBrand]: infer I;
+} ? InputResult<I, J> : V extends {
+  readonly [exprBrand]: ExprBrand<infer R, infer S>;
+} ? MaybeNull<R, S, J> : V extends {
+  readonly arrayAgg: infer A;
+} ? ExpressionValue<ArrayAggValue<A>, J>[] | null : V extends ExprArgsInput ? V extends {
+  readonly nullIf: readonly unknown[];
+} ? ExpressionValue<ExprArgs<V>[0], J> | null : V extends {
+  readonly coalesce: readonly unknown[];
+} ? CoalesceValue<ExprArgs<V>, J> : Exclude<ExpressionValue<ExprArgs<V>[number], J>, null> | (null extends CoalesceValue<ExprArgs<V>, J> ? null : never) : V extends {
+  readonly case: infer A;
+} ? ExpressionValue<CaseArmValue<A>, J> | (A extends readonly [...unknown[], {
+  readonly else: unknown;
+}] ? never : null) : WidenLiteral<V>;
+/** Turns literal types such as "Alice" and 18 into string and number, including array elements. */
+type WidenLiteral<V> = V extends string ? string : V extends number ? number : V extends boolean ? boolean : V extends bigint ? bigint : V extends readonly (infer E)[] ? WidenLiteral<E>[] : V;
+/**
+ * Uses existing expressions' result types for their literal fallbacks, just as their codecs do at runtime.
+ * I.e. COALESCE(Book.id, "b:9") returns BookId rather than string. ExpressionValue supplies the nullability.
+ */
+type InputResult<I, J extends QueryJoinList> = [Exclude<BranchResult<I>, null>] extends [never] ? ExpressionValue<I, J> : Exclude<BranchResult<I>, null> | (null extends ExpressionValue<I, J> ? null : never);
+/** Collects the types supplied by columns and existing expressions, excluding plain literal fallbacks. */
+type BranchResult<V> = unknown extends V ? never : V extends ExprLike<infer R> ? R : V extends {
+  readonly arrayAgg: infer A;
+} ? BranchResult<ArrayAggValue<A>>[] : V extends ExprArgsInput ? BranchResult<V extends {
+  readonly nullIf: readonly unknown[];
+} ? ExprArgs<V>[0] : ExprArgs<V>[number]> : V extends {
+  readonly case: infer A;
+} ? BranchResult<CaseArmValue<A>> : never;
+/** A fixed non-null candidate guarantees a result; a possibly empty candidate array does not. */
+type CoalesceValue<A extends readonly unknown[], J extends QueryJoinList> = A extends readonly [infer H, ...infer T] ? Exclude<ExpressionValue<H, J>, null> | (null extends ExpressionValue<H, J> ? CoalesceValue<T, J> : never) : A extends readonly [...infer Before, infer Last] ? Exclude<ExpressionValue<A[number], J>, null> | (null extends ExpressionValue<Last, J> ? (null extends CoalesceValue<Before, J> ? null : never) : never) : ExpressionValue<A[number], J> | null;
+/** Conditions affect which value is chosen, but do not make that value nullable through a LEFT join. */
+type ExpressionSources<V> = unknown extends V ? string : V extends ExprLike<unknown> ? V[typeof exprBrand]["__source"] : V extends {
+  readonly arrayAgg: infer A;
+} ? ExpressionSources<ArrayAggValue<A>> : V extends ExprArgsInput ? ExpressionSources<ExprArgs<V>[number]> : V extends {
+  readonly case: infer A;
+} ? ExpressionSources<CaseArmValue<A>> : never;
+/**
+ * Compares every operand with the others using the same type check as query set operations.
+ * I.e. Author.age and 18 both yield number; Author.age and Author.first_name yield incompatible types.
+ * SQL storage types and codecs are checked separately at runtime.
+ */
+type CompatibleValues<V, All = V> = false extends (V extends unknown ? All extends unknown ? CompatibleValue<ExpressionValue<V, []>, ExpressionValue<All, []>> : never : never) ? "Expression values must have compatible types" : unknown;
+/** Checks nested expression shapes and literal fallbacks in one pass; R is the type supplied by existing expressions. */
+type CheckExpression<V, R> = V extends ExprLike<unknown> ? unknown : V extends {
+  readonly arrayAgg: infer A;
+} ? {
+  readonly arrayAgg: CheckArrayAgg<A, R extends readonly (infer E)[] ? E : never>;
+} & { readonly [K in Exclude<keyof V, "arrayAgg">]: never; } : V extends ExprArgsInput ? V extends ExprInput ? { readonly [K in keyof V]: K extends ExprName ? V[K] extends readonly unknown[] ? CheckOperands<V[K], K, R> : never : never; } : never : V extends {
+  readonly case: infer A;
+} ? {
+  readonly case: CheckCase<A, R>;
+} & CompatibleValues<CaseArmValue<A>> & { readonly [K in Exclude<keyof V, "case">]: never; } : V extends undefined ? "Use null for a SQL NULL value" : [R] extends [never] ? unknown : V extends null ? unknown : V extends (R extends readonly unknown[] ? Readonly<R> : R) ? unknown : "Literal values must match the expression";
+/** Checks fixed argument counts and then each operand; dynamic array lengths are checked at runtime. */
+type CheckOperands<A extends readonly unknown[], Name extends ExprName, R> = (Name extends "nullIf" ? number extends A["length"] ? unknown : A extends readonly [unknown, unknown] ? unknown : "NULLIF needs exactly two values" : A extends readonly [] ? `${Uppercase<Name>} needs at least one value` : unknown) & { readonly [K in keyof A]: CheckExpression<A[K], R>; } & CompatibleValues<A[number]>;
+/** Valid inputs need no extra constraint; this keeps spread arrays from losing their fixed final operand. */
+type CheckInput<I> = [I] extends [CheckExpression<I, Exclude<BranchResult<I>, null>>] ? unknown : CheckExpression<I, Exclude<BranchResult<I>, null>>;
+/**
+ * The internal form produced by parsing expression inputs, like ParsedFindQuery for em.find filters.
+ * Existing Expr instances remain intact; literal operands and CASE results are parsed recursively.
+ * CASE conditions retain their query input until SQL rendering supplies the alias context.
+ */
+type ParsedExpression = BaseExpr | ParsedLiteralExpression | ParsedArrayAggExpression | ParsedCoalesceExpression | ParsedNullIfExpression | ParsedGreatestExpression | ParsedLeastExpression | ParsedCaseExpression;
+/** A bound value whose encoder is selected from the surrounding expression. */
+interface ParsedLiteralExpression {
+  kind: "literal";
+  value: unknown;
+}
+/** The conversions shared by all result values, separate from their SQL rendering. */
+type ResultCodec = Pick<BaseExpr, "outputType" | "encode" | "decode">;
+/** Extracts the aggregate value from compact or expanded ARRAY_AGG input. */
+type ArrayAggValue<A> = A extends {
+  readonly value: infer V;
+} ? V : A;
+/** Checks the aggregate value and rejects unknown expanded option keys. */
+type CheckArrayAgg<A, R> = A extends {
+  readonly value: unknown;
+} ? A extends ArrayAggExpressionOptions ? { readonly [K in keyof A]: K extends "value" ? CheckExpression<A[K], R> : K extends keyof ArrayAggExpressionOptions ? A[K] : never; } : never : CheckExpression<A, R>;
+//#endregion
+export { CheckExpression, CheckInput, ExprFromInput, ExprInput, ExprName, ExpressionSources, ExpressionValue, ParsedExpression, ParsedLiteralExpression, ResultCodec };
+//# sourceMappingURL=types.d.cts.map

package/build/queries/sql/expressions/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../../../src/queries/sql/expressions/types.ts"],"mappings":"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"}