joist-core 2.4.0-next.2 → 2.4.0-next.21

package/build/queries/sql/query.cjs

@@ -168,7 +168,7 @@ sql.condition = function condition(strings, ...values) {
 * `EntityManager.query` runs the plan; this module deliberately does not import `EntityManager` (see
 * `EntityHydrator`), so it parses and hands back `{ sql, bindings, decodeRows }` instead of executing.
 */
-function parseUserQuery(arg) {
+function parseRootQuery(arg) {
 	if (arg instanceof SubqueryExpr) require_utils.fail("Scalar query values are expressions, not executable read inputs");
 	return parseQuery(toQuery(arg), void 0, new require_queries_sql_AliasAssigner.AliasAssigner());
 }
@@ -220,6 +220,7 @@ function projectionToSql(select, ctx, joins) {
 var SubqueryHandle = class {
 	recursive;
 	#q;
+	#output;
 	constructor(q, recursive = false) {
 		this.recursive = recursive;
 		this.#q = q;
@@ -228,13 +229,17 @@ var SubqueryHandle = class {
 		return this.#q;
 	}
 	/**
-	* Gives a recursive CTE its finished body. `recursiveQuery` starts the handle on its base term, so
-	* the step term can read the CTE's columns while the body that will hold that step is still being
-	* built. The base term supplies the CTE's columns either way, PostgreSQL's rule for a recursive WITH.
+	* Gives a recursive CTE its finished body.
+	*
+	* `recursiveQuery(name, base, step)` cannot hand us the real body up front: it has to call `step` to
+	* get it, and `step` needs this handle first, because the recursive half of the query references the
+	* CTE's own columns. So the handle starts out holding `base` alone, and the real body, `base UNION
+	* step`, arrives here afterwards. Either way PostgreSQL takes the CTE's column names from `base`.
 	*/
 	setBody(q) {
 		if (!this.recursive) require_utils.fail("Only a recursive CTE replaces its body");
 		this.#q = q;
+		this.#output = void 0;
 	}
 	get name() {
 		return this.q.as;
@@ -243,15 +248,27 @@ var SubqueryHandle = class {
 	columnKeys() {
 		const output = this.output();
 		if (output.kind === "pojo") return output.columns.map(([key]) => key);
-		return require_utils.fail(`A subquery with an entity or scalar select has no columns`);
+		return require_utils.fail(`A query value with an entity or scalar select has no columns`);
 	}
 	/** The inner expression behind `key`, for its decoder/encoder. */
 	columnExpr(key) {
-		return this.output().columns.find(([name]) => name === key)?.[1] ?? require_utils.fail(`Subquery ${this.describe()} has no column ${key}`);
+		return this.output().columns.find(([name]) => name === key)?.[1] ?? require_utils.fail(`Query value ${this.describe()} has no column ${key}`);
 	}
-	/** Resolve output metadata without parsing SQL or caching aliases from an enclosing query. */
+	/**
+	* The output columns, in order, with the codec for each; worked out without generating any SQL.
+	*
+	* Cached, because the answer is expensive to work out and gets asked for a lot:
+	*
+	* - `queryOutput` re-checks the whole query, converts a `join: { books: ... }` relationship tree
+	*   back into a flat list of joins, and repeats all of that for every operand of a set query.
+	* - A `query(...)` value has no real properties. `bookStats.n` runs a `Proxy` get that builds a new
+	*   column expression, and building one needs this method's answer to find `n`. So selecting two of
+	*   a value's columns asked for the whole shape twice, before parsing then asked a third time.
+	*
+	* `setBody` is the only thing that changes the shape, so it is the only thing that clears this.
+	*/
 	output() {
-		return queryOutput(this.q);
+		return this.#output ??= queryOutput(this.q);
 	}
 	column(key) {
 		return new SubqueryColumnExpr(this, key, this.columnExpr(key));
@@ -477,15 +494,15 @@ function queryOutput(q) {
 	validateReadQuery(q);
 	if (isSetQuery(q)) {
 		const [operation, operands] = setOperands(q);
-		const first = queryOutput(toQuery(operands[0]));
+		const first = requirePojoOperand(queryOutput(toQuery(operands[0])));
 		const columns = [...first.columns];
-		for (const operand of operands) {
-			const output = operand === operands[0] ? first : queryOutput(toQuery(operand));
-			if (output.kind !== "pojo") require_utils.fail(output.kind === "entity" ? "Set operations do not support entity-mode operands" : "Set operations require POJO operands; wrap scalar expressions in a named select projection");
+		for (const operand of operands.slice(1)) {
+			const output = requirePojoOperand(queryOutput(toQuery(operand)));
 			if (output.columns.length !== first.columns.length) require_utils.fail("Set operands must have the same POJO keys");
+			const byKey = new Map(output.columns);
 			for (let i = 0; i < columns.length; i++) {
 				const [key, expr] = columns[i];
-				const other = output.columns.find(([name]) => name === key)?.[1];
+				const other = byKey.get(key);
 				if (!other) require_utils.fail(`Set operands must have the same POJO keys; missing '${key}'`);
 				const left = expr.outputType;
 				const right = other.outputType;
@@ -512,6 +529,11 @@ function queryOutput(q) {
 	if (isSubqueryValue(select)) return readValueHandle(select).output();
 	return joinedOutput(projectionOutput(select), q.join);
 }
+/** Only named POJO operands combine; entity and scalar reads have no columns to line up. */
+function requirePojoOperand(output) {
+	if (output.kind !== "pojo") require_utils.fail(output.kind === "entity" ? "Set operations do not support entity-mode operands" : "Set operations require POJO operands; wrap scalar expressions in a named select projection");
+	return output;
+}
 /** Validates the projection before compiling SQL or exposing reusable query columns. */
 function projectionOutput(select) {
 	if (require_queries_sql_Expr.isExpr(select)) return {
@@ -642,17 +664,12 @@ function parseSetQuery(q, parent, assigner, recursiveSelf) {
 		sql += " OFFSET ?";
 		bindings.push(q.offset);
 	}
-	const keptCtes = pruneCtes(ctes, new Set(plans.flatMap((plan) => plan.outerRefs)));
-	if (keptCtes.length > 0) {
-		const clause = withFragment(keptCtes);
-		sql = clause.sql + sql;
-		bindings.unshift(...clause.bindings);
-	}
+	const withCtes = prependCtes(ctes, new Set(plans.flatMap((plan) => plan.outerRefs)), sql, bindings);
 	const cteAliases = new Set(ctes.map((cte) => cte.alias));
 	const outerRefs = [...ctx.outerRefs, ...plans.flatMap((plan) => plan.outerRefs)];
 	return {
-		sql,
-		bindings,
+		sql: withCtes.sql,
+		bindings: withCtes.bindings,
 		outerRefs: [...new Set(outerRefs.filter((ref) => !cteAliases.has(ref)))],
 		output,
 		decodeRows: (_, rows) => rows.map((row) => decodeRow(row, output.columns))
@@ -777,7 +794,7 @@ var Ctx = class {
 	}
 };
 function describeHandle(handle) {
-	if (handle instanceof SubqueryHandle) return `Subquery ${handle.describe()}`;
+	if (handle instanceof SubqueryHandle) return `Query value ${handle.describe()}`;
 	if (handle instanceof require_queries_sql_Tables.JoinTableHandle) return `Join table ${handle.joinTableName}`;
 	if ("tableName" in handle) return `Table for ${handle.tableName}`;
 	return "Table";
@@ -1294,19 +1311,19 @@ function checkCondition(value) {
 	if ("and" in condition || "or" in condition) {
 		if ("and" in condition === "or" in condition) require_utils.fail("Query conditions require exactly one and/or group");
 		const key = "and" in condition ? "and" : "or";
-		checkConditionKeys(condition, [key, "pruneIfUndefined"], "Query condition group");
+		checkPojoKeys(condition, [key, "pruneIfUndefined"], "Query condition group");
 		if (!Array.isArray(condition[key])) require_utils.fail("Query condition groups require an array");
 		if (condition.pruneIfUndefined !== void 0 && condition.pruneIfUndefined !== "any" && condition.pruneIfUndefined !== "all") require_utils.fail("Invalid query pruneIfUndefined policy");
 		for (const child of condition[key]) checkCondition(child);
 	} else if ("exists" in condition || "notExists" in condition) {
 		const key = "exists" in condition ? "exists" : "notExists";
-		checkConditionKeys(condition, [key], "Query existence condition");
+		checkPojoKeys(condition, [key], "Query existence condition");
 		const query = condition[key];
 		if (query === void 0) return;
 		if (!(query instanceof SubqueryExpr) && !isReadQueryValue(query)) require_utils.fail(`Query ${key} requires a query(...) value`);
 		toQuery(query);
 	} else if (condition.kind === "raw") {
-		checkConditionKeys(condition, [
+		checkPojoKeys(condition, [
 			"kind",
 			"aliases",
 			"condition",
@@ -1317,7 +1334,7 @@ function checkCondition(value) {
 		], "Query raw condition");
 		if (typeof condition.condition !== "string" || !Array.isArray(condition.aliases) || !condition.aliases.every((alias) => typeof alias === "string") || !Array.isArray(condition.bindings) || typeof condition.pruneable !== "boolean") require_utils.fail("Malformed query raw condition");
 	} else if (condition.kind === "column") {
-		checkConditionKeys(condition, [
+		checkPojoKeys(condition, [
 			"kind",
 			"alias",
 			"column",
@@ -1329,7 +1346,7 @@ function checkCondition(value) {
 		if (typeof condition.alias !== "string" || typeof condition.column !== "string" || typeof condition.dbType !== "string" || condition.pruneable !== void 0 && typeof condition.pruneable !== "boolean") require_utils.fail("Malformed query column condition");
 		const filter = condition.cond;
 		if (!filter) require_utils.fail("Malformed query column filter");
-		checkConditionKeys(filter, ["kind", "value"], "Query column filter");
+		checkPojoKeys(filter, ["kind", "value"], "Query column filter");
 		const unary = filter.kind === "is-null" || filter.kind === "not-null";
 		if (!unary && (![
 			"eq",
@@ -1360,8 +1377,18 @@ function checkCondition(value) {
 		if (unary && "value" in filter) require_utils.fail("Unary query filters do not accept values");
 	} else require_utils.fail("Unknown query condition");
 }
-/** Conditions use own enumerable POJO fields, with predicate-brand and SQL-resolver symbols allowed. */
-function checkConditionKeys(value, allowed, description) {
+/**
+* Accepts only own enumerable POJO fields, so nothing a caller supplied can be silently ignored: the
+* compilers read these POJOs back with `Object.entries`/`Object.keys`, which skip inherited,
+* non-enumerable, and symbol keys, so a field hidden behind one of those would never reach the SQL.
+* I.e. an UPDATE whose `set` carries `title` on a prototype would leave `title` unchanged and still
+* report success.
+*
+* Conditions, mutation clauses, and assignment POJOs all share this rule; `allowed` may include symbol
+* keys, i.e. a condition's predicate brand and SQL resolver. Read-query clauses instead use
+* `validateQueryKeys`, which walks the prototype chain and reports mutation clauses by name.
+*/
+function checkPojoKeys(value, allowed, description) {
 	if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) require_utils.fail(`${description} must be a plain POJO`);
 	for (const key of Reflect.ownKeys(value)) {
 		if (!allowed.includes(key)) require_utils.fail(`${description} does not support '${String(key)}'`);
@@ -1512,6 +1539,24 @@ function withEntryHandle(entry) {
 	return readValueHandle(entry);
 }
 /**
+* Puts a statement's surviving `with` entries in front of it, dropping the ones nothing reads.
+*
+* `referenced` is the aliases the rest of the statement used. The WITH clause leads the statement, so
+* its bindings lead the statement's bindings too.
+*/
+function prependCtes(ctes, referenced, sql, bindings) {
+	const kept = pruneCtes(ctes, referenced);
+	if (kept.length === 0) return {
+		sql,
+		bindings
+	};
+	const clause = withFragment(kept);
+	return {
+		sql: clause.sql + sql,
+		bindings: [...clause.bindings, ...bindings]
+	};
+}
+/**
 * Drops the CTEs that nothing reads, given the aliases the rest of the statement referenced.
 *
 * A CTE can only read earlier siblings, so going last to first means every CTE that could read this one
@@ -1590,12 +1635,14 @@ function typedSql(strings, ...values) {
 //#endregion
 exports.Ctx = Ctx;
 exports.SubqueryHandle = SubqueryHandle;
+exports.checkPojoKeys = checkPojoKeys;
 exports.conditionToSql = conditionToSql;
 exports.entityQueryBrand = entityQueryBrand;
 exports.injectedConditions = injectedConditions;
 exports.isReadQueryValue = isReadQueryValue;
 exports.parseNestedQuery = parseNestedQuery;
-exports.parseUserQuery = parseUserQuery;
+exports.parseRootQuery = parseRootQuery;
+exports.prependCtes = prependCtes;
 exports.projectionToSql = projectionToSql;
 exports.pruneCtes = pruneCtes;
 exports.query = query;