joist-core 2.3.0-next.99 → 2.4.0

package/build/queries/sql/query.js

@@ -5,13 +5,14 @@ import { isDeferredAliasCondition } from "../find/DeferredAlias.js";
 import { ConditionBuilder } from "../ConditionBuilder.js";
 import { filterSoftDeletes, lazyExcludedSelects, stiSubtypeFilter } from "../entityQueryUtils.js";
 import { deepFindConditions } from "../parsedConditions.js";
-import { BaseExpr, RefExpr, TemplateExpr, asNode, deferredCondition, deferredSym, isExpr, orderByToSql, resolveDeferredConditions } from "./Expr.js";
+import { BaseExpr, TemplateExpr, asNode, deferredCondition, deferredSym, isExpr, orderByToSql, resolveDeferredConditions, selectKeyBrand } from "./Expr.js";
 import { fail } from "../../utils.js";
 import { getBaseMeta } from "../../EntityMetadata.js";
 import { buildWhereClause } from "../renderConditions.js";
 import { AliasAssigner } from "./AliasAssigner.js";
-import { JoinTableHandle, collectionJoin, getTableMetadata, getTableMgmt, isTable, m2mJoinTable, referenceJoinSource } from "./Tables.js";
+import { JoinTableHandle, collectionJoin, getTableMetadata, getTableMgmt, inQueryCondition, isEntityTable, isTable, m2mJoinTable, referenceJoinSource, tableSqlName } from "./Tables.js";
 import { buildExpr } from "./expressions/expression.js";
+import { compileJoinTree } from "./JoinTree.js";
 //#region src/queries/sql/query.ts
 /**
 * `em.query`: SQL-shaped queries as plain object literals.
@@ -27,10 +28,10 @@ import { buildExpr } from "./expressions/expression.js";
 *     select: { name: a.first_name, n: bookStats.n },
 *     orderBy: { n: "DESC" },
 *   });
-*   // rows: { name: string; n: number | null }[]   (null because of the LEFT join)
+*   // rows: { name: string; n: number | undefined }[]   (undefined because of the LEFT join)
 *
-* `em.query(pojo)` runs it. `select` decides the row type: a bare table returns entities, a
-* `{ key: expr }` object returns typed POJOs, a bare subquery returns that subquery's rows.
+* `em.query(pojo)` runs it. `select` decides the row type: a bare table returns entities, an array of
+* columns or a `{ key: expr }` object returns typed POJOs, and a bare subquery returns its rows.
 *
 * `query(pojo)` turns the *same* POJO into a value: a derived table with typed columns, a scalar
 * expression, or an entity list. It is the one non-POJO step, and the subquery analog of `table(Author)`:
@@ -50,24 +51,26 @@ const subqueryBrand = Symbol("joist.subquery");
 const entityQueryBrand = Symbol("joist.entityQuery");
 const scalarQueryBrand = Symbol("joist.scalarQuery");
 function query(q) {
-	const handle = new SubqueryHandle(toQuery(q));
-	const output = handle.output();
-	if (output.kind === "entity") return { [entityQueryBrand]: handle };
-	else if (output.kind === "scalar") return new SubqueryExpr(handle);
-	else return newSubqueryProxy(handle);
+	return createQueryValue(q);
 }
 /**
-* Builds a query value only when its user-supplied `where` survives pruning.
+* Builds a query value only when its user-supplied `where` or join-tree filters survive pruning.
 *
 * Missing or empty conditions prune the value, including nested groups and `pruneIfUndefined`.
-* Joins, HAVING, and implicit soft-delete/STI conditions do not keep the value alive.
+* Alias-only joins, HAVING, and implicit soft-delete/STI conditions do not keep the value alive.
 *
 * I.e. `queryMaybe({ from: b, where: b.authorId.eq(enabled ? a.id : undefined), select: b.id })`
 * returns `undefined` when `enabled` is false, so an enclosing `notExists` also prunes.
 */
 function queryMaybe(q) {
-	checkCondition(q.where);
-	return isPrunedQueryCondition(q.where) ? void 0 : query(q);
+	return createMaybeQueryValue(q);
+}
+/** Applies queryMaybe's structural pruning before creating any kind of read-query value. */
+function createMaybeQueryValue(q) {
+	const normalized = normalizeQueryJoins(q);
+	const where = normalizeWhere(normalized.where);
+	checkCondition(where);
+	return isPrunedQueryCondition(where) ? void 0 : createQueryValue(normalized);
 }
 /**
 * Declares a `WITH RECURSIVE` CTE from its two terms, and returns the CTE as a readable value.
@@ -122,9 +125,9 @@ function recursiveQuery(name, base, step, opts = {}) {
 * // Selecting this expression keeps the join to Book b.
 * sql.number`${b.order} * ${2}`
 *
-* // Reference an unmodeled column; it is untracked at the type level.
-* sql.ref<string>(a, "ts_search")
-* sql.condition`${sql.ref(a, "ts_search")} @@ plainto_tsquery(${term})`
+* // Reference an unmodeled column; prefer the table's own `column`, which keeps its source key.
+* a.column<string>("ts_search")
+* sql.condition`${a.column("ts_search")} @@ plainto_tsquery(${term})`
 * ```
 */
 function sql(strings, ...values) {
@@ -158,10 +161,6 @@ sql.booleanArrayOrNull = typedSql;
 sql.condition = function condition(strings, ...values) {
 	return deferredCondition((ctx) => new TemplateExpr(strings, values).toSql(ctx));
 };
-/** A column Joist does not model, on a source that is in the query. */
-sql.ref = function ref(source, column) {
-	return new RefExpr(handleOf(source), column);
-};
 /**
 * Parses `arg` (a `Query` POJO or `query(...)` value) into a runnable `Plan`.
 *
@@ -188,8 +187,8 @@ function isReadQueryValue(arg) {
 * Compiles scalar or nonempty named expression projections, shared by SELECT and mutation RETURNING.
 * Source-shaped values need read hydration/source rules and are deliberately excluded here.
 */
-function projectionToSql(select, ctx) {
-	const output = projectionOutput(select);
+function projectionToSql(select, ctx, joins) {
+	const output = joinedOutput(projectionOutput(select), joins);
 	if (output.kind === "scalar") {
 		const expr = output.columns[0][1];
 		const fragment = expr.toSql(ctx);
@@ -198,7 +197,7 @@ function projectionToSql(select, ctx) {
 				...fragment,
 				sql: `${fragment.sql} AS value`
 			}],
-			decodeRows: (_, rows) => rows.map((row) => expr.decode(row.value)),
+			decodeRows: (_, rows) => rows.map((row) => decodeValue(expr, row.value)),
 			output
 		};
 	}
@@ -271,6 +270,9 @@ var SubqueryColumnExpr = class extends BaseExpr {
 		this.key = key;
 		this.inner = inner;
 	}
+	get [selectKeyBrand]() {
+		return this.key;
+	}
 	toSql(ctx) {
 		const alias = ctx.aliasFor(this.handle);
 		return {
@@ -500,6 +502,7 @@ function queryOutput(q) {
 			columns
 		};
 	}
+	q = normalizeQueryJoins(q);
 	const { select } = q;
 	if (isTable(select)) return {
 		kind: "entity",
@@ -514,6 +517,20 @@ function projectionOutput(select) {
 		kind: "scalar",
 		columns: [["value", asExpr(select, "select")]]
 	};
+	if (Array.isArray(select)) {
+		if (select.length === 0) fail("A column array projection must not be empty");
+		const columns = select.map((value, index) => {
+			const expr = asExpr(value, `select[${index}]`);
+			const key = expr[selectKeyBrand];
+			if (typeof key !== "string") fail(`select[${index}] must be a physical or subquery column`);
+			return [key, expr];
+		});
+		if (new Set(columns.map(([key]) => key)).size !== columns.length) fail("A column array projection must not contain duplicate field names");
+		return {
+			kind: "pojo",
+			columns
+		};
+	}
 	if (isPlainSelect(select)) {
 		const columns = [];
 		for (const key of Reflect.ownKeys(select)) {
@@ -529,7 +546,7 @@ function projectionOutput(select) {
 	return fail("Expected a scalar expression or a nonempty named expression projection");
 }
 /**
-* Adds physical NULL from unmatched LEFT joins without mutating shared expressions or their codecs.
+* Adds SQL nullability from unmatched LEFT joins without mutating shared expressions or their codecs.
 * Only direct columns carry sqlSource; COUNT and COALESCE retain their own SQL nullability.
 * I.e. selecting Book.title from a LEFT-joined Book makes its output nullable, but COUNT(Book.id) stays NOT NULL.
 */
@@ -637,7 +654,7 @@ function parseSetQuery(q, parent, assigner, recursiveSelf) {
 		bindings,
 		outerRefs: [...new Set(outerRefs.filter((ref) => !cteAliases.has(ref)))],
 		output,
-		decodeRows: plans[0].decodeRows
+		decodeRows: (_, rows) => rows.map((row) => decodeRow(row, output.columns))
 	};
 }
 /** Validate and quote only named set output sorts, including before a reusable value is parsed. */
@@ -776,6 +793,7 @@ function describeHandle(handle) {
 function parseQuery(q, parent, assigner, recursiveSelf) {
 	validateReadQuery(q);
 	if (isSetQuery(q)) return parseSetQuery(q, parent, assigner, recursiveSelf);
+	q = normalizeQueryJoins(q);
 	const ctx = new Ctx(assigner, parent);
 	if (recursiveSelf) ctx.setRecursiveSelf(recursiveSelf);
 	const joinEntries = resolveReferenceJoins(q.join);
@@ -823,7 +841,8 @@ function parseQuery(q, parent, assigner, recursiveSelf) {
 	const sti = stiEntityPlan(q, from);
 	const { selects, decodeRows, output } = selectsToSql(q, ctx, from, cti.selects ?? sti.selects);
 	const fromInjected = [...injectedConditions(from, softDeletes), ...sti.conditions];
-	const where = conditionToSql(fromInjected.length > 0 ? { and: [q.where, ...fromInjected] } : q.where, ctx, true);
+	const predicate = normalizeWhere(q.where);
+	const where = conditionToSql(fromInjected.length > 0 ? { and: [predicate, ...fromInjected] } : predicate, ctx, true);
 	const having = conditionToSql(q.having, ctx, true);
 	const groupBys = (q.groupBy ?? []).map((g) => asExpr(g, "groupBy").toSql(ctx));
 	const orderBys = orderBysToSql(q, ctx);
@@ -936,15 +955,17 @@ function registerSource(source, ctx, assigner) {
 			};
 		};
 	} else {
-		const meta = getTableMetadata(source);
-		const alias = assigner.getAlias(meta.tableName);
+		const mgmt = getTableMgmt(source);
+		const { tableName } = mgmt;
+		const meta = "meta" in mgmt ? mgmt.meta : void 0;
+		const alias = assigner.getAlias(tableName);
 		ctx.register(handle, alias);
 		return () => {
-			const entitySelects = meta.hasLazyColumns ? lazyExcludedSelects(meta, alias) : [kqStar(alias)];
+			const entitySelects = !meta ? [] : meta.hasLazyColumns ? lazyExcludedSelects(meta, alias) : [kqStar(alias)];
 			return {
 				handle,
 				alias,
-				sql: `${kq(meta.tableName)} AS ${kq(alias)}`,
+				sql: `${tableSqlName(mgmt)} AS ${kq(alias)}`,
 				bindings: [],
 				refs: [],
 				entitySelects,
@@ -996,7 +1017,8 @@ function registerJoinTable(handle, ctx, assigner) {
 /** Generates the `select` clause SQL and returns how to decode the resulting rows. */
 function selectsToSql(q, ctx, from, entitySelects) {
 	const { select } = q;
-	if (isTable(select)) {
+	if (isTable(select) && !isEntityTable(select)) fail("A custom table cannot be selected as an entity; select its columns individually");
+	if (isEntityTable(select)) {
 		if (from.handle !== getTableMgmt(select)) fail("Selecting a joined table is not supported yet; select the from table, or select its columns individually");
 		const alias = ctx.aliasFor(getTableMgmt(select));
 		const meta = getTableMetadata(select);
@@ -1027,9 +1049,7 @@ function selectsToSql(q, ctx, from, entitySelects) {
 			output
 		};
 	}
-	const projection = projectionToSql(select, ctx);
-	projection.output = joinedOutput(projection.output, q.join);
-	return projection;
+	return projectionToSql(select, ctx, q.join);
 }
 /**
 * Builds the mandatory CTI joins and flat row projection needed by entity hydration.
@@ -1040,7 +1060,7 @@ function selectsToSql(q, ctx, from, entitySelects) {
 * `_sN` aliases can be made unique before their projection fragments are built.
 */
 function ctiEntityPlan(q, from, assigner) {
-	if (!isTable(q.select) || from.handle !== getTableMgmt(q.select)) return {
+	if (!isEntityTable(q.select) || from.handle !== getTableMgmt(q.select)) return {
 		joins: [],
 		selects: void 0
 	};
@@ -1102,7 +1122,7 @@ function ctiEntityPlan(q, from, assigner) {
 }
 /** Adds the discriminator projection and subtype filter required by STI entity hydration. */
 function stiEntityPlan(q, from) {
-	if (!isTable(q.select) || from.handle !== getTableMgmt(q.select)) return {
+	if (!isEntityTable(q.select) || from.handle !== getTableMgmt(q.select)) return {
 		selects: void 0,
 		conditions: []
 	};
@@ -1168,7 +1188,7 @@ function decodeRow(row, decoders) {
 	const result = {};
 	for (const [key, expr] of decoders) {
 		const value = row[key];
-		const decoded = value === null || value === void 0 ? null : expr.decode(value);
+		const decoded = decodeValue(expr, value);
 		if (key === "__proto__") Object.defineProperty(result, key, {
 			value: decoded,
 			enumerable: true,
@@ -1179,6 +1199,10 @@ function decodeRow(row, decoders) {
 	}
 	return result;
 }
+/** Decodes a top-level projected SQL NULL using Joist's undefined convention. */
+function decodeValue(expr, value) {
+	return value === null ? void 0 : expr.decode(value);
+}
 const ORDER_BY_DIRECTIONS = [
 	"ASC",
 	"DESC",
@@ -1188,7 +1212,7 @@ const ORDER_BY_DIRECTIONS = [
 	"DESC NULLS LAST"
 ];
 /**
-* Generates ORDER BY SQL in entry order for keyed/expression arrays or a single keyed object.
+* Generates ORDER BY SQL in entry order for keyed/expression arrays or a single entry.
 *
 * Expression entries retain bindings and alias references for join pruning. Undefined entries and
 * directions are omitted before expression references are collected.
@@ -1217,7 +1241,7 @@ function orderBysToSql(q, ctx) {
 				});
 			} else {
 				if (isExpr(select)) return fail(`the keyed orderBy form needs a POJO or entity select`);
-				if (!(isSubqueryValue(select) ? select[subqueryBrand].columnKeys() : Object.keys(select)).includes(key)) return fail(`orderBy key '${key}' is not a key of select`);
+				if (!(isSubqueryValue(select) ? select[subqueryBrand].columnKeys() : projectionOutput(select).columns.map(([key]) => key)).includes(key)) return fail(`orderBy key '${key}' is not a key of select`);
 				result.push({
 					sql: `${safeKq(key)} ${dir}`,
 					bindings: [],
@@ -1260,6 +1284,10 @@ function conditionToSql(cond, ctx, topLevel) {
 function checkCondition(value) {
 	if (isDeferredAliasCondition(value) || value && typeof value === "object" && predicateBrand in value && value[predicateBrand] === "domain") fail("Domain alias conditions are only supported by em.find; use table(...) predicates in SQL queries and mutations.");
 	if (value === void 0 || value === skipCondition) return;
+	if (isInQueryCondition(value)) {
+		checkCondition(normalizeWhere(normalizeQueryJoins(toQuery(value[inQueryCondition].query)).where));
+		return;
+	}
 	if (!value || typeof value !== "object" || Array.isArray(value) || isExpr(value)) fail("Query predicate must be a condition or an and/or group");
 	const condition = value;
 	if ("and" in condition || "or" in condition) {
@@ -1345,6 +1373,13 @@ function checkConditionKeys(value, allowed, description) {
 */
 function resolveQueryCondition(cond, ctx) {
 	if (cond === void 0) return void 0;
+	if (isInQueryCondition(cond)) {
+		const { column, query } = cond[inQueryCondition];
+		const value = createMaybeQueryValue(query);
+		if (value === void 0) return void 0;
+		if (!isExpr(value)) return fail("An in query literal must select one expression");
+		return column.in(value);
+	}
 	if ("and" in cond && cond.and) return {
 		and: cond.and.map((child) => resolveQueryCondition(child, ctx)),
 		pruneIfUndefined: cond.pruneIfUndefined
@@ -1379,6 +1414,7 @@ function isFilter(cond) {
 */
 function isPrunedQueryCondition(cond) {
 	if (cond === void 0 || cond === skipCondition) return true;
+	if (isInQueryCondition(cond)) return isPrunedQueryCondition(normalizeWhere(normalizeQueryJoins(cond[inQueryCondition].query).where));
 	if ("and" in cond || "or" in cond) {
 		const children = (cond.and ?? cond.or ?? []).map(isPrunedQueryCondition);
 		return children.every((pruned) => pruned) || "pruneIfUndefined" in cond && cond.pruneIfUndefined === "any" && children.some((pruned) => pruned);
@@ -1387,6 +1423,10 @@ function isPrunedQueryCondition(cond) {
 	if ("notExists" in cond) return cond.notExists === void 0;
 	return false;
 }
+/** Recognizes the direct query-literal condition created by EntityColumn.in. */
+function isInQueryCondition(value) {
+	return typeof value === "object" && value !== null && inQueryCondition in value;
+}
 /** The physical source aliases a parsed condition tree references. */
 function refsOf(parsed) {
 	return deepFindConditions(parsed, false).flatMap((c) => c.kind === "column" ? [c.alias] : c.kind === "raw" ? c.aliases : c.outerAliases);
@@ -1520,6 +1560,28 @@ function joinFragmentParts(parts, sep) {
 function isDefined(value) {
 	return value !== void 0;
 }
+/** Lowers a relationship tree before SQL rendering or output nullability is calculated. */
+function normalizeQueryJoins(q) {
+	if (q.join === void 0 || Array.isArray(q.join)) return q;
+	const tree = compileJoinTree(q.from, q.join);
+	return {
+		...q,
+		join: tree.joins,
+		where: { and: [tree.condition, normalizeWhere(q.where)] }
+	};
+}
+/** Gives WHERE arrays the same pruning and validation as explicit AND groups. */
+function normalizeWhere(where) {
+	return Array.isArray(where) ? { and: where } : where;
+}
+/** Creates the runtime query value after the public signature has checked its input. */
+function createQueryValue(q) {
+	const handle = new SubqueryHandle(toQuery(q));
+	const output = handle.output();
+	if (output.kind === "entity") return { [entityQueryBrand]: handle };
+	else if (output.kind === "scalar") return new SubqueryExpr(handle);
+	else return newSubqueryProxy(handle);
+}
 /** Keeps shorthand declarations callable-only, without recursively copying sql's own shorthand properties. */
 function typedSql(strings, ...values) {
 	return new TemplateExpr(strings, values);