joist-core 2.3.0-next.92 → 2.3.0-next.93

package/build/expressions/arrayAgg.cjs

@@ -0,0 +1,63 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_Expr = require("../Expr.cjs");
+const require_expressions_parseExpression = require("./parseExpression.cjs");
+const require_expressions_expression = require("./expression.cjs");
+//#region src/expressions/arrayAgg.ts
+/** Parses compact and expanded ARRAY_AGG inputs. */
+function parseArrayAggExpression(input) {
+	if (input instanceof require_Expr.BaseExpr || !isArrayAggOptions(input)) return {
+		kind: "arrayAgg",
+		value: require_expressions_parseExpression.parseExpression(input)
+	};
+	require_expressions_parseExpression.checkKeys(input, [
+		"value",
+		"distinct",
+		"orderBy",
+		"filter"
+	]);
+	if (!("value" in input)) throw new Error("ARRAY_AGG options need a value");
+	if (input.distinct !== void 0 && typeof input.distinct !== "boolean") throw new Error("ARRAY_AGG distinct must be a boolean");
+	if (input.orderBy !== void 0 && !Array.isArray(input.orderBy)) throw new Error("ARRAY_AGG orderBy must be an array");
+	return {
+		kind: "arrayAgg",
+		value: require_expressions_parseExpression.parseExpression(input.value),
+		options: {
+			distinct: input.distinct,
+			orderBy: input.orderBy,
+			filter: input.filter
+		}
+	};
+}
+/** Renders ARRAY_AGG's value, ordering, and filter in SQL binding order. */
+function arrayAggToSql(parsed, ctx, valueCodec) {
+	const value = require_expressions_expression.expressionToSql(parsed.value, ctx, valueCodec);
+	const ordering = require_Expr.joinFragments((parsed.options?.orderBy ?? []).flatMap((entry) => {
+		if (entry === void 0) return [];
+		const fragment = require_Expr.orderByToSql(entry, ctx);
+		return fragment ? [fragment] : [];
+	}), ", ");
+	const filter = parsed.options?.filter;
+	const condition = filter === void 0 ? void 0 : ctx.conditionToSql(filter);
+	return {
+		sql: `array_agg(${parsed.options?.distinct ? "DISTINCT " : ""}${value.sql}${ordering.sql ? ` ORDER BY ${ordering.sql}` : ""})${condition ? ` FILTER (WHERE ${condition.sql})` : ""}`,
+		bindings: [
+			...value.bindings,
+			...ordering.bindings,
+			...condition?.bindings ?? []
+		],
+		refs: [
+			...value.refs,
+			...ordering.refs,
+			...condition?.refs ?? []
+		]
+	};
+}
+/** Distinguishes expanded options from nested object expressions. */
+function isArrayAggOptions(input) {
+	return require_expressions_parseExpression.isObject(input) && ("value" in input || "distinct" in input || "orderBy" in input || "filter" in input);
+}
+//#endregion
+exports.arrayAggToSql = arrayAggToSql;
+exports.parseArrayAggExpression = parseArrayAggExpression;
+
+//# sourceMappingURL=arrayAgg.cjs.map

package/build/expressions/arrayAgg.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayAgg.cjs","names":["BaseExpr","parseExpression","expressionToSql","joinFragments","orderByToSql","isObject"],"sources":["../../src/expressions/arrayAgg.ts"],"sourcesContent":["import {\n  type ArrayAggOptions,\n  BaseExpr,\n  type ExprContext,\n  type ExprLike,\n  type SqlFragment,\n  joinFragments,\n  orderByToSql,\n} from \"../Expr.ts\";\nimport { expressionToSql } from \"./expression.ts\";\nimport { checkKeys, isObject, parseExpression } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./types.ts\";\n\n/** The aggregate value alone, or the value together with PostgreSQL aggregate options. */\nexport interface ArrayAggInput {\n  readonly arrayAgg: ExprLike<unknown> | ArrayAggExpressionOptions;\n}\n\n/** Options for an inline ARRAY_AGG expression. */\nexport interface ArrayAggExpressionOptions extends ArrayAggOptions {\n  readonly value: unknown;\n}\n\n/** An ARRAY_AGG value and its aggregate options. */\nexport interface ParsedArrayAggExpression {\n  kind: \"arrayAgg\";\n  value: ParsedExpression;\n  options?: ArrayAggOptions;\n}\n\n/** Parses compact and expanded ARRAY_AGG inputs. */\nexport function parseArrayAggExpression(input: unknown): ParsedArrayAggExpression {\n  if (input instanceof BaseExpr || !isArrayAggOptions(input)) {\n    return { kind: \"arrayAgg\", value: parseExpression(input) };\n  }\n  checkKeys(input, [\"value\", \"distinct\", \"orderBy\", \"filter\"]);\n  if (!(\"value\" in input)) throw new Error(\"ARRAY_AGG options need a value\");\n  if (input.distinct !== undefined && typeof input.distinct !== \"boolean\") {\n    throw new Error(\"ARRAY_AGG distinct must be a boolean\");\n  }\n  if (input.orderBy !== undefined && !Array.isArray(input.orderBy)) {\n    throw new Error(\"ARRAY_AGG orderBy must be an array\");\n  }\n  return {\n    kind: \"arrayAgg\",\n    value: parseExpression(input.value),\n    options: {\n      distinct: input.distinct as boolean | undefined,\n      orderBy: input.orderBy as ArrayAggOptions[\"orderBy\"],\n      filter: input.filter as ArrayAggOptions[\"filter\"],\n    },\n  };\n}\n\n/** Renders ARRAY_AGG's value, ordering, and filter in SQL binding order. */\nexport function arrayAggToSql(\n  parsed: ParsedArrayAggExpression,\n  ctx: ExprContext,\n  valueCodec: ResultCodec,\n): SqlFragment {\n  const value = expressionToSql(parsed.value, ctx, valueCodec);\n  const ordering = joinFragments(\n    (parsed.options?.orderBy ?? []).flatMap((entry) => {\n      if (entry === undefined) return [];\n      const fragment = orderByToSql(entry, ctx);\n      return fragment ? [fragment] : [];\n    }),\n    \", \",\n  );\n  const filter = parsed.options?.filter;\n  const condition = filter === undefined ? undefined : ctx.conditionToSql(filter);\n  return {\n    sql: `array_agg(${parsed.options?.distinct ? \"DISTINCT \" : \"\"}${value.sql}${ordering.sql ? ` ORDER BY ${ordering.sql}` : \"\"})${condition ? ` FILTER (WHERE ${condition.sql})` : \"\"}`,\n    bindings: [...value.bindings, ...ordering.bindings, ...(condition?.bindings ?? [])],\n    refs: [...value.refs, ...ordering.refs, ...(condition?.refs ?? [])],\n  };\n}\n\n/** Distinguishes expanded options from nested object expressions. */\nfunction isArrayAggOptions(input: unknown): input is Record<string, unknown> {\n  return isObject(input) && (\"value\" in input || \"distinct\" in input || \"orderBy\" in input || \"filter\" in input);\n}\n"],"mappings":";;;;;;AA+BA,SAAgB,wBAAwB,OAA0C;CAChF,IAAI,iBAAiBA,aAAAA,YAAY,CAAC,kBAAkB,KAAK,GACvD,OAAO;EAAE,MAAM;EAAY,OAAOC,oCAAAA,gBAAgB,KAAK;CAAE;CAE3D,oCAAA,UAAU,OAAO;EAAC;EAAS;EAAY;EAAW;CAAQ,CAAC;CAC3D,IAAI,EAAE,WAAW,QAAQ,MAAM,IAAI,MAAM,gCAAgC;CACzE,IAAI,MAAM,aAAa,KAAA,KAAa,OAAO,MAAM,aAAa,WAC5D,MAAM,IAAI,MAAM,sCAAsC;CAExD,IAAI,MAAM,YAAY,KAAA,KAAa,CAAC,MAAM,QAAQ,MAAM,OAAO,GAC7D,MAAM,IAAI,MAAM,oCAAoC;CAEtD,OAAO;EACL,MAAM;EACN,OAAOA,oCAAAA,gBAAgB,MAAM,KAAK;EAClC,SAAS;GACP,UAAU,MAAM;GAChB,SAAS,MAAM;GACf,QAAQ,MAAM;EAChB;CACF;AACF;;AAGA,SAAgB,cACd,QACA,KACA,YACa;CACb,MAAM,QAAQC,+BAAAA,gBAAgB,OAAO,OAAO,KAAK,UAAU;CAC3D,MAAM,WAAWC,aAAAA,eACd,OAAO,SAAS,WAAW,CAAC,EAAA,CAAG,SAAS,UAAU;EACjD,IAAI,UAAU,KAAA,GAAW,OAAO,CAAC;EACjC,MAAM,WAAWC,aAAAA,aAAa,OAAO,GAAG;EACxC,OAAO,WAAW,CAAC,QAAQ,IAAI,CAAC;CAClC,CAAC,GACD,IACF;CACA,MAAM,SAAS,OAAO,SAAS;CAC/B,MAAM,YAAY,WAAW,KAAA,IAAY,KAAA,IAAY,IAAI,eAAe,MAAM;CAC9E,OAAO;EACL,KAAK,aAAa,OAAO,SAAS,WAAW,cAAc,KAAK,MAAM,MAAM,SAAS,MAAM,aAAa,SAAS,QAAQ,GAAG,GAAG,YAAY,kBAAkB,UAAU,IAAI,KAAK;EAChL,UAAU;GAAC,GAAG,MAAM;GAAU,GAAG,SAAS;GAAU,GAAI,WAAW,YAAY,CAAC;EAAE;EAClF,MAAM;GAAC,GAAG,MAAM;GAAM,GAAG,SAAS;GAAM,GAAI,WAAW,QAAQ,CAAC;EAAE;CACpE;AACF;;AAGA,SAAS,kBAAkB,OAAkD;CAC3E,OAAOC,oCAAAA,SAAS,KAAK,MAAM,WAAW,SAAS,cAAc,SAAS,aAAa,SAAS,YAAY;AAC1G"}

package/build/expressions/arrayAgg.d.cts

@@ -0,0 +1,24 @@
+import { ParsedExpression, ResultCodec } from "./types.cjs";
+import { ArrayAggOptions, ExprContext, ExprLike, SqlFragment } from "../Expr.cjs";
+//#region src/expressions/arrayAgg.d.ts
+/** The aggregate value alone, or the value together with PostgreSQL aggregate options. */
+interface ArrayAggInput {
+  readonly arrayAgg: ExprLike<unknown> | ArrayAggExpressionOptions;
+}
+/** Options for an inline ARRAY_AGG expression. */
+interface ArrayAggExpressionOptions extends ArrayAggOptions {
+  readonly value: unknown;
+}
+/** An ARRAY_AGG value and its aggregate options. */
+interface ParsedArrayAggExpression {
+  kind: "arrayAgg";
+  value: ParsedExpression;
+  options?: ArrayAggOptions;
+}
+/** Parses compact and expanded ARRAY_AGG inputs. */
+declare function parseArrayAggExpression(input: unknown): ParsedArrayAggExpression;
+/** Renders ARRAY_AGG's value, ordering, and filter in SQL binding order. */
+declare function arrayAggToSql(parsed: ParsedArrayAggExpression, ctx: ExprContext, valueCodec: ResultCodec): SqlFragment;
+//#endregion
+export { ArrayAggExpressionOptions, ArrayAggInput, ParsedArrayAggExpression, arrayAggToSql, parseArrayAggExpression };
+//# sourceMappingURL=arrayAgg.d.cts.map

package/build/expressions/arrayAgg.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayAgg.d.cts","names":[],"sources":["../../src/expressions/arrayAgg.ts"],"mappings":";;;;UAciB;WACN,UAAU,oBAAoB;;;UAIxB,kCAAkC;WACxC;;;UAIM;EACf;EACA,OAAO;EACP,UAAU;;;iBAII,wBAAwB,iBAAiB;;iBAwBzC,cACd,QAAQ,0BACR,KAAK,aACL,YAAY,cACX"}

package/build/expressions/arrayAgg.d.mts

@@ -0,0 +1,24 @@
+import { ParsedExpression, ResultCodec } from "./types.mjs";
+import { ArrayAggOptions, ExprContext, ExprLike, SqlFragment } from "../Expr.mjs";
+//#region src/expressions/arrayAgg.d.ts
+/** The aggregate value alone, or the value together with PostgreSQL aggregate options. */
+interface ArrayAggInput {
+  readonly arrayAgg: ExprLike<unknown> | ArrayAggExpressionOptions;
+}
+/** Options for an inline ARRAY_AGG expression. */
+interface ArrayAggExpressionOptions extends ArrayAggOptions {
+  readonly value: unknown;
+}
+/** An ARRAY_AGG value and its aggregate options. */
+interface ParsedArrayAggExpression {
+  kind: "arrayAgg";
+  value: ParsedExpression;
+  options?: ArrayAggOptions;
+}
+/** Parses compact and expanded ARRAY_AGG inputs. */
+declare function parseArrayAggExpression(input: unknown): ParsedArrayAggExpression;
+/** Renders ARRAY_AGG's value, ordering, and filter in SQL binding order. */
+declare function arrayAggToSql(parsed: ParsedArrayAggExpression, ctx: ExprContext, valueCodec: ResultCodec): SqlFragment;
+//#endregion
+export { ArrayAggExpressionOptions, ArrayAggInput, ParsedArrayAggExpression, arrayAggToSql, parseArrayAggExpression };
+//# sourceMappingURL=arrayAgg.d.mts.map

package/build/expressions/arrayAgg.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayAgg.d.mts","names":[],"sources":["../../src/expressions/arrayAgg.ts"],"mappings":";;;;UAciB;WACN,UAAU,oBAAoB;;;UAIxB,kCAAkC;WACxC;;;UAIM;EACf;EACA,OAAO;EACP,UAAU;;;iBAII,wBAAwB,iBAAiB;;iBAwBzC,cACd,QAAQ,0BACR,KAAK,aACL,YAAY,cACX"}

package/build/expressions/arrayAgg.js

@@ -0,0 +1,61 @@
+import { BaseExpr, joinFragments, orderByToSql } from "../Expr.js";
+import { checkKeys, isObject, parseExpression } from "./parseExpression.js";
+import { expressionToSql } from "./expression.js";
+//#region src/expressions/arrayAgg.ts
+/** Parses compact and expanded ARRAY_AGG inputs. */
+function parseArrayAggExpression(input) {
+	if (input instanceof BaseExpr || !isArrayAggOptions(input)) return {
+		kind: "arrayAgg",
+		value: parseExpression(input)
+	};
+	checkKeys(input, [
+		"value",
+		"distinct",
+		"orderBy",
+		"filter"
+	]);
+	if (!("value" in input)) throw new Error("ARRAY_AGG options need a value");
+	if (input.distinct !== void 0 && typeof input.distinct !== "boolean") throw new Error("ARRAY_AGG distinct must be a boolean");
+	if (input.orderBy !== void 0 && !Array.isArray(input.orderBy)) throw new Error("ARRAY_AGG orderBy must be an array");
+	return {
+		kind: "arrayAgg",
+		value: parseExpression(input.value),
+		options: {
+			distinct: input.distinct,
+			orderBy: input.orderBy,
+			filter: input.filter
+		}
+	};
+}
+/** Renders ARRAY_AGG's value, ordering, and filter in SQL binding order. */
+function arrayAggToSql(parsed, ctx, valueCodec) {
+	const value = expressionToSql(parsed.value, ctx, valueCodec);
+	const ordering = joinFragments((parsed.options?.orderBy ?? []).flatMap((entry) => {
+		if (entry === void 0) return [];
+		const fragment = orderByToSql(entry, ctx);
+		return fragment ? [fragment] : [];
+	}), ", ");
+	const filter = parsed.options?.filter;
+	const condition = filter === void 0 ? void 0 : ctx.conditionToSql(filter);
+	return {
+		sql: `array_agg(${parsed.options?.distinct ? "DISTINCT " : ""}${value.sql}${ordering.sql ? ` ORDER BY ${ordering.sql}` : ""})${condition ? ` FILTER (WHERE ${condition.sql})` : ""}`,
+		bindings: [
+			...value.bindings,
+			...ordering.bindings,
+			...condition?.bindings ?? []
+		],
+		refs: [
+			...value.refs,
+			...ordering.refs,
+			...condition?.refs ?? []
+		]
+	};
+}
+/** Distinguishes expanded options from nested object expressions. */
+function isArrayAggOptions(input) {
+	return isObject(input) && ("value" in input || "distinct" in input || "orderBy" in input || "filter" in input);
+}
+//#endregion
+export { arrayAggToSql, parseArrayAggExpression };
+
+//# sourceMappingURL=arrayAgg.js.map

package/build/expressions/arrayAgg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayAgg.js","names":[],"sources":["../../src/expressions/arrayAgg.ts"],"sourcesContent":["import {\n  type ArrayAggOptions,\n  BaseExpr,\n  type ExprContext,\n  type ExprLike,\n  type SqlFragment,\n  joinFragments,\n  orderByToSql,\n} from \"../Expr.ts\";\nimport { expressionToSql } from \"./expression.ts\";\nimport { checkKeys, isObject, parseExpression } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./types.ts\";\n\n/** The aggregate value alone, or the value together with PostgreSQL aggregate options. */\nexport interface ArrayAggInput {\n  readonly arrayAgg: ExprLike<unknown> | ArrayAggExpressionOptions;\n}\n\n/** Options for an inline ARRAY_AGG expression. */\nexport interface ArrayAggExpressionOptions extends ArrayAggOptions {\n  readonly value: unknown;\n}\n\n/** An ARRAY_AGG value and its aggregate options. */\nexport interface ParsedArrayAggExpression {\n  kind: \"arrayAgg\";\n  value: ParsedExpression;\n  options?: ArrayAggOptions;\n}\n\n/** Parses compact and expanded ARRAY_AGG inputs. */\nexport function parseArrayAggExpression(input: unknown): ParsedArrayAggExpression {\n  if (input instanceof BaseExpr || !isArrayAggOptions(input)) {\n    return { kind: \"arrayAgg\", value: parseExpression(input) };\n  }\n  checkKeys(input, [\"value\", \"distinct\", \"orderBy\", \"filter\"]);\n  if (!(\"value\" in input)) throw new Error(\"ARRAY_AGG options need a value\");\n  if (input.distinct !== undefined && typeof input.distinct !== \"boolean\") {\n    throw new Error(\"ARRAY_AGG distinct must be a boolean\");\n  }\n  if (input.orderBy !== undefined && !Array.isArray(input.orderBy)) {\n    throw new Error(\"ARRAY_AGG orderBy must be an array\");\n  }\n  return {\n    kind: \"arrayAgg\",\n    value: parseExpression(input.value),\n    options: {\n      distinct: input.distinct as boolean | undefined,\n      orderBy: input.orderBy as ArrayAggOptions[\"orderBy\"],\n      filter: input.filter as ArrayAggOptions[\"filter\"],\n    },\n  };\n}\n\n/** Renders ARRAY_AGG's value, ordering, and filter in SQL binding order. */\nexport function arrayAggToSql(\n  parsed: ParsedArrayAggExpression,\n  ctx: ExprContext,\n  valueCodec: ResultCodec,\n): SqlFragment {\n  const value = expressionToSql(parsed.value, ctx, valueCodec);\n  const ordering = joinFragments(\n    (parsed.options?.orderBy ?? []).flatMap((entry) => {\n      if (entry === undefined) return [];\n      const fragment = orderByToSql(entry, ctx);\n      return fragment ? [fragment] : [];\n    }),\n    \", \",\n  );\n  const filter = parsed.options?.filter;\n  const condition = filter === undefined ? undefined : ctx.conditionToSql(filter);\n  return {\n    sql: `array_agg(${parsed.options?.distinct ? \"DISTINCT \" : \"\"}${value.sql}${ordering.sql ? ` ORDER BY ${ordering.sql}` : \"\"})${condition ? ` FILTER (WHERE ${condition.sql})` : \"\"}`,\n    bindings: [...value.bindings, ...ordering.bindings, ...(condition?.bindings ?? [])],\n    refs: [...value.refs, ...ordering.refs, ...(condition?.refs ?? [])],\n  };\n}\n\n/** Distinguishes expanded options from nested object expressions. */\nfunction isArrayAggOptions(input: unknown): input is Record<string, unknown> {\n  return isObject(input) && (\"value\" in input || \"distinct\" in input || \"orderBy\" in input || \"filter\" in input);\n}\n"],"mappings":";;;;;AA+BA,SAAgB,wBAAwB,OAA0C;CAChF,IAAI,iBAAiB,YAAY,CAAC,kBAAkB,KAAK,GACvD,OAAO;EAAE,MAAM;EAAY,OAAO,gBAAgB,KAAK;CAAE;CAE3D,UAAU,OAAO;EAAC;EAAS;EAAY;EAAW;CAAQ,CAAC;CAC3D,IAAI,EAAE,WAAW,QAAQ,MAAM,IAAI,MAAM,gCAAgC;CACzE,IAAI,MAAM,aAAa,KAAA,KAAa,OAAO,MAAM,aAAa,WAC5D,MAAM,IAAI,MAAM,sCAAsC;CAExD,IAAI,MAAM,YAAY,KAAA,KAAa,CAAC,MAAM,QAAQ,MAAM,OAAO,GAC7D,MAAM,IAAI,MAAM,oCAAoC;CAEtD,OAAO;EACL,MAAM;EACN,OAAO,gBAAgB,MAAM,KAAK;EAClC,SAAS;GACP,UAAU,MAAM;GAChB,SAAS,MAAM;GACf,QAAQ,MAAM;EAChB;CACF;AACF;;AAGA,SAAgB,cACd,QACA,KACA,YACa;CACb,MAAM,QAAQ,gBAAgB,OAAO,OAAO,KAAK,UAAU;CAC3D,MAAM,WAAW,eACd,OAAO,SAAS,WAAW,CAAC,EAAA,CAAG,SAAS,UAAU;EACjD,IAAI,UAAU,KAAA,GAAW,OAAO,CAAC;EACjC,MAAM,WAAW,aAAa,OAAO,GAAG;EACxC,OAAO,WAAW,CAAC,QAAQ,IAAI,CAAC;CAClC,CAAC,GACD,IACF;CACA,MAAM,SAAS,OAAO,SAAS;CAC/B,MAAM,YAAY,WAAW,KAAA,IAAY,KAAA,IAAY,IAAI,eAAe,MAAM;CAC9E,OAAO;EACL,KAAK,aAAa,OAAO,SAAS,WAAW,cAAc,KAAK,MAAM,MAAM,SAAS,MAAM,aAAa,SAAS,QAAQ,GAAG,GAAG,YAAY,kBAAkB,UAAU,IAAI,KAAK;EAChL,UAAU;GAAC,GAAG,MAAM;GAAU,GAAG,SAAS;GAAU,GAAI,WAAW,YAAY,CAAC;EAAE;EAClF,MAAM;GAAC,GAAG,MAAM;GAAM,GAAG,SAAS;GAAM,GAAI,WAAW,QAAQ,CAAC;EAAE;CACpE;AACF;;AAGA,SAAS,kBAAkB,OAAkD;CAC3E,OAAO,SAAS,KAAK,MAAM,WAAW,SAAS,cAAc,SAAS,aAAa,SAAS,YAAY;AAC1G"}

package/build/expressions/codecs.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_utils = require("../utils.cjs");
+const require_TypeInfo = require("../TypeInfo.cjs");
 const require_Expr = require("../Expr.cjs");
 let node_util = require("node:util");
 //#region src/expressions/codecs.ts
@@ -10,7 +11,7 @@ let node_util = require("node:util");
 */
 function chooseExpressionCodec(parsed) {
 	const leaves = expressionLeaves(parsed);
-	const expressions = leaves.filter((v) => v instanceof require_Expr.BaseExpr);
+	const expressions = leaves.flatMap((leaf) => "codec" in leaf ? [leaf.codec] : []);
 	const first = expressions[0];
 	if (first) {
 		for (const other of expressions.slice(1)) {
@@ -26,10 +27,10 @@ function chooseExpressionCodec(parsed) {
 				throw new Error(`Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(", ")}`);
 			}
 		}
-		for (const leaf of leaves) if (!(leaf instanceof require_Expr.BaseExpr)) checkLiteral(leaf.value, first.outputType);
+		for (const leaf of leaves) if ("literal" in leaf) checkLiteral(leaf.literal.value, first.outputType);
 		return first;
 	}
-	const literals = leaves.filter((v) => !(v instanceof require_Expr.BaseExpr));
+	const literals = leaves.flatMap((leaf) => "literal" in leaf ? [leaf.literal] : []);
 	const types = literals.map((v) => literalType(v.value)).filter((v) => v !== void 0);
 	for (const literal of literals) checkLiteral(literal.value, types[0]);
 	return new LiteralCodec(types[0] ?? {
@@ -55,9 +56,17 @@ var LiteralCodec = class {
 * Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.
 */
 function expressionLeaves(parsed) {
-	if (parsed instanceof require_Expr.BaseExpr) return [parsed];
+	if (parsed instanceof require_Expr.BaseExpr) return [{ codec: parsed }];
 	switch (parsed.kind) {
-		case "literal": return [parsed];
+		case "literal": return [{ literal: parsed }];
+		case "arrayAgg": {
+			const valueCodec = chooseExpressionCodec(parsed.value);
+			return [{ codec: {
+				outputType: require_TypeInfo.arrayOutputType(valueCodec.outputType),
+				encode: (value) => Array.isArray(value) ? value.map((element) => valueCodec.encode(element)) : value,
+				decode: (value) => Array.isArray(value) ? value.map((element) => valueCodec.decode(element)) : value
+			} }];
+		}
 		case "coalesce": return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));
 		case "nullIf": return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];
 		case "greatest":

package/build/expressions/codecs.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"codecs.cjs","names":["BaseExpr","assertNever","inspect"],"sources":["../../src/expressions/codecs.ts"],"sourcesContent":["import { inspect } from \"node:util\";\n\nimport { BaseExpr } from \"../Expr.ts\";\nimport type { TypeInfo } from \"../TypeInfo.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport type { ParsedExpression, ParsedLiteralExpression, ResultCodec } from \"./types.ts\";\n\n/**\n * Chooses one decoder for all possible result values. Columns must agree on a compatible SQL type and domain;\n * literals use that column's encoder. This is conservative: PostgreSQL may accept other combinations,\n * but Joist cannot safely choose their decoder. I.e. Author.id and Book.id both store integers but use different tags.\n */\nexport function chooseExpressionCodec(parsed: ParsedExpression): ResultCodec {\n  const leaves = expressionLeaves(parsed);\n  const expressions = leaves.filter((v): v is BaseExpr => v instanceof BaseExpr);\n  const first = expressions[0];\n  if (first) {\n    for (const other of expressions.slice(1)) {\n      if (other === first) continue;\n      const a = first.outputType;\n      const b = other.outputType;\n      if (!a || !b || !compatibleDbTypes(a.dbType, b.dbType) || a.domain !== b.domain || a.idMeta !== b.idMeta) {\n        const mismatches =\n          !a || !b\n            ? [\"unknown codec\"]\n            : [\n                ...(!compatibleDbTypes(a.dbType, b.dbType) ? [\"SQL type\"] : []),\n                ...(a.domain !== b.domain ? [\"domain\"] : []),\n                ...(a.idMeta !== b.idMeta ? [\"ID target\"] : []),\n              ];\n        throw new Error(\n          `Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(\", \")}`,\n        );\n      }\n    }\n    for (const leaf of leaves) {\n      if (!(leaf instanceof BaseExpr)) checkLiteral(leaf.value, first.outputType);\n    }\n    return first;\n  }\n  const literals = leaves.filter((v): v is ParsedLiteralExpression => !(v instanceof BaseExpr));\n  const types = literals.map((v) => literalType(v.value)).filter((v) => v !== undefined);\n  for (const literal of literals) checkLiteral(literal.value, types[0]);\n  return new LiteralCodec(types[0] ?? { dbType: \"text\", domain: String });\n}\n\n/** Gives literal-only expressions a SQL type so PostgreSQL does not return numbers as text. */\nclass LiteralCodec {\n  constructor(readonly outputType: TypeInfo) {}\n\n  encode(value: unknown): unknown {\n    return value;\n  }\n\n  decode(value: unknown): unknown {\n    return this.outputType.domain === BigInt ? BigInt(value as string) : value;\n  }\n}\n\n/**\n * Finds parsed operands that share a codec, including NULLIF's comparison operand but not CASE conditions.\n * Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.\n */\nfunction expressionLeaves(parsed: ParsedExpression): (BaseExpr | ParsedLiteralExpression)[] {\n  if (parsed instanceof BaseExpr) return [parsed];\n  switch (parsed.kind) {\n    case \"literal\":\n      return [parsed];\n    case \"coalesce\":\n      return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));\n    case \"nullIf\":\n      return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];\n    case \"greatest\":\n    case \"least\":\n      return parsed.values.flatMap((value) => expressionLeaves(value));\n    case \"case\":\n      return [\n        ...parsed.whens.flatMap((entry) => expressionLeaves(entry.then)),\n        ...(parsed.else ? expressionLeaves(parsed.else) : []),\n      ];\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Supplies predictable PostgreSQL types for standalone primitive literals. */\nfunction literalType(value: unknown): TypeInfo | undefined {\n  if (value === null) return undefined;\n  if (typeof value === \"string\") return { dbType: \"text\", domain: String, arrayElementSafe: true };\n  if (typeof value === \"number\") return { dbType: \"float8\", domain: Number, arrayElementSafe: true };\n  if (typeof value === \"boolean\") return { dbType: \"bool\", domain: Boolean, arrayElementSafe: true };\n  if (typeof value === \"bigint\") return { dbType: \"int8\", domain: BigInt };\n  if (value instanceof Date) return { dbType: \"timestamptz\", domain: Date };\n  throw new Error(\"Object and array literals need an expression with a matching codec\");\n}\n\n/** Rejects primitive literals that disagree with the column; custom values are checked by their encoder. */\nfunction checkLiteral(value: unknown, type: TypeInfo | undefined): void {\n  if (value === null || !type) return;\n  const domain = type.domain;\n  if (\n    (domain === String && typeof value !== \"string\") ||\n    (domain === Number && typeof value !== \"number\") ||\n    (domain === Boolean && typeof value !== \"boolean\") ||\n    (domain === BigInt && typeof value !== \"bigint\") ||\n    (domain === Date && !(value instanceof Date))\n  ) {\n    throw new Error(\n      `Expression values must have compatible types: expected ${describeType(type)}, got ${inspect(value)} (${typeof value})`,\n    );\n  }\n}\n\n/** Names the storage type, conversion domain, and entity tag involved in a codec mismatch. */\nfunction describeType(type: TypeInfo | undefined): string {\n  if (!type) return \"unknown codec\";\n  const domain = typeof type.domain === \"function\" ? type.domain.name : inspect(type.domain, { depth: 0 });\n  return `${type.dbType} (domain ${domain}${type.idMeta ? `, ID target ${type.idMeta.type}` : \"\"})`;\n}\n\nconst compatibleStringDbTypes = new Set([\"text\", \"varchar\"]);\n\n/** Allows PostgreSQL scalar string types that resolve to a common string result. */\nfunction compatibleDbTypes(a: string, b: string): boolean {\n  return a === b || (compatibleStringDbTypes.has(a) && compatibleStringDbTypes.has(b));\n}\n"],"mappings":"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"}
+{"version":3,"file":"codecs.cjs","names":["BaseExpr","arrayOutputType","assertNever","inspect"],"sources":["../../src/expressions/codecs.ts"],"sourcesContent":["import { inspect } from \"node:util\";\n\nimport { BaseExpr } from \"../Expr.ts\";\nimport { type TypeInfo, arrayOutputType } from \"../TypeInfo.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport type { ParsedExpression, ParsedLiteralExpression, ResultCodec } from \"./types.ts\";\n\n/**\n * Chooses one decoder for all possible result values. Columns must agree on a compatible SQL type and domain;\n * literals use that column's encoder. This is conservative: PostgreSQL may accept other combinations,\n * but Joist cannot safely choose their decoder. I.e. Author.id and Book.id both store integers but use different tags.\n */\nexport function chooseExpressionCodec(parsed: ParsedExpression): ResultCodec {\n  const leaves = expressionLeaves(parsed);\n  const expressions = leaves.flatMap((leaf) => (\"codec\" in leaf ? [leaf.codec] : []));\n  const first = expressions[0];\n  if (first) {\n    for (const other of expressions.slice(1)) {\n      if (other === first) continue;\n      const a = first.outputType;\n      const b = other.outputType;\n      if (!a || !b || !compatibleDbTypes(a.dbType, b.dbType) || a.domain !== b.domain || a.idMeta !== b.idMeta) {\n        const mismatches =\n          !a || !b\n            ? [\"unknown codec\"]\n            : [\n                ...(!compatibleDbTypes(a.dbType, b.dbType) ? [\"SQL type\"] : []),\n                ...(a.domain !== b.domain ? [\"domain\"] : []),\n                ...(a.idMeta !== b.idMeta ? [\"ID target\"] : []),\n              ];\n        throw new Error(\n          `Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(\", \")}`,\n        );\n      }\n    }\n    for (const leaf of leaves) if (\"literal\" in leaf) checkLiteral(leaf.literal.value, first.outputType);\n    return first;\n  }\n  const literals = leaves.flatMap((leaf) => (\"literal\" in leaf ? [leaf.literal] : []));\n  const types = literals.map((v) => literalType(v.value)).filter((v) => v !== undefined);\n  for (const literal of literals) checkLiteral(literal.value, types[0]);\n  return new LiteralCodec(types[0] ?? { dbType: \"text\", domain: String });\n}\n\n/** Gives literal-only expressions a SQL type so PostgreSQL does not return numbers as text. */\nclass LiteralCodec {\n  constructor(readonly outputType: TypeInfo) {}\n\n  encode(value: unknown): unknown {\n    return value;\n  }\n\n  decode(value: unknown): unknown {\n    return this.outputType.domain === BigInt ? BigInt(value as string) : value;\n  }\n}\n\n/**\n * Finds parsed operands that share a codec, including NULLIF's comparison operand but not CASE conditions.\n * Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.\n */\nfunction expressionLeaves(parsed: ParsedExpression): CodecLeaf[] {\n  if (parsed instanceof BaseExpr) return [{ codec: parsed }];\n  switch (parsed.kind) {\n    case \"literal\":\n      return [{ literal: parsed }];\n    case \"arrayAgg\": {\n      const valueCodec = chooseExpressionCodec(parsed.value);\n      return [\n        {\n          codec: {\n            outputType: arrayOutputType(valueCodec.outputType),\n            encode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.encode(element)) : value),\n            decode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.decode(element)) : value),\n          },\n        },\n      ];\n    }\n    case \"coalesce\":\n      return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));\n    case \"nullIf\":\n      return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];\n    case \"greatest\":\n    case \"least\":\n      return parsed.values.flatMap((value) => expressionLeaves(value));\n    case \"case\":\n      return [\n        ...parsed.whens.flatMap((entry) => expressionLeaves(entry.then)),\n        ...(parsed.else ? expressionLeaves(parsed.else) : []),\n      ];\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** One result codec or one literal that will adopt a sibling codec. */\ntype CodecLeaf = { codec: ResultCodec } | { literal: ParsedLiteralExpression };\n\n/** Supplies predictable PostgreSQL types for standalone primitive literals. */\nfunction literalType(value: unknown): TypeInfo | undefined {\n  if (value === null) return undefined;\n  if (typeof value === \"string\") return { dbType: \"text\", domain: String, arrayElementSafe: true };\n  if (typeof value === \"number\") return { dbType: \"float8\", domain: Number, arrayElementSafe: true };\n  if (typeof value === \"boolean\") return { dbType: \"bool\", domain: Boolean, arrayElementSafe: true };\n  if (typeof value === \"bigint\") return { dbType: \"int8\", domain: BigInt };\n  if (value instanceof Date) return { dbType: \"timestamptz\", domain: Date };\n  throw new Error(\"Object and array literals need an expression with a matching codec\");\n}\n\n/** Rejects primitive literals that disagree with the column; custom values are checked by their encoder. */\nfunction checkLiteral(value: unknown, type: TypeInfo | undefined): void {\n  if (value === null || !type) return;\n  const domain = type.domain;\n  if (\n    (domain === String && typeof value !== \"string\") ||\n    (domain === Number && typeof value !== \"number\") ||\n    (domain === Boolean && typeof value !== \"boolean\") ||\n    (domain === BigInt && typeof value !== \"bigint\") ||\n    (domain === Date && !(value instanceof Date))\n  ) {\n    throw new Error(\n      `Expression values must have compatible types: expected ${describeType(type)}, got ${inspect(value)} (${typeof value})`,\n    );\n  }\n}\n\n/** Names the storage type, conversion domain, and entity tag involved in a codec mismatch. */\nfunction describeType(type: TypeInfo | undefined): string {\n  if (!type) return \"unknown codec\";\n  const domain = typeof type.domain === \"function\" ? type.domain.name : inspect(type.domain, { depth: 0 });\n  return `${type.dbType} (domain ${domain}${type.idMeta ? `, ID target ${type.idMeta.type}` : \"\"})`;\n}\n\nconst compatibleStringDbTypes = new Set([\"text\", \"varchar\"]);\n\n/** Allows PostgreSQL scalar string types that resolve to a common string result. */\nfunction compatibleDbTypes(a: string, b: string): boolean {\n  return a === b || (compatibleStringDbTypes.has(a) && compatibleStringDbTypes.has(b));\n}\n"],"mappings":"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"}

package/build/expressions/codecs.js

@@ -1,4 +1,5 @@
 import { assertNever } from "../utils.js";
+import { arrayOutputType } from "../TypeInfo.js";
 import { BaseExpr } from "../Expr.js";
 import { inspect } from "node:util";
 //#region src/expressions/codecs.ts
@@ -9,7 +10,7 @@ import { inspect } from "node:util";
 */
 function chooseExpressionCodec(parsed) {
 	const leaves = expressionLeaves(parsed);
-	const expressions = leaves.filter((v) => v instanceof BaseExpr);
+	const expressions = leaves.flatMap((leaf) => "codec" in leaf ? [leaf.codec] : []);
 	const first = expressions[0];
 	if (first) {
 		for (const other of expressions.slice(1)) {
@@ -25,10 +26,10 @@ function chooseExpressionCodec(parsed) {
 				throw new Error(`Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(", ")}`);
 			}
 		}
-		for (const leaf of leaves) if (!(leaf instanceof BaseExpr)) checkLiteral(leaf.value, first.outputType);
+		for (const leaf of leaves) if ("literal" in leaf) checkLiteral(leaf.literal.value, first.outputType);
 		return first;
 	}
-	const literals = leaves.filter((v) => !(v instanceof BaseExpr));
+	const literals = leaves.flatMap((leaf) => "literal" in leaf ? [leaf.literal] : []);
 	const types = literals.map((v) => literalType(v.value)).filter((v) => v !== void 0);
 	for (const literal of literals) checkLiteral(literal.value, types[0]);
 	return new LiteralCodec(types[0] ?? {
@@ -54,9 +55,17 @@ var LiteralCodec = class {
 * Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.
 */
 function expressionLeaves(parsed) {
-	if (parsed instanceof BaseExpr) return [parsed];
+	if (parsed instanceof BaseExpr) return [{ codec: parsed }];
 	switch (parsed.kind) {
-		case "literal": return [parsed];
+		case "literal": return [{ literal: parsed }];
+		case "arrayAgg": {
+			const valueCodec = chooseExpressionCodec(parsed.value);
+			return [{ codec: {
+				outputType: arrayOutputType(valueCodec.outputType),
+				encode: (value) => Array.isArray(value) ? value.map((element) => valueCodec.encode(element)) : value,
+				decode: (value) => Array.isArray(value) ? value.map((element) => valueCodec.decode(element)) : value
+			} }];
+		}
 		case "coalesce": return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));
 		case "nullIf": return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];
 		case "greatest":

package/build/expressions/codecs.js.map

@@ -1 +1 @@
-{"version":3,"file":"codecs.js","names":[],"sources":["../../src/expressions/codecs.ts"],"sourcesContent":["import { inspect } from \"node:util\";\n\nimport { BaseExpr } from \"../Expr.ts\";\nimport type { TypeInfo } from \"../TypeInfo.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport type { ParsedExpression, ParsedLiteralExpression, ResultCodec } from \"./types.ts\";\n\n/**\n * Chooses one decoder for all possible result values. Columns must agree on a compatible SQL type and domain;\n * literals use that column's encoder. This is conservative: PostgreSQL may accept other combinations,\n * but Joist cannot safely choose their decoder. I.e. Author.id and Book.id both store integers but use different tags.\n */\nexport function chooseExpressionCodec(parsed: ParsedExpression): ResultCodec {\n  const leaves = expressionLeaves(parsed);\n  const expressions = leaves.filter((v): v is BaseExpr => v instanceof BaseExpr);\n  const first = expressions[0];\n  if (first) {\n    for (const other of expressions.slice(1)) {\n      if (other === first) continue;\n      const a = first.outputType;\n      const b = other.outputType;\n      if (!a || !b || !compatibleDbTypes(a.dbType, b.dbType) || a.domain !== b.domain || a.idMeta !== b.idMeta) {\n        const mismatches =\n          !a || !b\n            ? [\"unknown codec\"]\n            : [\n                ...(!compatibleDbTypes(a.dbType, b.dbType) ? [\"SQL type\"] : []),\n                ...(a.domain !== b.domain ? [\"domain\"] : []),\n                ...(a.idMeta !== b.idMeta ? [\"ID target\"] : []),\n              ];\n        throw new Error(\n          `Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(\", \")}`,\n        );\n      }\n    }\n    for (const leaf of leaves) {\n      if (!(leaf instanceof BaseExpr)) checkLiteral(leaf.value, first.outputType);\n    }\n    return first;\n  }\n  const literals = leaves.filter((v): v is ParsedLiteralExpression => !(v instanceof BaseExpr));\n  const types = literals.map((v) => literalType(v.value)).filter((v) => v !== undefined);\n  for (const literal of literals) checkLiteral(literal.value, types[0]);\n  return new LiteralCodec(types[0] ?? { dbType: \"text\", domain: String });\n}\n\n/** Gives literal-only expressions a SQL type so PostgreSQL does not return numbers as text. */\nclass LiteralCodec {\n  constructor(readonly outputType: TypeInfo) {}\n\n  encode(value: unknown): unknown {\n    return value;\n  }\n\n  decode(value: unknown): unknown {\n    return this.outputType.domain === BigInt ? BigInt(value as string) : value;\n  }\n}\n\n/**\n * Finds parsed operands that share a codec, including NULLIF's comparison operand but not CASE conditions.\n * Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.\n */\nfunction expressionLeaves(parsed: ParsedExpression): (BaseExpr | ParsedLiteralExpression)[] {\n  if (parsed instanceof BaseExpr) return [parsed];\n  switch (parsed.kind) {\n    case \"literal\":\n      return [parsed];\n    case \"coalesce\":\n      return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));\n    case \"nullIf\":\n      return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];\n    case \"greatest\":\n    case \"least\":\n      return parsed.values.flatMap((value) => expressionLeaves(value));\n    case \"case\":\n      return [\n        ...parsed.whens.flatMap((entry) => expressionLeaves(entry.then)),\n        ...(parsed.else ? expressionLeaves(parsed.else) : []),\n      ];\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Supplies predictable PostgreSQL types for standalone primitive literals. */\nfunction literalType(value: unknown): TypeInfo | undefined {\n  if (value === null) return undefined;\n  if (typeof value === \"string\") return { dbType: \"text\", domain: String, arrayElementSafe: true };\n  if (typeof value === \"number\") return { dbType: \"float8\", domain: Number, arrayElementSafe: true };\n  if (typeof value === \"boolean\") return { dbType: \"bool\", domain: Boolean, arrayElementSafe: true };\n  if (typeof value === \"bigint\") return { dbType: \"int8\", domain: BigInt };\n  if (value instanceof Date) return { dbType: \"timestamptz\", domain: Date };\n  throw new Error(\"Object and array literals need an expression with a matching codec\");\n}\n\n/** Rejects primitive literals that disagree with the column; custom values are checked by their encoder. */\nfunction checkLiteral(value: unknown, type: TypeInfo | undefined): void {\n  if (value === null || !type) return;\n  const domain = type.domain;\n  if (\n    (domain === String && typeof value !== \"string\") ||\n    (domain === Number && typeof value !== \"number\") ||\n    (domain === Boolean && typeof value !== \"boolean\") ||\n    (domain === BigInt && typeof value !== \"bigint\") ||\n    (domain === Date && !(value instanceof Date))\n  ) {\n    throw new Error(\n      `Expression values must have compatible types: expected ${describeType(type)}, got ${inspect(value)} (${typeof value})`,\n    );\n  }\n}\n\n/** Names the storage type, conversion domain, and entity tag involved in a codec mismatch. */\nfunction describeType(type: TypeInfo | undefined): string {\n  if (!type) return \"unknown codec\";\n  const domain = typeof type.domain === \"function\" ? type.domain.name : inspect(type.domain, { depth: 0 });\n  return `${type.dbType} (domain ${domain}${type.idMeta ? `, ID target ${type.idMeta.type}` : \"\"})`;\n}\n\nconst compatibleStringDbTypes = new Set([\"text\", \"varchar\"]);\n\n/** Allows PostgreSQL scalar string types that resolve to a common string result. */\nfunction compatibleDbTypes(a: string, b: string): boolean {\n  return a === b || (compatibleStringDbTypes.has(a) && compatibleStringDbTypes.has(b));\n}\n"],"mappings":"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"}
+{"version":3,"file":"codecs.js","names":[],"sources":["../../src/expressions/codecs.ts"],"sourcesContent":["import { inspect } from \"node:util\";\n\nimport { BaseExpr } from \"../Expr.ts\";\nimport { type TypeInfo, arrayOutputType } from \"../TypeInfo.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport type { ParsedExpression, ParsedLiteralExpression, ResultCodec } from \"./types.ts\";\n\n/**\n * Chooses one decoder for all possible result values. Columns must agree on a compatible SQL type and domain;\n * literals use that column's encoder. This is conservative: PostgreSQL may accept other combinations,\n * but Joist cannot safely choose their decoder. I.e. Author.id and Book.id both store integers but use different tags.\n */\nexport function chooseExpressionCodec(parsed: ParsedExpression): ResultCodec {\n  const leaves = expressionLeaves(parsed);\n  const expressions = leaves.flatMap((leaf) => (\"codec\" in leaf ? [leaf.codec] : []));\n  const first = expressions[0];\n  if (first) {\n    for (const other of expressions.slice(1)) {\n      if (other === first) continue;\n      const a = first.outputType;\n      const b = other.outputType;\n      if (!a || !b || !compatibleDbTypes(a.dbType, b.dbType) || a.domain !== b.domain || a.idMeta !== b.idMeta) {\n        const mismatches =\n          !a || !b\n            ? [\"unknown codec\"]\n            : [\n                ...(!compatibleDbTypes(a.dbType, b.dbType) ? [\"SQL type\"] : []),\n                ...(a.domain !== b.domain ? [\"domain\"] : []),\n                ...(a.idMeta !== b.idMeta ? [\"ID target\"] : []),\n              ];\n        throw new Error(\n          `Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(\", \")}`,\n        );\n      }\n    }\n    for (const leaf of leaves) if (\"literal\" in leaf) checkLiteral(leaf.literal.value, first.outputType);\n    return first;\n  }\n  const literals = leaves.flatMap((leaf) => (\"literal\" in leaf ? [leaf.literal] : []));\n  const types = literals.map((v) => literalType(v.value)).filter((v) => v !== undefined);\n  for (const literal of literals) checkLiteral(literal.value, types[0]);\n  return new LiteralCodec(types[0] ?? { dbType: \"text\", domain: String });\n}\n\n/** Gives literal-only expressions a SQL type so PostgreSQL does not return numbers as text. */\nclass LiteralCodec {\n  constructor(readonly outputType: TypeInfo) {}\n\n  encode(value: unknown): unknown {\n    return value;\n  }\n\n  decode(value: unknown): unknown {\n    return this.outputType.domain === BigInt ? BigInt(value as string) : value;\n  }\n}\n\n/**\n * Finds parsed operands that share a codec, including NULLIF's comparison operand but not CASE conditions.\n * Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.\n */\nfunction expressionLeaves(parsed: ParsedExpression): CodecLeaf[] {\n  if (parsed instanceof BaseExpr) return [{ codec: parsed }];\n  switch (parsed.kind) {\n    case \"literal\":\n      return [{ literal: parsed }];\n    case \"arrayAgg\": {\n      const valueCodec = chooseExpressionCodec(parsed.value);\n      return [\n        {\n          codec: {\n            outputType: arrayOutputType(valueCodec.outputType),\n            encode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.encode(element)) : value),\n            decode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.decode(element)) : value),\n          },\n        },\n      ];\n    }\n    case \"coalesce\":\n      return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));\n    case \"nullIf\":\n      return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];\n    case \"greatest\":\n    case \"least\":\n      return parsed.values.flatMap((value) => expressionLeaves(value));\n    case \"case\":\n      return [\n        ...parsed.whens.flatMap((entry) => expressionLeaves(entry.then)),\n        ...(parsed.else ? expressionLeaves(parsed.else) : []),\n      ];\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** One result codec or one literal that will adopt a sibling codec. */\ntype CodecLeaf = { codec: ResultCodec } | { literal: ParsedLiteralExpression };\n\n/** Supplies predictable PostgreSQL types for standalone primitive literals. */\nfunction literalType(value: unknown): TypeInfo | undefined {\n  if (value === null) return undefined;\n  if (typeof value === \"string\") return { dbType: \"text\", domain: String, arrayElementSafe: true };\n  if (typeof value === \"number\") return { dbType: \"float8\", domain: Number, arrayElementSafe: true };\n  if (typeof value === \"boolean\") return { dbType: \"bool\", domain: Boolean, arrayElementSafe: true };\n  if (typeof value === \"bigint\") return { dbType: \"int8\", domain: BigInt };\n  if (value instanceof Date) return { dbType: \"timestamptz\", domain: Date };\n  throw new Error(\"Object and array literals need an expression with a matching codec\");\n}\n\n/** Rejects primitive literals that disagree with the column; custom values are checked by their encoder. */\nfunction checkLiteral(value: unknown, type: TypeInfo | undefined): void {\n  if (value === null || !type) return;\n  const domain = type.domain;\n  if (\n    (domain === String && typeof value !== \"string\") ||\n    (domain === Number && typeof value !== \"number\") ||\n    (domain === Boolean && typeof value !== \"boolean\") ||\n    (domain === BigInt && typeof value !== \"bigint\") ||\n    (domain === Date && !(value instanceof Date))\n  ) {\n    throw new Error(\n      `Expression values must have compatible types: expected ${describeType(type)}, got ${inspect(value)} (${typeof value})`,\n    );\n  }\n}\n\n/** Names the storage type, conversion domain, and entity tag involved in a codec mismatch. */\nfunction describeType(type: TypeInfo | undefined): string {\n  if (!type) return \"unknown codec\";\n  const domain = typeof type.domain === \"function\" ? type.domain.name : inspect(type.domain, { depth: 0 });\n  return `${type.dbType} (domain ${domain}${type.idMeta ? `, ID target ${type.idMeta.type}` : \"\"})`;\n}\n\nconst compatibleStringDbTypes = new Set([\"text\", \"varchar\"]);\n\n/** Allows PostgreSQL scalar string types that resolve to a common string result. */\nfunction compatibleDbTypes(a: string, b: string): boolean {\n  return a === b || (compatibleStringDbTypes.has(a) && compatibleStringDbTypes.has(b));\n}\n"],"mappings":";;;;;;;;;;AAYA,SAAgB,sBAAsB,QAAuC;CAC3E,MAAM,SAAS,iBAAiB,MAAM;CACtC,MAAM,cAAc,OAAO,SAAS,SAAU,WAAW,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC,CAAE;CAClF,MAAM,QAAQ,YAAY;CAC1B,IAAI,OAAO;EACT,KAAK,MAAM,SAAS,YAAY,MAAM,CAAC,GAAG;GACxC,IAAI,UAAU,OAAO;GACrB,MAAM,IAAI,MAAM;GAChB,MAAM,IAAI,MAAM;GAChB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,kBAAkB,EAAE,QAAQ,EAAE,MAAM,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ;IACxG,MAAM,aACJ,CAAC,KAAK,CAAC,IACH,CAAC,eAAe,IAChB;KACE,GAAI,CAAC,kBAAkB,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC,UAAU,IAAI,CAAC;KAC7D,GAAI,EAAE,WAAW,EAAE,SAAS,CAAC,QAAQ,IAAI,CAAC;KAC1C,GAAI,EAAE,WAAW,EAAE,SAAS,CAAC,WAAW,IAAI,CAAC;IAC/C;IACN,MAAM,IAAI,MACR,2DAA2D,aAAa,CAAC,EAAE,MAAM,aAAa,CAAC,EAAE,eAAe,WAAW,KAAK,IAAI,GACtI;GACF;EACF;EACA,KAAK,MAAM,QAAQ,QAAQ,IAAI,aAAa,MAAM,aAAa,KAAK,QAAQ,OAAO,MAAM,UAAU;EACnG,OAAO;CACT;CACA,MAAM,WAAW,OAAO,SAAS,SAAU,aAAa,OAAO,CAAC,KAAK,OAAO,IAAI,CAAC,CAAE;CACnF,MAAM,QAAQ,SAAS,KAAK,MAAM,YAAY,EAAE,KAAK,CAAC,CAAC,CAAC,QAAQ,MAAM,MAAM,KAAA,CAAS;CACrF,KAAK,MAAM,WAAW,UAAU,aAAa,QAAQ,OAAO,MAAM,EAAE;CACpE,OAAO,IAAI,aAAa,MAAM,MAAM;EAAE,QAAQ;EAAQ,QAAQ;CAAO,CAAC;AACxE;;AAGA,IAAM,eAAN,MAAmB;CACI;CAArB,YAAY,YAA+B;EAAtB,KAAA,aAAA;CAAuB;CAE5C,OAAO,OAAyB;EAC9B,OAAO;CACT;CAEA,OAAO,OAAyB;EAC9B,OAAO,KAAK,WAAW,WAAW,SAAS,OAAO,KAAe,IAAI;CACvE;AACF;;;;;AAMA,SAAS,iBAAiB,QAAuC;CAC/D,IAAI,kBAAkB,UAAU,OAAO,CAAC,EAAE,OAAO,OAAO,CAAC;CACzD,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,CAAC,EAAE,SAAS,OAAO,CAAC;EAC7B,KAAK,YAAY;GACf,MAAM,aAAa,sBAAsB,OAAO,KAAK;GACrD,OAAO,CACL,EACE,OAAO;IACL,YAAY,gBAAgB,WAAW,UAAU;IACjD,SAAS,UAAW,MAAM,QAAQ,KAAK,IAAI,MAAM,KAAK,YAAY,WAAW,OAAO,OAAO,CAAC,IAAI;IAChG,SAAS,UAAW,MAAM,QAAQ,KAAK,IAAI,MAAM,KAAK,YAAY,WAAW,OAAO,OAAO,CAAC,IAAI;GAClG,EACF,CACF;EACF;EACA,KAAK,YACH,OAAO,OAAO,WAAW,SAAS,cAAc,iBAAiB,SAAS,CAAC;EAC7E,KAAK,UACH,OAAO,CAAC,GAAG,iBAAiB,OAAO,KAAK,GAAG,GAAG,iBAAiB,OAAO,MAAM,CAAC;EAC/E,KAAK;EACL,KAAK,SACH,OAAO,OAAO,OAAO,SAAS,UAAU,iBAAiB,KAAK,CAAC;EACjE,KAAK,QACH,OAAO,CACL,GAAG,OAAO,MAAM,SAAS,UAAU,iBAAiB,MAAM,IAAI,CAAC,GAC/D,GAAI,OAAO,OAAO,iBAAiB,OAAO,IAAI,IAAI,CAAC,CACrD;EACF,SACE,OAAO,YAAY,MAAM;CAC7B;AACF;;AAMA,SAAS,YAAY,OAAsC;CACzD,IAAI,UAAU,MAAM,OAAO,KAAA;CAC3B,IAAI,OAAO,UAAU,UAAU,OAAO;EAAE,QAAQ;EAAQ,QAAQ;EAAQ,kBAAkB;CAAK;CAC/F,IAAI,OAAO,UAAU,UAAU,OAAO;EAAE,QAAQ;EAAU,QAAQ;EAAQ,kBAAkB;CAAK;CACjG,IAAI,OAAO,UAAU,WAAW,OAAO;EAAE,QAAQ;EAAQ,QAAQ;EAAS,kBAAkB;CAAK;CACjG,IAAI,OAAO,UAAU,UAAU,OAAO;EAAE,QAAQ;EAAQ,QAAQ;CAAO;CACvE,IAAI,iBAAiB,MAAM,OAAO;EAAE,QAAQ;EAAe,QAAQ;CAAK;CACxE,MAAM,IAAI,MAAM,oEAAoE;AACtF;;AAGA,SAAS,aAAa,OAAgB,MAAkC;CACtE,IAAI,UAAU,QAAQ,CAAC,MAAM;CAC7B,MAAM,SAAS,KAAK;CACpB,IACG,WAAW,UAAU,OAAO,UAAU,YACtC,WAAW,UAAU,OAAO,UAAU,YACtC,WAAW,WAAW,OAAO,UAAU,aACvC,WAAW,UAAU,OAAO,UAAU,YACtC,WAAW,QAAQ,EAAE,iBAAiB,OAEvC,MAAM,IAAI,MACR,0DAA0D,aAAa,IAAI,EAAE,QAAQ,QAAQ,KAAK,EAAE,IAAI,OAAO,MAAM,EACvH;AAEJ;;AAGA,SAAS,aAAa,MAAoC;CACxD,IAAI,CAAC,MAAM,OAAO;CAClB,MAAM,SAAS,OAAO,KAAK,WAAW,aAAa,KAAK,OAAO,OAAO,QAAQ,KAAK,QAAQ,EAAE,OAAO,EAAE,CAAC;CACvG,OAAO,GAAG,KAAK,OAAO,WAAW,SAAS,KAAK,SAAS,eAAe,KAAK,OAAO,SAAS,GAAG;AACjG;AAEA,MAAM,0CAA0B,IAAI,IAAI,CAAC,QAAQ,SAAS,CAAC;;AAG3D,SAAS,kBAAkB,GAAW,GAAoB;CACxD,OAAO,MAAM,KAAM,wBAAwB,IAAI,CAAC,KAAK,wBAAwB,IAAI,CAAC;AACpF"}

package/build/expressions/expression.cjs

@@ -1,12 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_utils = require("../utils.cjs");
 const require_Expr = require("../Expr.cjs");
+const require_expressions_case = require("./case.cjs");
 const require_expressions_coalesce = require("./coalesce.cjs");
 const require_expressions_greatest = require("./greatest.cjs");
 const require_expressions_least = require("./least.cjs");
 const require_expressions_nullIf = require("./nullIf.cjs");
 const require_expressions_parseExpression = require("./parseExpression.cjs");
-const require_expressions_case = require("./case.cjs");
+const require_expressions_arrayAgg = require("./arrayAgg.cjs");
 const require_expressions_codecs = require("./codecs.cjs");
 //#region src/expressions/expression.ts
 /** Builds a reusable SQL value expression, binding literal values as parameters. */
@@ -50,6 +51,7 @@ function expressionNullable(parsed) {
 	if (parsed instanceof require_Expr.BaseExpr) return parsed.sqlSource ? void 0 : parsed.sqlNullable;
 	switch (parsed.kind) {
 		case "literal": return parsed.value === null;
+		case "arrayAgg": return true;
 		case "nullIf": return require_expressions_nullIf.nullIfNullable();
 		case "coalesce": return require_expressions_coalesce.coalesceNullable(parsed);
 		case "greatest": return require_expressions_greatest.greatestNullable(parsed);
@@ -73,6 +75,7 @@ function expressionToSql(parsed, ctx, codec) {
 				refs: []
 			};
 		}
+		case "arrayAgg": return require_expressions_arrayAgg.arrayAggToSql(parsed, ctx, require_expressions_codecs.chooseExpressionCodec(parsed.value));
 		case "coalesce": return require_expressions_coalesce.coalesceToSql(parsed, ctx, codec);
 		case "nullIf": return require_expressions_nullIf.nullIfToSql(parsed, ctx, codec);
 		case "greatest": return require_expressions_greatest.greatestToSql(parsed, ctx, codec);

package/build/expressions/expression.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"expression.cjs","names":["parseExpressionInput","BaseExpr","chooseExpressionCodec","nullIfNullable","coalesceNullable","greatestNullable","leastNullable","caseNullable","assertNever","coalesceToSql","nullIfToSql","greatestToSql","leastToSql","caseToSql","joinFragments"],"sources":["../../src/expressions/expression.ts"],"sourcesContent":["import { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"../Expr.ts\";\nimport type { TypeInfo } from \"../TypeInfo.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { caseNullable, caseToSql } from \"./case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"./coalesce.ts\";\nimport { chooseExpressionCodec } from \"./codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"./greatest.ts\";\nimport { leastNullable, leastToSql } from \"./least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"./nullIf.ts\";\nimport { parseExpressionInput } from \"./parseExpression.ts\";\nimport type { CheckInput, ExprFromInput, ExprInput, ParsedExpression, ResultCodec } from \"./types.ts\";\n\nexport type { CaseElse, CaseWhen } from \"./case.ts\";\nexport type { CheckInput, ExprFromInput, ExprInput, ExpressionSources, ExpressionValue } from \"./types.ts\";\n\n/** Builds a reusable SQL value expression, binding literal values as parameters. */\nexport function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I> {\n  return buildExpr(input) as unknown as ExprFromInput<I>;\n}\n\n/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */\nexport function buildExpr(input: unknown): BaseExpr {\n  return new ObjectExpr(parseExpressionInput(input));\n}\n\n/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */\nclass ObjectExpr extends BaseExpr {\n  private readonly codec: ResultCodec;\n\n  constructor(private readonly parsed: ParsedExpression) {\n    super();\n    this.codec = chooseExpressionCodec(parsed);\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.codec.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    return expressionNullable(this.parsed);\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    return expressionToSql(this.parsed, ctx, this.codec);\n  }\n\n  decode(value: unknown): unknown {\n    return value == null ? value : this.codec.decode(value);\n  }\n\n  encode(value: unknown): unknown {\n    return value == null ? value : this.codec.encode(value);\n  }\n}\n\n/**\n * Reports nullability from the fields of each parsed expression kind.\n * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.\n */\nexport function expressionNullable(parsed: ParsedExpression): boolean | undefined {\n  if (parsed instanceof BaseExpr) return parsed.sqlSource ? undefined : parsed.sqlNullable;\n  switch (parsed.kind) {\n    case \"literal\":\n      return parsed.value === null;\n    case \"nullIf\":\n      return nullIfNullable();\n    case \"coalesce\":\n      return coalesceNullable(parsed);\n    case \"greatest\":\n      return greatestNullable(parsed);\n    case \"least\":\n      return leastNullable(parsed);\n    case \"case\":\n      return caseNullable(parsed);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/**\n * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.\n * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.\n */\nexport function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  if (parsed instanceof BaseExpr) return parsed.toSql(ctx);\n  switch (parsed.kind) {\n    case \"literal\": {\n      const dbType = codec.outputType?.dbType;\n      return {\n        sql: dbType ? `?::${dbType}` : \"?\",\n        bindings: [parsed.value === null ? null : codec.encode(parsed.value)],\n        refs: [],\n      };\n    }\n    case \"coalesce\":\n      return coalesceToSql(parsed, ctx, codec);\n    case \"nullIf\":\n      return nullIfToSql(parsed, ctx, codec);\n    case \"greatest\":\n      return greatestToSql(parsed, ctx, codec);\n    case \"least\":\n      return leastToSql(parsed, ctx, codec);\n    case \"case\":\n      return caseToSql(parsed, ctx, codec);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */\nexport function functionToSql(\n  name: string,\n  args: readonly ParsedExpression[],\n  ctx: ExprContext,\n  codec: ResultCodec,\n): SqlFragment {\n  const parts = joinFragments(\n    args.map((arg) => expressionToSql(arg, ctx, codec)),\n    \", \",\n  );\n  return { ...parts, sql: `${name}(${parts.sql})` };\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,SAAgB,KAAgC,OAAqD;CACnG,OAAO,UAAU,KAAK;AACxB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,OAAO,IAAI,WAAWA,oCAAAA,qBAAqB,KAAK,CAAC;AACnD;;AAGA,IAAM,aAAN,cAAyBC,aAAAA,SAAS;CAGH;CAF7B;CAEA,YAAY,QAA2C;EACrD,MAAM;EADqB,KAAA,SAAA;EAE3B,KAAK,QAAQC,2BAAAA,sBAAsB,MAAM;CAC3C;CAEA,IAAI,aAAmC;EACrC,OAAO,KAAK,MAAM;CACpB;CAEA,IAAI,cAAmC;EACrC,OAAO,mBAAmB,KAAK,MAAM;CACvC;CAEA,MAAM,KAA+B;EACnC,OAAO,gBAAgB,KAAK,QAAQ,KAAK,KAAK,KAAK;CACrD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;AACF;;;;;AAMA,SAAgB,mBAAmB,QAA+C;CAChF,IAAI,kBAAkBD,aAAAA,UAAU,OAAO,OAAO,YAAY,KAAA,IAAY,OAAO;CAC7E,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,OAAO,UAAU;EAC1B,KAAK,UACH,OAAOE,2BAAAA,eAAe;EACxB,KAAK,YACH,OAAOC,6BAAAA,iBAAiB,MAAM;EAChC,KAAK,YACH,OAAOC,6BAAAA,iBAAiB,MAAM;EAChC,KAAK,SACH,OAAOC,0BAAAA,cAAc,MAAM;EAC7B,KAAK,QACH,OAAOC,yBAAAA,aAAa,MAAM;EAC5B,SACE,OAAOC,cAAAA,YAAY,MAAM;CAC7B;AACF;;;;;AAMA,SAAgB,gBAAgB,QAA0B,KAAkB,OAAiC;CAC3G,IAAI,kBAAkBP,aAAAA,UAAU,OAAO,OAAO,MAAM,GAAG;CACvD,QAAQ,OAAO,MAAf;EACE,KAAK,WAAW;GACd,MAAM,SAAS,MAAM,YAAY;GACjC,OAAO;IACL,KAAK,SAAS,MAAM,WAAW;IAC/B,UAAU,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC;IACpE,MAAM,CAAC;GACT;EACF;EACA,KAAK,YACH,OAAOQ,6BAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,UACH,OAAOC,2BAAAA,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,YACH,OAAOC,6BAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,SACH,OAAOC,0BAAAA,WAAW,QAAQ,KAAK,KAAK;EACtC,KAAK,QACH,OAAOC,yBAAAA,UAAU,QAAQ,KAAK,KAAK;EACrC,SACE,OAAOL,cAAAA,YAAY,MAAM;CAC7B;AACF;;AAGA,SAAgB,cACd,MACA,MACA,KACA,OACa;CACb,MAAM,QAAQM,aAAAA,cACZ,KAAK,KAAK,QAAQ,gBAAgB,KAAK,KAAK,KAAK,CAAC,GAClD,IACF;CACA,OAAO;EAAE,GAAG;EAAO,KAAK,GAAG,KAAK,GAAG,MAAM,IAAI;CAAG;AAClD"}
+{"version":3,"file":"expression.cjs","names":["parseExpressionInput","BaseExpr","chooseExpressionCodec","nullIfNullable","coalesceNullable","greatestNullable","leastNullable","caseNullable","assertNever","arrayAggToSql","coalesceToSql","nullIfToSql","greatestToSql","leastToSql","caseToSql","joinFragments"],"sources":["../../src/expressions/expression.ts"],"sourcesContent":["import { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"../Expr.ts\";\nimport type { TypeInfo } from \"../TypeInfo.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { arrayAggToSql } from \"./arrayAgg.ts\";\nimport { caseNullable, caseToSql } from \"./case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"./coalesce.ts\";\nimport { chooseExpressionCodec } from \"./codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"./greatest.ts\";\nimport { leastNullable, leastToSql } from \"./least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"./nullIf.ts\";\nimport { parseExpressionInput } from \"./parseExpression.ts\";\nimport type { CheckInput, ExprFromInput, ExprInput, ParsedExpression, ResultCodec } from \"./types.ts\";\n\nexport type { CaseElse, CaseWhen } from \"./case.ts\";\nexport type { CheckInput, ExprFromInput, ExprInput, ExpressionSources, ExpressionValue } from \"./types.ts\";\n\n/** Builds a reusable SQL value expression, binding literal values as parameters. */\nexport function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I> {\n  return buildExpr(input) as unknown as ExprFromInput<I>;\n}\n\n/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */\nexport function buildExpr(input: unknown): BaseExpr {\n  return new ObjectExpr(parseExpressionInput(input));\n}\n\n/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */\nclass ObjectExpr extends BaseExpr {\n  private readonly codec: ResultCodec;\n\n  constructor(private readonly parsed: ParsedExpression) {\n    super();\n    this.codec = chooseExpressionCodec(parsed);\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.codec.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    return expressionNullable(this.parsed);\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    return expressionToSql(this.parsed, ctx, this.codec);\n  }\n\n  decode(value: unknown): unknown {\n    return value == null ? value : this.codec.decode(value);\n  }\n\n  encode(value: unknown): unknown {\n    return value == null ? value : this.codec.encode(value);\n  }\n}\n\n/**\n * Reports nullability from the fields of each parsed expression kind.\n * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.\n */\nexport function expressionNullable(parsed: ParsedExpression): boolean | undefined {\n  if (parsed instanceof BaseExpr) return parsed.sqlSource ? undefined : parsed.sqlNullable;\n  switch (parsed.kind) {\n    case \"literal\":\n      return parsed.value === null;\n    case \"arrayAgg\":\n      return true;\n    case \"nullIf\":\n      return nullIfNullable();\n    case \"coalesce\":\n      return coalesceNullable(parsed);\n    case \"greatest\":\n      return greatestNullable(parsed);\n    case \"least\":\n      return leastNullable(parsed);\n    case \"case\":\n      return caseNullable(parsed);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/**\n * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.\n * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.\n */\nexport function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  if (parsed instanceof BaseExpr) return parsed.toSql(ctx);\n  switch (parsed.kind) {\n    case \"literal\": {\n      const dbType = codec.outputType?.dbType;\n      return {\n        sql: dbType ? `?::${dbType}` : \"?\",\n        bindings: [parsed.value === null ? null : codec.encode(parsed.value)],\n        refs: [],\n      };\n    }\n    case \"arrayAgg\":\n      return arrayAggToSql(parsed, ctx, chooseExpressionCodec(parsed.value));\n    case \"coalesce\":\n      return coalesceToSql(parsed, ctx, codec);\n    case \"nullIf\":\n      return nullIfToSql(parsed, ctx, codec);\n    case \"greatest\":\n      return greatestToSql(parsed, ctx, codec);\n    case \"least\":\n      return leastToSql(parsed, ctx, codec);\n    case \"case\":\n      return caseToSql(parsed, ctx, codec);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */\nexport function functionToSql(\n  name: string,\n  args: readonly ParsedExpression[],\n  ctx: ExprContext,\n  codec: ResultCodec,\n): SqlFragment {\n  const parts = joinFragments(\n    args.map((arg) => expressionToSql(arg, ctx, codec)),\n    \", \",\n  );\n  return { ...parts, sql: `${name}(${parts.sql})` };\n}\n"],"mappings":";;;;;;;;;;;;;AAiBA,SAAgB,KAAgC,OAAqD;CACnG,OAAO,UAAU,KAAK;AACxB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,OAAO,IAAI,WAAWA,oCAAAA,qBAAqB,KAAK,CAAC;AACnD;;AAGA,IAAM,aAAN,cAAyBC,aAAAA,SAAS;CAGH;CAF7B;CAEA,YAAY,QAA2C;EACrD,MAAM;EADqB,KAAA,SAAA;EAE3B,KAAK,QAAQC,2BAAAA,sBAAsB,MAAM;CAC3C;CAEA,IAAI,aAAmC;EACrC,OAAO,KAAK,MAAM;CACpB;CAEA,IAAI,cAAmC;EACrC,OAAO,mBAAmB,KAAK,MAAM;CACvC;CAEA,MAAM,KAA+B;EACnC,OAAO,gBAAgB,KAAK,QAAQ,KAAK,KAAK,KAAK;CACrD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;AACF;;;;;AAMA,SAAgB,mBAAmB,QAA+C;CAChF,IAAI,kBAAkBD,aAAAA,UAAU,OAAO,OAAO,YAAY,KAAA,IAAY,OAAO;CAC7E,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,OAAO,UAAU;EAC1B,KAAK,YACH,OAAO;EACT,KAAK,UACH,OAAOE,2BAAAA,eAAe;EACxB,KAAK,YACH,OAAOC,6BAAAA,iBAAiB,MAAM;EAChC,KAAK,YACH,OAAOC,6BAAAA,iBAAiB,MAAM;EAChC,KAAK,SACH,OAAOC,0BAAAA,cAAc,MAAM;EAC7B,KAAK,QACH,OAAOC,yBAAAA,aAAa,MAAM;EAC5B,SACE,OAAOC,cAAAA,YAAY,MAAM;CAC7B;AACF;;;;;AAMA,SAAgB,gBAAgB,QAA0B,KAAkB,OAAiC;CAC3G,IAAI,kBAAkBP,aAAAA,UAAU,OAAO,OAAO,MAAM,GAAG;CACvD,QAAQ,OAAO,MAAf;EACE,KAAK,WAAW;GACd,MAAM,SAAS,MAAM,YAAY;GACjC,OAAO;IACL,KAAK,SAAS,MAAM,WAAW;IAC/B,UAAU,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC;IACpE,MAAM,CAAC;GACT;EACF;EACA,KAAK,YACH,OAAOQ,6BAAAA,cAAc,QAAQ,KAAKP,2BAAAA,sBAAsB,OAAO,KAAK,CAAC;EACvE,KAAK,YACH,OAAOQ,6BAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,UACH,OAAOC,2BAAAA,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,YACH,OAAOC,6BAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,SACH,OAAOC,0BAAAA,WAAW,QAAQ,KAAK,KAAK;EACtC,KAAK,QACH,OAAOC,yBAAAA,UAAU,QAAQ,KAAK,KAAK;EACrC,SACE,OAAON,cAAAA,YAAY,MAAM;CAC7B;AACF;;AAGA,SAAgB,cACd,MACA,MACA,KACA,OACa;CACb,MAAM,QAAQO,aAAAA,cACZ,KAAK,KAAK,QAAQ,gBAAgB,KAAK,KAAK,KAAK,CAAC,GAClD,IACF;CACA,OAAO;EAAE,GAAG;EAAO,KAAK,GAAG,KAAK,GAAG,MAAM,IAAI;CAAG;AAClD"}

package/build/expressions/expression.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"expression.d.cts","names":[],"sources":["../../src/expressions/expression.ts"],"mappings":";;;;;iBAgBgB,WAAW,UAAU,WAAW,OAAO,IAAI,WAAW,QAAQ,MAAM,cAAc;;iBAKlF,UAAU,iBAAiB;;;;;iBAsC3B,mBAAmB,QAAQ;;;;;iBAwB3B,gBAAgB,QAAQ,kBAAkB,KAAK,aAAa,OAAO,cAAc;;iBA2BjF,cACd,cACA,eAAe,oBACf,KAAK,aACL,OAAO,cACN"}
+{"version":3,"file":"expression.d.cts","names":[],"sources":["../../src/expressions/expression.ts"],"mappings":";;;;;iBAiBgB,WAAW,UAAU,WAAW,OAAO,IAAI,WAAW,QAAQ,MAAM,cAAc;;iBAKlF,UAAU,iBAAiB;;;;;iBAsC3B,mBAAmB,QAAQ;;;;;iBA0B3B,gBAAgB,QAAQ,kBAAkB,KAAK,aAAa,OAAO,cAAc;;iBA6BjF,cACd,cACA,eAAe,oBACf,KAAK,aACL,OAAO,cACN"}

package/build/expressions/expression.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"expression.d.mts","names":[],"sources":["../../src/expressions/expression.ts"],"mappings":";;;;;iBAgBgB,WAAW,UAAU,WAAW,OAAO,IAAI,WAAW,QAAQ,MAAM,cAAc;;iBAKlF,UAAU,iBAAiB;;;;;iBAsC3B,mBAAmB,QAAQ;;;;;iBAwB3B,gBAAgB,QAAQ,kBAAkB,KAAK,aAAa,OAAO,cAAc;;iBA2BjF,cACd,cACA,eAAe,oBACf,KAAK,aACL,OAAO,cACN"}
+{"version":3,"file":"expression.d.mts","names":[],"sources":["../../src/expressions/expression.ts"],"mappings":";;;;;iBAiBgB,WAAW,UAAU,WAAW,OAAO,IAAI,WAAW,QAAQ,MAAM,cAAc;;iBAKlF,UAAU,iBAAiB;;;;;iBAsC3B,mBAAmB,QAAQ;;;;;iBA0B3B,gBAAgB,QAAQ,kBAAkB,KAAK,aAAa,OAAO,cAAc;;iBA6BjF,cACd,cACA,eAAe,oBACf,KAAK,aACL,OAAO,cACN"}

package/build/expressions/expression.js

@@ -1,11 +1,12 @@
 import { assertNever } from "../utils.js";
 import { BaseExpr, joinFragments } from "../Expr.js";
+import { caseNullable, caseToSql } from "./case.js";
 import { coalesceNullable, coalesceToSql } from "./coalesce.js";
 import { greatestNullable, greatestToSql } from "./greatest.js";
 import { leastNullable, leastToSql } from "./least.js";
 import { nullIfNullable, nullIfToSql } from "./nullIf.js";
 import { parseExpressionInput } from "./parseExpression.js";
-import { caseNullable, caseToSql } from "./case.js";
+import { arrayAggToSql } from "./arrayAgg.js";
 import { chooseExpressionCodec } from "./codecs.js";
 //#region src/expressions/expression.ts
 /** Builds a reusable SQL value expression, binding literal values as parameters. */
@@ -49,6 +50,7 @@ function expressionNullable(parsed) {
 	if (parsed instanceof BaseExpr) return parsed.sqlSource ? void 0 : parsed.sqlNullable;
 	switch (parsed.kind) {
 		case "literal": return parsed.value === null;
+		case "arrayAgg": return true;
 		case "nullIf": return nullIfNullable();
 		case "coalesce": return coalesceNullable(parsed);
 		case "greatest": return greatestNullable(parsed);
@@ -72,6 +74,7 @@ function expressionToSql(parsed, ctx, codec) {
 				refs: []
 			};
 		}
+		case "arrayAgg": return arrayAggToSql(parsed, ctx, chooseExpressionCodec(parsed.value));
 		case "coalesce": return coalesceToSql(parsed, ctx, codec);
 		case "nullIf": return nullIfToSql(parsed, ctx, codec);
 		case "greatest": return greatestToSql(parsed, ctx, codec);

package/build/expressions/expression.js.map

@@ -1 +1 @@
-{"version":3,"file":"expression.js","names":[],"sources":["../../src/expressions/expression.ts"],"sourcesContent":["import { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"../Expr.ts\";\nimport type { TypeInfo } from \"../TypeInfo.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { caseNullable, caseToSql } from \"./case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"./coalesce.ts\";\nimport { chooseExpressionCodec } from \"./codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"./greatest.ts\";\nimport { leastNullable, leastToSql } from \"./least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"./nullIf.ts\";\nimport { parseExpressionInput } from \"./parseExpression.ts\";\nimport type { CheckInput, ExprFromInput, ExprInput, ParsedExpression, ResultCodec } from \"./types.ts\";\n\nexport type { CaseElse, CaseWhen } from \"./case.ts\";\nexport type { CheckInput, ExprFromInput, ExprInput, ExpressionSources, ExpressionValue } from \"./types.ts\";\n\n/** Builds a reusable SQL value expression, binding literal values as parameters. */\nexport function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I> {\n  return buildExpr(input) as unknown as ExprFromInput<I>;\n}\n\n/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */\nexport function buildExpr(input: unknown): BaseExpr {\n  return new ObjectExpr(parseExpressionInput(input));\n}\n\n/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */\nclass ObjectExpr extends BaseExpr {\n  private readonly codec: ResultCodec;\n\n  constructor(private readonly parsed: ParsedExpression) {\n    super();\n    this.codec = chooseExpressionCodec(parsed);\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.codec.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    return expressionNullable(this.parsed);\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    return expressionToSql(this.parsed, ctx, this.codec);\n  }\n\n  decode(value: unknown): unknown {\n    return value == null ? value : this.codec.decode(value);\n  }\n\n  encode(value: unknown): unknown {\n    return value == null ? value : this.codec.encode(value);\n  }\n}\n\n/**\n * Reports nullability from the fields of each parsed expression kind.\n * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.\n */\nexport function expressionNullable(parsed: ParsedExpression): boolean | undefined {\n  if (parsed instanceof BaseExpr) return parsed.sqlSource ? undefined : parsed.sqlNullable;\n  switch (parsed.kind) {\n    case \"literal\":\n      return parsed.value === null;\n    case \"nullIf\":\n      return nullIfNullable();\n    case \"coalesce\":\n      return coalesceNullable(parsed);\n    case \"greatest\":\n      return greatestNullable(parsed);\n    case \"least\":\n      return leastNullable(parsed);\n    case \"case\":\n      return caseNullable(parsed);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/**\n * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.\n * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.\n */\nexport function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  if (parsed instanceof BaseExpr) return parsed.toSql(ctx);\n  switch (parsed.kind) {\n    case \"literal\": {\n      const dbType = codec.outputType?.dbType;\n      return {\n        sql: dbType ? `?::${dbType}` : \"?\",\n        bindings: [parsed.value === null ? null : codec.encode(parsed.value)],\n        refs: [],\n      };\n    }\n    case \"coalesce\":\n      return coalesceToSql(parsed, ctx, codec);\n    case \"nullIf\":\n      return nullIfToSql(parsed, ctx, codec);\n    case \"greatest\":\n      return greatestToSql(parsed, ctx, codec);\n    case \"least\":\n      return leastToSql(parsed, ctx, codec);\n    case \"case\":\n      return caseToSql(parsed, ctx, codec);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */\nexport function functionToSql(\n  name: string,\n  args: readonly ParsedExpression[],\n  ctx: ExprContext,\n  codec: ResultCodec,\n): SqlFragment {\n  const parts = joinFragments(\n    args.map((arg) => expressionToSql(arg, ctx, codec)),\n    \", \",\n  );\n  return { ...parts, sql: `${name}(${parts.sql})` };\n}\n"],"mappings":";;;;;;;;;;;AAgBA,SAAgB,KAAgC,OAAqD;CACnG,OAAO,UAAU,KAAK;AACxB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,OAAO,IAAI,WAAW,qBAAqB,KAAK,CAAC;AACnD;;AAGA,IAAM,aAAN,cAAyB,SAAS;CAGH;CAF7B;CAEA,YAAY,QAA2C;EACrD,MAAM;EADqB,KAAA,SAAA;EAE3B,KAAK,QAAQ,sBAAsB,MAAM;CAC3C;CAEA,IAAI,aAAmC;EACrC,OAAO,KAAK,MAAM;CACpB;CAEA,IAAI,cAAmC;EACrC,OAAO,mBAAmB,KAAK,MAAM;CACvC;CAEA,MAAM,KAA+B;EACnC,OAAO,gBAAgB,KAAK,QAAQ,KAAK,KAAK,KAAK;CACrD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;AACF;;;;;AAMA,SAAgB,mBAAmB,QAA+C;CAChF,IAAI,kBAAkB,UAAU,OAAO,OAAO,YAAY,KAAA,IAAY,OAAO;CAC7E,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,OAAO,UAAU;EAC1B,KAAK,UACH,OAAO,eAAe;EACxB,KAAK,YACH,OAAO,iBAAiB,MAAM;EAChC,KAAK,YACH,OAAO,iBAAiB,MAAM;EAChC,KAAK,SACH,OAAO,cAAc,MAAM;EAC7B,KAAK,QACH,OAAO,aAAa,MAAM;EAC5B,SACE,OAAO,YAAY,MAAM;CAC7B;AACF;;;;;AAMA,SAAgB,gBAAgB,QAA0B,KAAkB,OAAiC;CAC3G,IAAI,kBAAkB,UAAU,OAAO,OAAO,MAAM,GAAG;CACvD,QAAQ,OAAO,MAAf;EACE,KAAK,WAAW;GACd,MAAM,SAAS,MAAM,YAAY;GACjC,OAAO;IACL,KAAK,SAAS,MAAM,WAAW;IAC/B,UAAU,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC;IACpE,MAAM,CAAC;GACT;EACF;EACA,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,UACH,OAAO,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,SACH,OAAO,WAAW,QAAQ,KAAK,KAAK;EACtC,KAAK,QACH,OAAO,UAAU,QAAQ,KAAK,KAAK;EACrC,SACE,OAAO,YAAY,MAAM;CAC7B;AACF;;AAGA,SAAgB,cACd,MACA,MACA,KACA,OACa;CACb,MAAM,QAAQ,cACZ,KAAK,KAAK,QAAQ,gBAAgB,KAAK,KAAK,KAAK,CAAC,GAClD,IACF;CACA,OAAO;EAAE,GAAG;EAAO,KAAK,GAAG,KAAK,GAAG,MAAM,IAAI;CAAG;AAClD"}
+{"version":3,"file":"expression.js","names":[],"sources":["../../src/expressions/expression.ts"],"sourcesContent":["import { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"../Expr.ts\";\nimport type { TypeInfo } from \"../TypeInfo.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { arrayAggToSql } from \"./arrayAgg.ts\";\nimport { caseNullable, caseToSql } from \"./case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"./coalesce.ts\";\nimport { chooseExpressionCodec } from \"./codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"./greatest.ts\";\nimport { leastNullable, leastToSql } from \"./least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"./nullIf.ts\";\nimport { parseExpressionInput } from \"./parseExpression.ts\";\nimport type { CheckInput, ExprFromInput, ExprInput, ParsedExpression, ResultCodec } from \"./types.ts\";\n\nexport type { CaseElse, CaseWhen } from \"./case.ts\";\nexport type { CheckInput, ExprFromInput, ExprInput, ExpressionSources, ExpressionValue } from \"./types.ts\";\n\n/** Builds a reusable SQL value expression, binding literal values as parameters. */\nexport function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I> {\n  return buildExpr(input) as unknown as ExprFromInput<I>;\n}\n\n/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */\nexport function buildExpr(input: unknown): BaseExpr {\n  return new ObjectExpr(parseExpressionInput(input));\n}\n\n/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */\nclass ObjectExpr extends BaseExpr {\n  private readonly codec: ResultCodec;\n\n  constructor(private readonly parsed: ParsedExpression) {\n    super();\n    this.codec = chooseExpressionCodec(parsed);\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.codec.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    return expressionNullable(this.parsed);\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    return expressionToSql(this.parsed, ctx, this.codec);\n  }\n\n  decode(value: unknown): unknown {\n    return value == null ? value : this.codec.decode(value);\n  }\n\n  encode(value: unknown): unknown {\n    return value == null ? value : this.codec.encode(value);\n  }\n}\n\n/**\n * Reports nullability from the fields of each parsed expression kind.\n * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.\n */\nexport function expressionNullable(parsed: ParsedExpression): boolean | undefined {\n  if (parsed instanceof BaseExpr) return parsed.sqlSource ? undefined : parsed.sqlNullable;\n  switch (parsed.kind) {\n    case \"literal\":\n      return parsed.value === null;\n    case \"arrayAgg\":\n      return true;\n    case \"nullIf\":\n      return nullIfNullable();\n    case \"coalesce\":\n      return coalesceNullable(parsed);\n    case \"greatest\":\n      return greatestNullable(parsed);\n    case \"least\":\n      return leastNullable(parsed);\n    case \"case\":\n      return caseNullable(parsed);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/**\n * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.\n * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.\n */\nexport function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  if (parsed instanceof BaseExpr) return parsed.toSql(ctx);\n  switch (parsed.kind) {\n    case \"literal\": {\n      const dbType = codec.outputType?.dbType;\n      return {\n        sql: dbType ? `?::${dbType}` : \"?\",\n        bindings: [parsed.value === null ? null : codec.encode(parsed.value)],\n        refs: [],\n      };\n    }\n    case \"arrayAgg\":\n      return arrayAggToSql(parsed, ctx, chooseExpressionCodec(parsed.value));\n    case \"coalesce\":\n      return coalesceToSql(parsed, ctx, codec);\n    case \"nullIf\":\n      return nullIfToSql(parsed, ctx, codec);\n    case \"greatest\":\n      return greatestToSql(parsed, ctx, codec);\n    case \"least\":\n      return leastToSql(parsed, ctx, codec);\n    case \"case\":\n      return caseToSql(parsed, ctx, codec);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */\nexport function functionToSql(\n  name: string,\n  args: readonly ParsedExpression[],\n  ctx: ExprContext,\n  codec: ResultCodec,\n): SqlFragment {\n  const parts = joinFragments(\n    args.map((arg) => expressionToSql(arg, ctx, codec)),\n    \", \",\n  );\n  return { ...parts, sql: `${name}(${parts.sql})` };\n}\n"],"mappings":";;;;;;;;;;;;AAiBA,SAAgB,KAAgC,OAAqD;CACnG,OAAO,UAAU,KAAK;AACxB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,OAAO,IAAI,WAAW,qBAAqB,KAAK,CAAC;AACnD;;AAGA,IAAM,aAAN,cAAyB,SAAS;CAGH;CAF7B;CAEA,YAAY,QAA2C;EACrD,MAAM;EADqB,KAAA,SAAA;EAE3B,KAAK,QAAQ,sBAAsB,MAAM;CAC3C;CAEA,IAAI,aAAmC;EACrC,OAAO,KAAK,MAAM;CACpB;CAEA,IAAI,cAAmC;EACrC,OAAO,mBAAmB,KAAK,MAAM;CACvC;CAEA,MAAM,KAA+B;EACnC,OAAO,gBAAgB,KAAK,QAAQ,KAAK,KAAK,KAAK;CACrD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;AACF;;;;;AAMA,SAAgB,mBAAmB,QAA+C;CAChF,IAAI,kBAAkB,UAAU,OAAO,OAAO,YAAY,KAAA,IAAY,OAAO;CAC7E,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,OAAO,UAAU;EAC1B,KAAK,YACH,OAAO;EACT,KAAK,UACH,OAAO,eAAe;EACxB,KAAK,YACH,OAAO,iBAAiB,MAAM;EAChC,KAAK,YACH,OAAO,iBAAiB,MAAM;EAChC,KAAK,SACH,OAAO,cAAc,MAAM;EAC7B,KAAK,QACH,OAAO,aAAa,MAAM;EAC5B,SACE,OAAO,YAAY,MAAM;CAC7B;AACF;;;;;AAMA,SAAgB,gBAAgB,QAA0B,KAAkB,OAAiC;CAC3G,IAAI,kBAAkB,UAAU,OAAO,OAAO,MAAM,GAAG;CACvD,QAAQ,OAAO,MAAf;EACE,KAAK,WAAW;GACd,MAAM,SAAS,MAAM,YAAY;GACjC,OAAO;IACL,KAAK,SAAS,MAAM,WAAW;IAC/B,UAAU,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC;IACpE,MAAM,CAAC;GACT;EACF;EACA,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,sBAAsB,OAAO,KAAK,CAAC;EACvE,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,UACH,OAAO,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,SACH,OAAO,WAAW,QAAQ,KAAK,KAAK;EACtC,KAAK,QACH,OAAO,UAAU,QAAQ,KAAK,KAAK;EACrC,SACE,OAAO,YAAY,MAAM;CAC7B;AACF;;AAGA,SAAgB,cACd,MACA,MACA,KACA,OACa;CACb,MAAM,QAAQ,cACZ,KAAK,KAAK,QAAQ,gBAAgB,KAAK,KAAK,KAAK,CAAC,GAClD,IACF;CACA,OAAO;EAAE,GAAG;EAAO,KAAK,GAAG,KAAK,GAAG,MAAM,IAAI;CAAG;AAClD"}

package/build/expressions/parseExpression.cjs

@@ -1,11 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_utils = require("../utils.cjs");
 const require_Expr = require("../Expr.cjs");
+const require_expressions_case = require("./case.cjs");
 const require_expressions_coalesce = require("./coalesce.cjs");
 const require_expressions_greatest = require("./greatest.cjs");
 const require_expressions_least = require("./least.cjs");
 const require_expressions_nullIf = require("./nullIf.cjs");
-const require_expressions_case = require("./case.cjs");
+const require_expressions_arrayAgg = require("./arrayAgg.cjs");
 //#region src/expressions/parseExpression.ts
 const exprNames = [
 	"coalesce",
@@ -15,7 +16,7 @@ const exprNames = [
 ];
 /** Requires an expression object at the root before parsing its nested operands. */
 function parseExpressionInput(input) {
-	if (!isObject(input) || !("case" in input) && !exprNames.some((name) => name in input)) throw new Error("expr expects an object with case, coalesce, nullIf, greatest, or least");
+	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);
 }
 /**
@@ -37,6 +38,10 @@ function parseExpression(input) {
 			default: return require_utils.assertNever(name);
 		}
 	}
+	if (isObject(input) && "arrayAgg" in input) {
+		checkKeys(input, ["arrayAgg"]);
+		return require_expressions_arrayAgg.parseArrayAggExpression(input.arrayAgg);
+	}
 	if (isObject(input) && "case" in input) {
 		checkKeys(input, ["case"]);
 		return require_expressions_case.parseCaseExpression(input.case);

package/build/expressions/parseExpression.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseExpression.cjs","names":["BaseExpr","parseCoalesceExpression","parseNullIfExpression","parseGreatestExpression","parseLeastExpression","assertNever","parseCaseExpression"],"sources":["../../src/expressions/parseExpression.ts"],"sourcesContent":["import { BaseExpr } from \"../Expr.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { parseCaseExpression } from \"./case.ts\";\nimport { parseCoalesceExpression } from \"./coalesce.ts\";\nimport { parseGreatestExpression } from \"./greatest.ts\";\nimport { parseLeastExpression } from \"./least.ts\";\nimport { parseNullIfExpression } from \"./nullIf.ts\";\nimport type { ExprName, ParsedExpression } from \"./types.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) && !exprNames.some((name) => name in input))) {\n    throw new Error(\"expr expects an object with 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) && \"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":";;;;;;;;;AAUA,MAAM,YAAY;CAAC;CAAY;CAAU;CAAY;AAAO;;AAG5D,SAAgB,qBAAqB,OAAkC;CACrE,IAAI,CAAC,SAAS,KAAK,KAAM,EAAE,UAAU,UAAU,CAAC,UAAU,MAAM,SAAS,QAAQ,KAAK,GACpF,MAAM,IAAI,MAAM,wEAAwE;CAE1F,OAAO,gBAAgB,KAAK;AAC9B;;;;;;AAOA,SAAgB,gBAAgB,OAAkC;CAChE,IAAI,iBAAiBA,aAAAA,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,6BAAAA,wBAAwB,MAAM,QAAQ;GAC/C,KAAK,UACH,OAAOC,2BAAAA,sBAAsB,MAAM,MAAM;GAC3C,KAAK,YACH,OAAOC,6BAAAA,wBAAwB,MAAM,QAAQ;GAC/C,KAAK,SACH,OAAOC,0BAAAA,qBAAqB,MAAM,KAAK;GACzC,SACE,OAAOC,cAAAA,YAAY,IAAI;EAC3B;CACF;CACA,IAAI,SAAS,KAAK,KAAK,UAAU,OAAO;EACtC,UAAU,OAAO,CAAC,MAAM,CAAC;EACzB,OAAOC,yBAAAA,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"}
+{"version":3,"file":"parseExpression.cjs","names":["BaseExpr","parseCoalesceExpression","parseNullIfExpression","parseGreatestExpression","parseLeastExpression","assertNever","parseArrayAggExpression","parseCaseExpression"],"sources":["../../src/expressions/parseExpression.ts"],"sourcesContent":["import { BaseExpr } from \"../Expr.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { parseArrayAggExpression } from \"./arrayAgg.ts\";\nimport { parseCaseExpression } from \"./case.ts\";\nimport { parseCoalesceExpression } from \"./coalesce.ts\";\nimport { parseGreatestExpression } from \"./greatest.ts\";\nimport { parseLeastExpression } from \"./least.ts\";\nimport { parseNullIfExpression } from \"./nullIf.ts\";\nimport type { ExprName, ParsedExpression } from \"./types.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,aAAAA,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,6BAAAA,wBAAwB,MAAM,QAAQ;GAC/C,KAAK,UACH,OAAOC,2BAAAA,sBAAsB,MAAM,MAAM;GAC3C,KAAK,YACH,OAAOC,6BAAAA,wBAAwB,MAAM,QAAQ;GAC/C,KAAK,SACH,OAAOC,0BAAAA,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,6BAAAA,wBAAwB,MAAM,QAAQ;CAC/C;CACA,IAAI,SAAS,KAAK,KAAK,UAAU,OAAO;EACtC,UAAU,OAAO,CAAC,MAAM,CAAC;EACzB,OAAOC,yBAAAA,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/expressions/parseExpression.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"parseExpression.d.cts","names":[],"sources":["../../src/expressions/parseExpression.ts"],"mappings":";;;iBAagB,qBAAqB,iBAAiB;;;;;;iBAYtC,gBAAgB,iBAAiB;;iBA2BjC,sBAAsB,gBAAgB,gBAAgB,qBAAqB;;iBAQ3E,UAAU,eAAe;;iBAOzB,SAAS,iBAAiB,SAAS"}
+{"version":3,"file":"parseExpression.d.cts","names":[],"sources":["../../src/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/expressions/parseExpression.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"parseExpression.d.mts","names":[],"sources":["../../src/expressions/parseExpression.ts"],"mappings":";;;iBAagB,qBAAqB,iBAAiB;;;;;;iBAYtC,gBAAgB,iBAAiB;;iBA2BjC,sBAAsB,gBAAgB,gBAAgB,qBAAqB;;iBAQ3E,UAAU,eAAe;;iBAOzB,SAAS,iBAAiB,SAAS"}
+{"version":3,"file":"parseExpression.d.mts","names":[],"sources":["../../src/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/expressions/parseExpression.js

@@ -1,10 +1,11 @@
 import { assertNever } from "../utils.js";
 import { BaseExpr } from "../Expr.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 { parseCaseExpression } from "./case.js";
+import { parseArrayAggExpression } from "./arrayAgg.js";
 //#region src/expressions/parseExpression.ts
 const exprNames = [
 	"coalesce",
@@ -14,7 +15,7 @@ const exprNames = [
 ];
 /** Requires an expression object at the root before parsing its nested operands. */
 function parseExpressionInput(input) {
-	if (!isObject(input) || !("case" in input) && !exprNames.some((name) => name in input)) throw new Error("expr expects an object with case, coalesce, nullIf, greatest, or least");
+	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);
 }
 /**
@@ -36,6 +37,10 @@ function parseExpression(input) {
 			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);

package/build/expressions/parseExpression.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseExpression.js","names":[],"sources":["../../src/expressions/parseExpression.ts"],"sourcesContent":["import { BaseExpr } from \"../Expr.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { parseCaseExpression } from \"./case.ts\";\nimport { parseCoalesceExpression } from \"./coalesce.ts\";\nimport { parseGreatestExpression } from \"./greatest.ts\";\nimport { parseLeastExpression } from \"./least.ts\";\nimport { parseNullIfExpression } from \"./nullIf.ts\";\nimport type { ExprName, ParsedExpression } from \"./types.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) && !exprNames.some((name) => name in input))) {\n    throw new Error(\"expr expects an object with 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) && \"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":";;;;;;;;AAUA,MAAM,YAAY;CAAC;CAAY;CAAU;CAAY;AAAO;;AAG5D,SAAgB,qBAAqB,OAAkC;CACrE,IAAI,CAAC,SAAS,KAAK,KAAM,EAAE,UAAU,UAAU,CAAC,UAAU,MAAM,SAAS,QAAQ,KAAK,GACpF,MAAM,IAAI,MAAM,wEAAwE;CAE1F,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,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"}
+{"version":3,"file":"parseExpression.js","names":[],"sources":["../../src/expressions/parseExpression.ts"],"sourcesContent":["import { BaseExpr } from \"../Expr.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { parseArrayAggExpression } from \"./arrayAgg.ts\";\nimport { parseCaseExpression } from \"./case.ts\";\nimport { parseCoalesceExpression } from \"./coalesce.ts\";\nimport { parseGreatestExpression } from \"./greatest.ts\";\nimport { parseLeastExpression } from \"./least.ts\";\nimport { parseNullIfExpression } from \"./nullIf.ts\";\nimport type { ExprName, ParsedExpression } from \"./types.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/expressions/types.d.cts

@@ -1,3 +1,4 @@
+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";
@@ -9,12 +10,13 @@ import { BaseExpr, Expr, ExprBrand, ExprLike, exprBrand } from "../Expr.cjs";
 /** 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">;
+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] }. */
@@ -32,7 +34,9 @@ type ExpressionValue<V, J extends QueryJoins> = unknown extends V ? V : V extend
   readonly [inputBrand]: infer I;
 } ? InputResult<I, J> : V extends {
   readonly [exprBrand]: ExprBrand<infer R, infer S>;
-} ? MaybeNull<R, S, J> : V extends ExprArgsInput ? V extends {
+} ? 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[];
@@ -49,7 +53,9 @@ type WidenLiteral<V> = V extends string ? string : V extends number ? number : V
  */
 type InputResult<I, J extends QueryJoins> = [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 ExprArgsInput ? BranchResult<V extends {
+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;
@@ -57,7 +63,9 @@ type BranchResult<V> = unknown extends V ? never : V extends ExprLike<infer R> ?
 /** A fixed non-null candidate guarantees a result; a possibly empty candidate array does not. */
 type CoalesceValue<A extends readonly unknown[], J extends QueryJoins> = 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 ExprArgsInput ? ExpressionSources<ExprArgs<V>[number]> : V extends {
+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;
 /**
@@ -67,7 +75,11 @@ type ExpressionSources<V> = unknown extends V ? string : V extends ExprLike<unkn
  */
 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 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 {
+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>;
@@ -81,7 +93,7 @@ type CheckInput<I> = [I] extends [CheckExpression<I, Exclude<BranchResult<I>, nu
  * 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 | ParsedCoalesceExpression | ParsedNullIfExpression | ParsedGreatestExpression | ParsedLeastExpression | ParsedCaseExpression;
+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";
@@ -89,6 +101,14 @@ interface ParsedLiteralExpression {
 }
 /** 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/expressions/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/expressions/types.ts"],"mappings":";;;;;;;;;UASU;EACR,MAAM;EACN,UAAU;EACV,QAAQ;EACR,UAAU;EACV,OAAO;;KAIG,WAAW,cAAc;KAChC,mBAAmB,KAAK,uBAAuB,KAAK,6BAA2B;KAC/E,SAAS,KAAK,QAAQ,QAAQ,IAAI;;KAG3B,eACT,WAAW,aAAa,WAAW,iBAAiB,KAAK,cAAc,qBAAqB,wBACvF;cAEM;;KAGF,cAAc,KAAK,KAAK,YAAY,QAAQ,kBAAkB;YAC9D,aAAa;;;;;;KAOb,gBAAgB,GAAG,UAAU,8BAA8B,IACnE,IACA;YAAsB,mBAAmB;IACvC,YAAY,GAAG,KACf;YAAsB,YAAY,gBAAgB,SAAS;IACzD,UAAU,GAAG,GAAG,KAChB,UAAU,gBACR;WAAqB;IACnB,gBAAgB,SAAS,OAAO,YAChC;WAAqB;IACnB,cAAc,SAAS,IAAI,KAEvB,QAAQ,gBAAgB,SAAS,YAAY,0BAC/B,cAAc,SAAS,IAAI,qBACjD;WAAqB,YAAY;IAE3B,gBAAgB,aAAa,IAAI,MAChC;WAA6C;qBAClD,aAAa;;KAGpB,aAAa,KAAK,4BAEnB,4BAEE,8BAEE,4BAEE,0BAA0B,OACxB,aAAa,OACb;;;;;KAMP,YAAY,GAAG,UAAU,eAAe,QAAQ,aAAa,6BAC9D,gBAAgB,GAAG,KACnB,QAAQ,aAAa,0BAA0B,gBAAgB,GAAG;;KAGjE,aAAa,qBAAqB,YAEnC,UAAU,eAAe,KACvB,IACA,UAAU,gBACR,aAAa;WAAqB;IAA+B,SAAS,QAAQ,SAAS,cAC3F;WAAqB,YAAY;IAC/B,aAAa,aAAa;;KAI/B,cAAc,8BAA8B,UAAU,cAAc,0BAA0B,YAAY,KAC3G,QAAQ,gBAAgB,GAAG,0BAA0B,gBAAgB,GAAG,KAAK,cAAc,GAAG,cAC9F,6BAA6B,cAAc,QAErC,QAAQ,gBAAgB,WAAW,0BACrB,gBAAgB,MAAM,mBAAmB,cAAc,QAAQ,8BACjF,gBAAgB,WAAW;;KAGrB,kBAAkB,qBAAqB,aAE/C,UAAU,oBACR,SAAS,yBACT,UAAU,gBACR,kBAAkB,SAAS,cAC3B;WAAqB,YAAY;IAC/B,kBAAkB,aAAa;;;;;;KAQpC,iBAAiB,GAAG,MAAM,oBAC7B,oBACI,sBACE,gBAAgB,gBAAgB,QAAQ,gBAAgB;;KAQpD,gBAAgB,GAAG,KAC7B,UAAU,8BAEN,UAAU,gBACR,UAAU,wBAEI,WAAW,IAAI,UAAU,WAC/B,EAAE,gCACA,cAAc,EAAE,IAAI,GAAG,gCAKjC;WAAqB,YAAY;;WACpB,MAAM,UAAU,GAAG;IAAO,iBAAiB,aAAa,kBACrD,KAAK,cAAc,wBAEjC,yDAEG,+BAEC,2BAEE,WAAW,+BAA+B,SAAS,KAAK;;KAKnE,cAAc,8BAA8B,aAAa,UAAU,MAAM,uCAC3D,wBAEb,sFAGF,2BACK,UAAU,0DACU,WAAW,IAAI,gBAAgB,EAAE,IAAI,QAAO,iBAAiB;;KAG9E,WAAW,MAAM,YAAY,gBAAgB,GAAG,QAAQ,aAAa,wBAE7E,gBAAgB,GAAG,QAAQ,aAAa;;;;;;KAOhC,mBACR,WACA,0BACA,2BACA,yBACA,2BACA,wBACA;;UAGa;EACf;EACA;;;KAIU,cAAc,KAAK"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/expressions/types.ts"],"mappings":"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"}

package/build/expressions/types.d.mts

@@ -1,3 +1,4 @@
+import { ArrayAggExpressionOptions, ArrayAggInput, ParsedArrayAggExpression } from "./arrayAgg.mjs";
 import { CaseArmValue, CaseInput, CheckCase, ParsedCaseExpression } from "./case.mjs";
 import { CoalesceInput, ParsedCoalesceExpression } from "./coalesce.mjs";
 import { GreatestInput, ParsedGreatestExpression } from "./greatest.mjs";
@@ -9,12 +10,13 @@ import { BaseExpr, Expr, ExprBrand, ExprLike, exprBrand } from "../Expr.mjs";
 /** 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">;
+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] }. */
@@ -32,7 +34,9 @@ type ExpressionValue<V, J extends QueryJoins> = unknown extends V ? V : V extend
   readonly [inputBrand]: infer I;
 } ? InputResult<I, J> : V extends {
   readonly [exprBrand]: ExprBrand<infer R, infer S>;
-} ? MaybeNull<R, S, J> : V extends ExprArgsInput ? V extends {
+} ? 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[];
@@ -49,7 +53,9 @@ type WidenLiteral<V> = V extends string ? string : V extends number ? number : V
  */
 type InputResult<I, J extends QueryJoins> = [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 ExprArgsInput ? BranchResult<V extends {
+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;
@@ -57,7 +63,9 @@ type BranchResult<V> = unknown extends V ? never : V extends ExprLike<infer R> ?
 /** A fixed non-null candidate guarantees a result; a possibly empty candidate array does not. */
 type CoalesceValue<A extends readonly unknown[], J extends QueryJoins> = 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 ExprArgsInput ? ExpressionSources<ExprArgs<V>[number]> : V extends {
+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;
 /**
@@ -67,7 +75,11 @@ type ExpressionSources<V> = unknown extends V ? string : V extends ExprLike<unkn
  */
 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 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 {
+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>;
@@ -81,7 +93,7 @@ type CheckInput<I> = [I] extends [CheckExpression<I, Exclude<BranchResult<I>, nu
  * 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 | ParsedCoalesceExpression | ParsedNullIfExpression | ParsedGreatestExpression | ParsedLeastExpression | ParsedCaseExpression;
+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";
@@ -89,6 +101,14 @@ interface ParsedLiteralExpression {
 }
 /** 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.mts.map

package/build/expressions/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/expressions/types.ts"],"mappings":";;;;;;;;;UASU;EACR,MAAM;EACN,UAAU;EACV,QAAQ;EACR,UAAU;EACV,OAAO;;KAIG,WAAW,cAAc;KAChC,mBAAmB,KAAK,uBAAuB,KAAK,6BAA2B;KAC/E,SAAS,KAAK,QAAQ,QAAQ,IAAI;;KAG3B,eACT,WAAW,aAAa,WAAW,iBAAiB,KAAK,cAAc,qBAAqB,wBACvF;cAEM;;KAGF,cAAc,KAAK,KAAK,YAAY,QAAQ,kBAAkB;YAC9D,aAAa;;;;;;KAOb,gBAAgB,GAAG,UAAU,8BAA8B,IACnE,IACA;YAAsB,mBAAmB;IACvC,YAAY,GAAG,KACf;YAAsB,YAAY,gBAAgB,SAAS;IACzD,UAAU,GAAG,GAAG,KAChB,UAAU,gBACR;WAAqB;IACnB,gBAAgB,SAAS,OAAO,YAChC;WAAqB;IACnB,cAAc,SAAS,IAAI,KAEvB,QAAQ,gBAAgB,SAAS,YAAY,0BAC/B,cAAc,SAAS,IAAI,qBACjD;WAAqB,YAAY;IAE3B,gBAAgB,aAAa,IAAI,MAChC;WAA6C;qBAClD,aAAa;;KAGpB,aAAa,KAAK,4BAEnB,4BAEE,8BAEE,4BAEE,0BAA0B,OACxB,aAAa,OACb;;;;;KAMP,YAAY,GAAG,UAAU,eAAe,QAAQ,aAAa,6BAC9D,gBAAgB,GAAG,KACnB,QAAQ,aAAa,0BAA0B,gBAAgB,GAAG;;KAGjE,aAAa,qBAAqB,YAEnC,UAAU,eAAe,KACvB,IACA,UAAU,gBACR,aAAa;WAAqB;IAA+B,SAAS,QAAQ,SAAS,cAC3F;WAAqB,YAAY;IAC/B,aAAa,aAAa;;KAI/B,cAAc,8BAA8B,UAAU,cAAc,0BAA0B,YAAY,KAC3G,QAAQ,gBAAgB,GAAG,0BAA0B,gBAAgB,GAAG,KAAK,cAAc,GAAG,cAC9F,6BAA6B,cAAc,QAErC,QAAQ,gBAAgB,WAAW,0BACrB,gBAAgB,MAAM,mBAAmB,cAAc,QAAQ,8BACjF,gBAAgB,WAAW;;KAGrB,kBAAkB,qBAAqB,aAE/C,UAAU,oBACR,SAAS,yBACT,UAAU,gBACR,kBAAkB,SAAS,cAC3B;WAAqB,YAAY;IAC/B,kBAAkB,aAAa;;;;;;KAQpC,iBAAiB,GAAG,MAAM,oBAC7B,oBACI,sBACE,gBAAgB,gBAAgB,QAAQ,gBAAgB;;KAQpD,gBAAgB,GAAG,KAC7B,UAAU,8BAEN,UAAU,gBACR,UAAU,wBAEI,WAAW,IAAI,UAAU,WAC/B,EAAE,gCACA,cAAc,EAAE,IAAI,GAAG,gCAKjC;WAAqB,YAAY;;WACpB,MAAM,UAAU,GAAG;IAAO,iBAAiB,aAAa,kBACrD,KAAK,cAAc,wBAEjC,yDAEG,+BAEC,2BAEE,WAAW,+BAA+B,SAAS,KAAK;;KAKnE,cAAc,8BAA8B,aAAa,UAAU,MAAM,uCAC3D,wBAEb,sFAGF,2BACK,UAAU,0DACU,WAAW,IAAI,gBAAgB,EAAE,IAAI,QAAO,iBAAiB;;KAG9E,WAAW,MAAM,YAAY,gBAAgB,GAAG,QAAQ,aAAa,wBAE7E,gBAAgB,GAAG,QAAQ,aAAa;;;;;;KAOhC,mBACR,WACA,0BACA,2BACA,yBACA,2BACA,wBACA;;UAGa;EACf;EACA;;;KAIU,cAAc,KAAK"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/expressions/types.ts"],"mappings":";;;;;;;;;;UAUU;EACR,MAAM;EACN,UAAU;EACV,UAAU;EACV,QAAQ;EACR,UAAU;EACV,OAAO;;KAIG,WAAW,cAAc;KAChC,mBAAmB,KAAK,uBAAuB,KAAK,6BAA2B;KAC/E,SAAS,KAAK,QAAQ,QAAQ,IAAI;;KAG3B,eACT,WAAW,aAAa,WAAW,iBAAiB,KAAK,cAAc,qBAAqB,wBACvF;cAEM;;KAGF,cAAc,KAAK,KAAK,YAAY,QAAQ,kBAAkB;YAC9D,aAAa;;;;;;KAOb,gBAAgB,GAAG,UAAU,8BAA8B,IACnE,IACA;YAAsB,mBAAmB;IACvC,YAAY,GAAG,KACf;YAAsB,YAAY,gBAAgB,SAAS;IACzD,UAAU,GAAG,GAAG,KAChB;WAAqB,gBAAgB;IACnC,gBAAgB,cAAc,IAAI,cAClC,UAAU,gBACR;WAAqB;IACnB,gBAAgB,SAAS,OAAO,YAChC;WAAqB;IACnB,cAAc,SAAS,IAAI,KAEvB,QAAQ,gBAAgB,SAAS,YAAY,0BAC/B,cAAc,SAAS,IAAI,qBACjD;WAAqB,YAAY;IAE3B,gBAAgB,aAAa,IAAI,MAChC;WAA6C;qBAClD,aAAa;;KAGtB,aAAa,KAAK,4BAEnB,4BAEE,8BAEE,4BAEE,0BAA0B,OACxB,aAAa,OACb;;;;;KAMP,YAAY,GAAG,UAAU,eAAe,QAAQ,aAAa,6BAC9D,gBAAgB,GAAG,KACnB,QAAQ,aAAa,0BAA0B,gBAAgB,GAAG;;KAGjE,aAAa,qBAAqB,YAEnC,UAAU,eAAe,KACvB,IACA;WAAqB,gBAAgB;IACnC,aAAa,cAAc,QAC3B,UAAU,gBACR,aAAa;WAAqB;IAA+B,SAAS,QAAQ,SAAS,cAC3F;WAAqB,YAAY;IAC/B,aAAa,aAAa;;KAIjC,cAAc,8BAA8B,UAAU,cAAc,0BAA0B,YAAY,KAC3G,QAAQ,gBAAgB,GAAG,0BAA0B,gBAAgB,GAAG,KAAK,cAAc,GAAG,cAC9F,6BAA6B,cAAc,QAErC,QAAQ,gBAAgB,WAAW,0BACrB,gBAAgB,MAAM,mBAAmB,cAAc,QAAQ,8BACjF,gBAAgB,WAAW;;KAGrB,kBAAkB,qBAAqB,aAE/C,UAAU,oBACR,SAAS,yBACT;WAAqB,gBAAgB;IACnC,kBAAkB,cAAc,MAChC,UAAU,gBACR,kBAAkB,SAAS,cAC3B;WAAqB,YAAY;IAC/B,kBAAkB,aAAa;;;;;;KAQtC,iBAAiB,GAAG,MAAM,oBAC7B,oBACI,sBACE,gBAAgB,gBAAgB,QAAQ,gBAAgB;;KAQpD,gBAAgB,GAAG,KAC7B,UAAU,8BAEN;WAAqB,gBAAgB;;WACxB,UAAU,cAAc,GAAG,0BAA0B,OAAO;gBAC3D,KAAK,cAAc,4BAE/B,UAAU,gBACR,UAAU,wBAEI,WAAW,IAAI,UAAU,WAC/B,EAAE,gCACA,cAAc,EAAE,IAAI,GAAG,gCAKjC;WAAqB,YAAY;;WACpB,MAAM,UAAU,GAAG;IAAO,iBAAiB,aAAa,kBACrD,KAAK,cAAc,wBAEjC,yDAEG,+BAEC,2BAEE,WAAW,+BAA+B,SAAS,KAAK;;KAKrE,cAAc,8BAA8B,aAAa,UAAU,MAAM,uCAC3D,wBAEb,sFAGF,2BACK,UAAU,0DACU,WAAW,IAAI,gBAAgB,EAAE,IAAI,QAAO,iBAAiB;;KAG9E,WAAW,MAAM,YAAY,gBAAgB,GAAG,QAAQ,aAAa,wBAE7E,gBAAgB,GAAG,QAAQ,aAAa;;;;;;KAOhC,mBACR,WACA,0BACA,2BACA,2BACA,yBACA,2BACA,wBACA;;UAGa;EACf;EACA;;;KAIU,cAAc,KAAK;;KAG1B,cAAc,KAAK;WAAqB,aAAa;IAAM,IAAI;;KAG/D,cAAc,GAAG,KAAK;WAAqB;IAC5C,UAAU,wCAEI,WAAW,IAAI,oBACrB,gBAAgB,EAAE,IAAI,KACtB,gBAAgB,4BACd,EAAE,wBAIZ,gBAAgB,GAAG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "joist-core",
-  "version": "2.3.0-next.92",
+  "version": "2.3.0-next.93",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -42,7 +42,7 @@
     "build"
   ],
   "peerDependencies": {
-    "joist-utils": "2.3.0-next.92"
+    "joist-utils": "2.3.0-next.93"
   },
   "dependencies": {
     "ansis": "^4.3.1",