joist-core 2.3.0-next.90 → 2.3.0-next.91

package/build/query.cjs

@@ -1,6 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_conditions = require("./conditions.cjs");
-require("./typeMap.cjs");
 const require_keywords = require("./keywords.cjs");
 const require_EntityMetadata = require("./EntityMetadata.cjs");
 const require_utils = require("./utils.cjs");
@@ -413,10 +412,6 @@ function validateReadQuery(arg) {
 	else {
 		validateQueryKeys(arg, READ_KEYS, "Read queries");
 		if (!("from" in arg && "select" in arg)) require_utils.fail("em.query expects a { from, select, ... } object or a query(...) value");
-		if (require_Tables.isTable(arg.select)) {
-			const meta = require_Tables.getTableMetadata(arg.select);
-			if (meta.inheritanceType || meta.baseType || meta.baseTypes.length || meta.subTypes.length) require_utils.fail(`Inherited table ${meta.type} cannot be selected as entities; select its columns individually`);
-		}
 	}
 	const options = arg;
 	for (const key of ["limit", "offset"]) {
@@ -777,7 +772,7 @@ function parseQuery(q, parent, assigner, recursiveSelf) {
 	});
 	const softDeletes = q.softDeletes ?? "exclude";
 	const from = parseFrom();
-	const joins = pendingJoins.map((j) => {
+	const userJoins = pendingJoins.map((j) => {
 		const source = j.parseSource();
 		const userOn = conditionToSql(j.on, ctx, true);
 		const injected = injectedConditions(source, j.softDeletes ? softDeletes : "include");
@@ -790,8 +785,11 @@ function parseQuery(q, parent, assigner, recursiveSelf) {
 			fullOn
 		};
 	});
-	const { selects, decodeRows, output } = selectsToSql(q, ctx, from);
-	const fromInjected = injectedConditions(from, softDeletes);
+	const cti = ctiEntityPlan(q, from, assigner);
+	const joins = [...cti.joins, ...userJoins];
+	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 having = conditionToSql(q.having, ctx, true);
 	const groupBys = (q.groupBy ?? []).map((g) => asExpr(g, "groupBy").toSql(ctx));
@@ -963,14 +961,14 @@ function registerJoinTable(handle, ctx, assigner) {
 	});
 }
 /** Generates the `select` clause SQL and returns how to decode the resulting rows. */
-function selectsToSql(q, ctx, from) {
+function selectsToSql(q, ctx, from, entitySelects) {
 	const { select } = q;
 	if (require_Tables.isTable(select)) {
 		if (from.handle !== require_Tables.getTableMgmt(select)) require_utils.fail("Selecting a joined table is not supported yet; select the from table, or select its columns individually");
 		const alias = ctx.aliasFor(require_Tables.getTableMgmt(select));
 		const meta = require_Tables.getTableMetadata(select);
 		return {
-			selects: from.entitySelects.map((s) => ({
+			selects: entitySelects ?? from.entitySelects.map((s) => ({
 				sql: s,
 				bindings: [],
 				refs: [alias]
@@ -1000,6 +998,139 @@ function selectsToSql(q, ctx, from) {
 	projection.output = joinedOutput(projection.output, q.join);
 	return projection;
 }
+/**
+* Builds the mandatory CTI joins and flat row projection needed by entity hydration.
+*
+* The joins use the same ParsedJoin path as user joins, but `keep: true` makes them survive pruning.
+* They are generated only for an entity selection of the from source; POJO and scalar reads keep their
+* physical-table behavior. User source aliases have already been allocated, so the preferred `_bN` and
+* `_sN` aliases can be made unique before their projection fragments are built.
+*/
+function ctiEntityPlan(q, from, assigner) {
+	if (!require_Tables.isTable(q.select) || from.handle !== require_Tables.getTableMgmt(q.select)) return {
+		joins: [],
+		selects: void 0
+	};
+	const meta = require_Tables.getTableMetadata(q.select);
+	if (meta.inheritanceType !== "cti") return {
+		joins: [],
+		selects: void 0
+	};
+	const joins = [];
+	const selects = from.entitySelects.map((sql) => ({
+		sql,
+		bindings: [],
+		refs: [from.alias]
+	}));
+	for (const [i, baseMeta] of meta.baseTypes.entries()) {
+		const alias = assigner.getLiteralAlias(`${from.alias}_b${i}`);
+		joins.push(ctiJoin(from, baseMeta, alias));
+		selects.push(...entitySelectFragments(baseMeta, alias));
+	}
+	const subtypeColumns = /* @__PURE__ */ new Map();
+	for (const [i, subtypeMeta] of meta.subTypes.entries()) {
+		const alias = assigner.getLiteralAlias(`${from.alias}_s${i}`);
+		joins.push(ctiJoin(from, subtypeMeta, alias));
+		selects.push(...entitySelectFragments(subtypeMeta, alias));
+		for (const field of Object.values(subtypeMeta.fields)) {
+			if (field.fieldName === "id" || !field.serde || field.kind === "primitive" && field.lazy) continue;
+			for (const column of field.serde.columns) {
+				const aliases = subtypeColumns.get(column.columnName);
+				if (aliases) aliases.push(alias);
+				else subtypeColumns.set(column.columnName, [alias]);
+			}
+		}
+	}
+	selects.push({
+		sql: `${require_keywords.safeKq(from.alias)}.${require_keywords.kq("id")} AS ${require_keywords.kq("id")}`,
+		bindings: [],
+		refs: [from.alias]
+	});
+	for (const [column, aliases] of subtypeColumns) {
+		if (aliases.length < 2) continue;
+		selects.push({
+			sql: `COALESCE(${aliases.map((alias) => `${require_keywords.safeKq(alias)}.${require_keywords.kq(column)}`).join(", ")}) AS ${require_keywords.kq(column)}`,
+			bindings: [],
+			refs: aliases
+		});
+	}
+	if (meta.subTypes.length > 0) {
+		const subtypeAliases = joins.slice(meta.baseTypes.length).map((join) => join.source.alias);
+		selects.push({
+			sql: `CASE ${subtypeAliases.map((alias) => `WHEN ${require_keywords.safeKq(alias)}.${require_keywords.kq("id")} IS NOT NULL THEN ?`).join(" ")} ELSE '_' END AS ${require_keywords.kq("__class")}`,
+			bindings: meta.subTypes.map((subtype) => subtype.type),
+			refs: subtypeAliases
+		});
+	}
+	return {
+		joins,
+		selects
+	};
+}
+/** Adds the discriminator projection and subtype filter required by STI entity hydration. */
+function stiEntityPlan(q, from) {
+	if (!require_Tables.isTable(q.select) || from.handle !== require_Tables.getTableMgmt(q.select)) return {
+		selects: void 0,
+		conditions: []
+	};
+	const meta = require_Tables.getTableMetadata(q.select);
+	if (meta.inheritanceType !== "sti") return {
+		selects: void 0,
+		conditions: []
+	};
+	const selects = from.entitySelects.map((sql) => ({
+		sql,
+		bindings: [],
+		refs: [from.alias]
+	}));
+	if (!(from.entitySelects.length === 1 && from.entitySelects[0] === require_keywords.kqStar(from.alias))) {
+		const discriminator = require_EntityMetadata.getBaseMeta(meta).stiDiscriminatorColumnName;
+		selects.push({
+			sql: `${require_keywords.safeKq(from.alias)}.${require_keywords.kq(discriminator)} AS ${require_keywords.kq(discriminator)}`,
+			bindings: [],
+			refs: [from.alias]
+		});
+	}
+	const condition = require_QueryParser.stiSubtypeFilter(meta, from.alias);
+	return {
+		selects,
+		conditions: condition ? [condition] : []
+	};
+}
+/** Creates one mandatory CTI join through the selected source's primary key. */
+function ctiJoin(from, meta, alias) {
+	const on = {
+		sql: `${require_keywords.safeKq(from.alias)}.${require_keywords.kq("id")} = ${require_keywords.safeKq(alias)}.${require_keywords.kq("id")}`,
+		bindings: [],
+		refs: [from.alias, alias]
+	};
+	return {
+		kind: "left",
+		source: {
+			handle: {
+				tableName: meta.tableName,
+				meta
+			},
+			alias,
+			sql: `${require_keywords.kq(meta.tableName)} AS ${require_keywords.safeKq(alias)}`,
+			bindings: [],
+			refs: [],
+			entitySelects: [],
+			meta
+		},
+		userOn: on,
+		fullOn: on,
+		keep: true
+	};
+}
+/** Selects one physical CTI table while preserving lazy-field exclusions. */
+function entitySelectFragments(meta, alias) {
+	return (meta.hasLazyColumns ? require_QueryParser.lazyExcludedSelects(meta, alias) : [require_keywords.kqStar(alias)]).map((sql) => ({
+		sql,
+		bindings: [],
+		refs: [alias]
+	}));
+}
 function decodeRow(row, decoders) {
 	const result = {};
 	for (const [key, expr] of decoders) {