@happyvertical/sql 0.105.12 → 0.106.1

package/dist/chunks/{query-DubG7aF0.js → query-B6ATOWzc.js}

@@ -1,6 +1,119 @@
 import { a as raw, i as parseConditionKey, n as buildWhere, s as unwrapRawKey } from "./schema-manager-tfASrb_b.js";
 import { DatabaseError } from "@happyvertical/utils";
+//#region src/aggregate-expression.ts
+var MAX_DEPTH = 24;
+/** Node budget for a whole spec (every select item, join, filter and predicate together). */
+var MAX_NODES = 1024;
+var ARITHMETIC = {
+	add: "+",
+	sub: "-",
+	mul: "*",
+	div: "/"
+};
+var COMPARISON = {
+	eq: "=",
+	ne: "<>",
+	lt: "<",
+	lte: "<=",
+	gt: ">",
+	gte: ">="
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function literal(value, state) {
+	const { ctx } = state;
+	if (value === null) return "NULL";
+	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error("Aggregate expression numbers must be finite");
+		return String(value);
+	}
+	if (value instanceof Date) {
+		if (Number.isNaN(value.getTime())) throw new Error("Aggregate expression dates must be valid");
+		const placeholder = `$${ctx.nextIndex++}`;
+		ctx.values.push(value.toISOString());
+		if (ctx.adapterType === "duckdb" || ctx.adapterType === "json") return `CAST(${placeholder} AS TIMESTAMP)`;
+		if (ctx.adapterType === "postgres") return `CAST(${placeholder} AS TIMESTAMPTZ)`;
+		return placeholder;
+	}
+	if (typeof value === "string") {
+		const placeholder = `$${ctx.nextIndex++}`;
+		ctx.values.push(value);
+		return placeholder;
+	}
+	throw new Error("Aggregate expression literal must be a string, number, boolean, Date or null");
+}
+function secondsBetween(adapterType, later, earlier) {
+	if (adapterType === "postgres") return `CAST(EXTRACT(EPOCH FROM (${later} - ${earlier})) AS DOUBLE PRECISION)`;
+	if (adapterType === "duckdb" || adapterType === "json") return `epoch(${later}) - epoch(${earlier})`;
+	return `((julianday(${later}) - julianday(${earlier})) * 86400.0)`;
+}
+function renderOperand(node, state, depth) {
+	if (depth > MAX_DEPTH) throw new Error(`Aggregate expression is nested deeper than ${MAX_DEPTH}`);
+	state.ctx.nodeCount = (state.ctx.nodeCount ?? 0) + 1;
+	if (state.ctx.nodeCount > MAX_NODES) throw new Error(`Aggregate expression has more than ${MAX_NODES} nodes`);
+	if (!isRecord(node)) throw new Error("Aggregate expression node must be an object");
+	const { ctx } = state;
+	if ("col" in node) {
+		const column = ctx.identifier(node.col);
+		ctx.onColumn?.(column);
+		return column;
+	}
+	if ("value" in node) return literal(node.value, state);
+	const op = node.op;
+	const child = (value) => renderOperand(value, state, depth + 1);
+	if (typeof op === "string" && Object.hasOwn(ARITHMETIC, op)) {
+		const arithmetic = op;
+		const left = child(node.left);
+		const right = child(node.right);
+		if (arithmetic === "div") {
+			const quotient = `((${left} * 1.0) / NULLIF(${right}, 0))`;
+			if (ctx.adapterType === "postgres") return `CAST(${quotient} AS DOUBLE PRECISION)`;
+			if (ctx.adapterType === "duckdb" || ctx.adapterType === "json") return `CAST(${quotient} AS DOUBLE)`;
+			return quotient;
+		}
+		return `(${left} ${ARITHMETIC[arithmetic]} ${right})`;
+	}
+	if (op === "secondsBetween") return secondsBetween(ctx.adapterType, child(node.later), child(node.earlier));
+	if (typeof op === "string" && Object.hasOwn(COMPARISON, op)) {
+		const comparison = op;
+		const against = (side) => isRecord(side) && "value" in side && side.value === null;
+		if ((comparison === "eq" || comparison === "ne") && against(node.right)) return `(${child(node.left)} IS ${comparison === "eq" ? "NULL" : "NOT NULL"})`;
+		if ((comparison === "eq" || comparison === "ne") && against(node.left)) return `(${child(node.right)} IS ${comparison === "eq" ? "NULL" : "NOT NULL"})`;
+		return `(${child(node.left)} ${COMPARISON[comparison]} ${child(node.right)})`;
+	}
+	if (op === "and" || op === "or") {
+		const operands = node.operands;
+		if (!Array.isArray(operands) || operands.length === 0) throw new Error(`Aggregate expression ${op} requires at least one operand`);
+		return `(${operands.map(child).join(op === "and" ? " AND " : " OR ")})`;
+	}
+	if (op === "not") return `(NOT ${child(node.operand)})`;
+	if (op === "isNull" || op === "isNotNull") return `(${child(node.operand)} IS ${op === "isNull" ? "NULL" : "NOT NULL"})`;
+	if (op === "coalesce") {
+		const operands = node.operands;
+		if (!Array.isArray(operands) || operands.length === 0) throw new Error("Aggregate expression coalesce requires at least one operand");
+		return `COALESCE(${operands.map(child).join(", ")})`;
+	}
+	throw new Error(`Unsupported aggregate expression operator: ${String(op)}`);
+}
+/**
+* Render an expression node to SQL, binding its string and date literals into
+* `ctx` as numbered parameters. Throws on any unknown operator, unsafe
+* identifier, non-finite number, or an expression too large to be legitimate.
+*/
+function renderAggregateExpression(node, ctx) {
+	return renderOperand(node, { ctx }, 0);
+}
+//#endregion
 //#region src/aggregate.ts
+var EXPRESSION_AGGREGATES = /* @__PURE__ */ new Set([
+	"count",
+	"sum",
+	"avg",
+	"min",
+	"max"
+]);
 var VALID_DIRECTIONS = /* @__PURE__ */ new Set(["ASC", "DESC"]);
 var VALID_BUCKET_UNITS = /* @__PURE__ */ new Set([
 	"minute",
@@ -36,32 +149,66 @@ function bucketExpr(adapterType, unit, column) {
 		case "year": return `strftime('%Y-01-01 00:00:00', ${col})`;
 	}
 }
-function aggregateExpression(expr) {
+function checkColumn(state, column) {
+	const { scope } = state;
+	if (scope && column.includes(".")) {
+		const parts = column.split(".");
+		if (parts.length !== 2 || !scope.has(parts[0])) throw new Error(`Aggregate column ${column} must be qualified by the from table or a join alias`);
+	}
+	return column;
+}
+function validateColumn(state, column) {
+	return checkColumn(state, validateSqlIdentifier(column));
+}
+function renderExpression(state, node) {
+	return renderAggregateExpression(node, state.ctx);
+}
+function aggregateExpression(expr, state) {
 	const normalizedFn = String(expr.fn).toLowerCase();
 	const fn = validateSqlIdentifier(String(expr.fn)).toUpperCase();
-	if (normalizedFn === "count" && !expr.column) {
+	if (expr.column !== void 0 && expr.expr !== void 0) throw new Error(`Aggregate ${expr.fn} takes a column or an expr, not both`);
+	if ((expr.expr !== void 0 || expr.filter !== void 0) && !EXPRESSION_AGGREGATES.has(normalizedFn)) throw new Error(`Aggregate ${expr.fn} cannot take an expr or filter; use count, sum, avg, min or max`);
+	const hasArgument = Boolean(expr.column) || expr.expr !== void 0;
+	const filter = expr.filter !== void 0 ? renderExpression(state, expr.filter) : void 0;
+	if (normalizedFn === "count" && !hasArgument) {
 		if (expr.distinct) throw new Error(`Aggregate ${expr.fn} with distinct requires a column`);
-		return "COUNT(*)";
+		return filter ? `COUNT(CASE WHEN ${filter} THEN 1 END)` : "COUNT(*)";
 	}
-	if (!expr.column) throw new Error(`Aggregate ${expr.fn} requires a column`);
-	const col = validateSqlIdentifier(expr.column);
-	return `${fn}(${expr.distinct ? "DISTINCT " : ""}${col})`;
+	if (!hasArgument) throw new Error(`Aggregate ${expr.fn} requires a column`);
+	const argument = expr.expr !== void 0 ? renderExpression(state, expr.expr) : validateColumn(state, expr.column);
+	return `${fn}(${expr.distinct ? "DISTINCT " : ""}${filter ? `CASE WHEN ${filter} THEN ${argument} END` : argument})`;
 }
-function selectExpression(expr, adapterType) {
-	if ("column" in expr && !("fn" in expr) && !("bucket" in expr)) return {
-		expression: validateSqlIdentifier(expr.column),
-		alias: validateSqlIdentifier(expr.as ?? expr.column),
-		groupingCandidate: true
+function selectExpression(expr, adapterType, state) {
+	if ([
+		"fn" in expr,
+		"expr" in expr && !("fn" in expr),
+		"bucket" in expr
+	].filter(Boolean).length > 1) throw new Error("Aggregate select item mixes fn, bucket and expr");
+	if ("fn" in expr) return {
+		expression: aggregateExpression(expr, state),
+		alias: validateSqlIdentifier(expr.as),
+		groupingCandidate: false,
+		computed: false
 	};
-	if ("bucket" in expr) return {
-		expression: bucketExpr(adapterType, expr.bucket, expr.column),
+	if ("expr" in expr) return {
+		expression: renderExpression(state, expr.expr),
 		alias: validateSqlIdentifier(expr.as),
-		groupingCandidate: true
+		groupingCandidate: true,
+		computed: true
+	};
+	if ("column" in expr && !("bucket" in expr)) return {
+		expression: validateColumn(state, expr.column),
+		alias: validateSqlIdentifier(expr.as ?? expr.column.split(".").pop() ?? expr.column),
+		groupingCandidate: true,
+		computed: false
 	};
+	const column = validateColumn(state, expr.column);
+	const bucket = expr.bucket;
 	return {
-		expression: aggregateExpression(expr),
+		expression: bucketExpr(adapterType, bucket, column),
 		alias: validateSqlIdentifier(expr.as),
-		groupingCandidate: false
+		groupingCandidate: true,
+		computed: false
 	};
 }
 function expandHavingKey(key, expressionByAlias) {
@@ -85,61 +232,121 @@ function buildHaving(having, expressionByAlias, startIndex, adapterType) {
 		values: built.values
 	};
 }
-function buildOrderBy(orderBy) {
+function buildOrderBy(orderBy, state, aliases) {
 	if (!orderBy) return "";
 	return `ORDER BY ${(Array.isArray(orderBy) ? orderBy : [orderBy]).map((item) => {
 		const [field, direction = "ASC"] = item.trim().split(/\s+/);
 		const normalizedDirection = direction.toUpperCase();
 		if (!VALID_DIRECTIONS.has(normalizedDirection)) throw new Error(`Invalid aggregate order direction: ${direction}`);
-		return `${validateSqlIdentifier(field)} ${normalizedDirection}`;
+		return `${aliases.has(field) ? validateSqlIdentifier(field) : validateColumn(state, field)} ${normalizedDirection}`;
 	}).join(", ")}`;
 }
+var VALID_JOIN_TYPES = /* @__PURE__ */ new Set(["inner", "left"]);
+var JOIN_ALIAS = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function buildScope(fromAlias, joins, from) {
+	if (joins.length === 0 && fromAlias === void 0) return void 0;
+	const scope = /* @__PURE__ */ new Set();
+	const claim = (name, what) => {
+		if (typeof name !== "string" || !JOIN_ALIAS.test(name)) throw new Error(`Invalid aggregate ${what}: ${name}`);
+		if (scope.has(name)) throw new Error(`Duplicate aggregate table name or alias: ${name}`);
+		scope.add(name);
+	};
+	if (fromAlias !== void 0) claim(fromAlias, "from alias");
+	else {
+		if (from.includes(".")) throw new Error("AggregateSpec.fromAlias is required when joining a schema-qualified from table");
+		claim(from, "from table");
+	}
+	for (const join of joins) claim(join.alias, "join alias");
+	return scope;
+}
+function joinSql(state, joins) {
+	return joins.map((join) => {
+		const type = join.type ?? "inner";
+		if (!VALID_JOIN_TYPES.has(type)) throw new Error(`Invalid aggregate join type: ${type}`);
+		if (join.on === void 0) throw new Error(`Aggregate join ${join.alias} requires an on condition`);
+		const table = validateSqlIdentifier(join.table);
+		const alias = join.alias;
+		if (typeof alias !== "string" || !JOIN_ALIAS.test(alias)) throw new Error(`Invalid aggregate join alias: ${String(alias)}`);
+		const on = renderExpression(state, join.on);
+		return `${type === "left" ? "LEFT" : "INNER"} JOIN ${table} AS ${alias} ON ${on}`;
+	});
+}
 function buildAggregate(spec, startIndex = 1, adapterType) {
 	const from = validateSqlIdentifier(spec.from);
 	if (spec.select.length === 0) throw new Error("AggregateSpec.select must contain at least one expression");
+	if (spec.joins !== void 0 && !Array.isArray(spec.joins)) throw new Error("AggregateSpec.joins must be an array");
+	const values = [];
+	const ctx = {
+		adapterType,
+		nextIndex: startIndex,
+		values,
+		identifier: validateSqlIdentifier
+	};
+	const fromAlias = spec.fromAlias;
+	const joins = (spec.joins ?? []).map((join) => ({
+		table: join.table,
+		alias: join.alias,
+		type: join.type,
+		on: join.on
+	}));
+	const state = {
+		ctx,
+		scope: buildScope(fromAlias, joins, from)
+	};
+	ctx.onColumn = (column) => {
+		checkColumn(state, column);
+	};
 	const expressionByAlias = /* @__PURE__ */ new Map();
+	const ordinalByAlias = /* @__PURE__ */ new Map();
 	const groupingAliases = [];
-	const selectSql = spec.select.map((expr) => {
-		const selected = selectExpression(expr, adapterType);
+	const selectSql = spec.select.map((expr, position) => {
+		const selected = selectExpression(expr, adapterType, state);
+		if (expressionByAlias.has(selected.alias)) throw new Error(`Duplicate aggregate select alias: ${selected.alias}`);
 		expressionByAlias.set(selected.alias, selected.expression);
+		if (selected.computed) ordinalByAlias.set(selected.alias, position + 1);
 		if (selected.groupingCandidate) groupingAliases.push(selected.alias);
 		return `${selected.expression} AS ${selected.alias}`;
 	});
-	const where = spec.where ? buildWhere(spec.where, startIndex, adapterType) : {
+	const joinParts = joinSql(state, joins);
+	const where = spec.where ? buildWhere(spec.where, ctx.nextIndex, adapterType) : {
 		sql: "",
 		values: []
 	};
-	let nextParamIndex = startIndex + where.values.length;
+	values.push(...where.values);
+	ctx.nextIndex += where.values.length;
+	let whereSql = where.sql;
+	if (spec.whereExpr !== void 0) {
+		const predicate = renderExpression(state, spec.whereExpr);
+		whereSql = whereSql ? `WHERE (${whereSql.replace(/^WHERE /, "")}) AND ${predicate}` : `WHERE ${predicate}`;
+	}
 	const groupByItems = spec.groupBy ?? groupingAliases;
-	const groupBySql = groupByItems.length > 0 ? `GROUP BY ${groupByItems.map((item) => expressionByAlias.has(item) ? expressionByAlias.get(item) : validateSqlIdentifier(item)).join(", ")}` : "";
-	const having = buildHaving(spec.having, expressionByAlias, nextParamIndex, adapterType);
-	nextParamIndex += having.values.length;
-	const orderBySql = buildOrderBy(spec.orderBy);
-	const pagingValues = [];
+	const groupBySql = groupByItems.length > 0 ? `GROUP BY ${groupByItems.map((item) => ordinalByAlias.has(item) ? String(ordinalByAlias.get(item)) : expressionByAlias.has(item) ? expressionByAlias.get(item) : validateColumn(state, item)).join(", ")}` : "";
+	const having = buildHaving(spec.having, expressionByAlias, ctx.nextIndex, adapterType);
+	values.push(...having.values);
+	ctx.nextIndex += having.values.length;
+	const orderBySql = buildOrderBy(spec.orderBy, state, new Set(expressionByAlias.keys()));
 	const pagingSql = [];
 	if (spec.limit !== void 0) {
-		pagingSql.push(`LIMIT ${placeholder(nextParamIndex++)}`);
-		pagingValues.push(spec.limit);
+		pagingSql.push(`LIMIT ${placeholder(ctx.nextIndex++)}`);
+		values.push(spec.limit);
 	} else if (spec.offset !== void 0 && normalizeAdapter(adapterType) === "sqlite") pagingSql.push("LIMIT -1");
 	if (spec.offset !== void 0) {
-		pagingSql.push(`OFFSET ${placeholder(nextParamIndex++)}`);
-		pagingValues.push(spec.offset);
+		pagingSql.push(`OFFSET ${placeholder(ctx.nextIndex++)}`);
+		values.push(spec.offset);
 	}
+	const fromSql = spec.fromAlias !== void 0 ? `${from} AS ${fromAlias}` : from;
 	return {
 		sql: [
 			`SELECT ${selectSql.join(", ")}`,
-			`FROM ${from}`,
-			where.sql,
+			`FROM ${fromSql}`,
+			...joinParts,
+			whereSql,
 			groupBySql,
 			having.sql,
 			orderBySql,
 			pagingSql.join(" ")
 		].filter(Boolean).join(" "),
-		values: [
-			...where.values,
-			...having.values,
-			...pagingValues
-		]
+		values
 	};
 }
 //#endregion
@@ -350,4 +557,4 @@ async function syncSchema(options) {
 //#endregion
 export { NestedTransactionError as a, bucketExpr as c, validateColumnName as i, buildAggregate as l, syncSchema as n, resolveSchemas as o, tableExists as r, convertUniqueIndexesToInlineConstraints as s, escapeSqlValue as t };
 
-//# sourceMappingURL=query-DubG7aF0.js.map
+//# sourceMappingURL=query-B6ATOWzc.js.map