joist-core 2.3.0 → 2.4.0-next.10

package/build/queries/find/QueryParser.cjs

@@ -0,0 +1,553 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_keys = require("../../keys.cjs");
+const require_queries_sql_keywords = require("../sql/keywords.cjs");
+const require_queries_conditions = require("../conditions.cjs");
+const require_queries_find_DeferredAlias = require("./DeferredAlias.cjs");
+const require_queries_find_Aliases = require("./Aliases.cjs");
+const require_queries_find_scopes = require("./scopes.cjs");
+const require_queries_valueFilters = require("../valueFilters.cjs");
+const require_queries_ConditionBuilder = require("../ConditionBuilder.cjs");
+const require_queries_entityQueryUtils = require("../entityQueryUtils.cjs");
+const require_queries_find_QueryParser_pruning = require("./QueryParser.pruning.cjs");
+const require_queries_find_QueryVisitor = require("./QueryVisitor.cjs");
+const require_queries_sql_Expr = require("../sql/Expr.cjs");
+const require_utils = require("../../utils.cjs");
+const require_configure = require("../../configure.cjs");
+const require_EntityMetadata = require("../../EntityMetadata.cjs");
+let joist_utils = require("joist-utils");
+//#region src/queries/find/QueryParser.ts
+/**
+* Parses an `em.find` filter into a logical `ParsedFindQuery` AST, leaving optimization/pruning to callers.
+*
+* The main execution flow is:
+* parseFindQuery -> beforeFind plugins -> optimizeCollectionJoins -> pruneUnusedJoins -> execute SQL.
+*/
+function parseFindQuery(meta, filter, opts = {}) {
+	const selects = [];
+	const tables = [];
+	const orderBys = [];
+	const query = {
+		selects,
+		tables,
+		orderBys
+	};
+	const { orderBy, conditions: optsExpression, softDeletes = "exclude", pruneJoins = false, keepAliases = [] } = opts;
+	const cb = new require_queries_ConditionBuilder.ConditionBuilder();
+	const aliasBindings = /* @__PURE__ */ new Map();
+	const aliases = {};
+	function getAlias(tableName) {
+		const abbrev = require_utils.abbreviation(tableName);
+		const i = aliases[abbrev] || 0;
+		aliases[abbrev] = i + 1;
+		return i === 0 ? abbrev : `${abbrev}${i}`;
+	}
+	/** Adds a `deleted_at IS NULL` condition for `alias`, i.e. for the primary table or a collection join. */
+	function addSoftDeleteCondition(meta, alias, targetCb) {
+		if (require_queries_entityQueryUtils.filterSoftDeletes(meta, softDeletes)) {
+			const column = meta.allFields[require_EntityMetadata.getBaseMeta(meta).timestampFields.deletedAt].serde?.columns[0];
+			targetCb.addSimpleCondition({
+				kind: "column",
+				alias,
+				column: column.columnName,
+				dbType: column.dbType,
+				cond: { kind: "is-null" },
+				pruneable: true
+			});
+		}
+	}
+	function addTable(meta, alias, join, col1, col2, filter, fieldName, targetCb = cb, isCollection = false) {
+		const scopeFilter = require_queries_find_scopes.isScope(filter);
+		const ef = scopeFilter ? void 0 : require_queries_valueFilters.parseEntityFilter(meta, filter);
+		if (!scopeFilter && !ef && join !== "primary" && !require_queries_find_Aliases.isAlias(filter)) return;
+		if (join === "primary") {
+			tables.push({
+				alias,
+				table: meta.tableName,
+				join
+			});
+			addTablePerClassJoinsAndClassTag({
+				selects,
+				tables,
+				orderBys
+			}, meta, alias, true);
+		} else if (meta.inheritanceType === "cti" && fieldName && !(fieldName in meta.fields)) meta.baseTypes.forEach((bt, i) => {
+			tables.push({
+				alias: `${alias}_b${i}`,
+				table: bt.tableName,
+				join: "outer",
+				col1,
+				col2: `${require_queries_sql_keywords.kq(`${alias}_b${i}`)}.${col2.split(".")[1]}`,
+				distinct: false
+			});
+			tables.push({
+				alias: `${alias}`,
+				table: meta.tableName,
+				join: "outer",
+				col1: require_queries_sql_keywords.kqDot(alias, "id"),
+				col2: require_queries_sql_keywords.kqDot(`${alias}_b${i}`, "id"),
+				distinct: false
+			});
+		});
+		else if (join === "lateral" || join === "cross") require_utils.fail("Unexpected lateral join");
+		else {
+			tables.push({
+				alias,
+				table: meta.tableName,
+				join,
+				col1,
+				col2
+			});
+			addTablePerClassJoinsAndClassTag({
+				selects,
+				tables,
+				orderBys
+			}, meta, alias, false);
+		}
+		if (needsStiDiscriminator(meta)) addStiSubtypeFilter(targetCb, meta, alias);
+		if (join === "primary" || isCollection) addSoftDeleteCondition(meta, alias, targetCb);
+		if (filter && typeof filter === "object" && "as" in filter && require_queries_find_Aliases.isAlias(filter.as)) aliasBindings.set(require_queries_find_Aliases.getAliasMgmt(filter.as), {
+			meta,
+			alias
+		});
+		else if (require_queries_find_Aliases.isAlias(filter)) aliasBindings.set(require_queries_find_Aliases.getAliasMgmt(filter), {
+			meta,
+			alias
+		});
+		addFilterAt(meta, alias, filter, targetCb, ef, join);
+	}
+	function addFilterAt(meta, tableAlias, filter, targetCb, parsed = require_queries_valueFilters.parseEntityFilter(meta, filter), parentJoin = "primary") {
+		if (require_queries_find_scopes.isScope(filter)) addScopeFilterAt(meta, tableAlias, filter, targetCb, parentJoin);
+		else if (parsed && parsed.kind === "join") addSubFilter(meta, tableAlias, parsed.subFilter, targetCb, parentJoin);
+		else if (parsed) {
+			const column = meta.fields["id"].serde.columns[0];
+			targetCb.addValueFilter(tableAlias, column, parsed);
+		}
+	}
+	function addScopeFilterAt(meta, tableAlias, scope, targetCb, parentJoin) {
+		for (const fragment of require_queries_find_scopes.resolveScope(scope).fragments) if (fragment.kind === "filter") addFilterAt(meta, tableAlias, fragment.filter, targetCb, void 0, parentJoin);
+		else {
+			const a = require_queries_find_Aliases.alias(meta.cstr);
+			const result = fragment.fn(a);
+			aliasBindings.set(require_queries_find_Aliases.getAliasMgmt(a), {
+				meta,
+				alias: tableAlias
+			});
+			if (require_queries_find_scopes.isScopeJoinFilter(result)) {
+				addFilterAt(meta, tableAlias, result.where, targetCb, void 0, parentJoin);
+				checkDomainCondition(result.conditions);
+				targetCb.maybeAddExpression(result.conditions);
+			} else {
+				const conditions = Array.isArray(result) ? result : [result];
+				for (const condition of conditions) checkDomainCondition(condition);
+				if (conditions.length > 0) targetCb.maybeAddExpression({ and: conditions });
+			}
+		}
+	}
+	function addSubFilter(meta, tableAlias, subFilter, targetCb, parentJoin) {
+		Object.keys(subFilter).forEach((key) => {
+			if (key === "as") return;
+			if (key === "and" || key === "or") {
+				addLogicalFilter(meta, tableAlias, key, subFilter[key], targetCb, parentJoin);
+				return;
+			}
+			const field = findFilterField(meta, key) ?? require_utils.fail(`Field '${key}' not found on ${meta.tableName}`);
+			const fa = `${tableAlias}${field.aliasSuffix}`;
+			if (field.kind === "primitive" || field.kind === "primaryKey" || field.kind === "enum") {
+				const column = field.serde.columns[0];
+				require_queries_valueFilters.parseValueFilter(subFilter[key]).forEach((filter) => {
+					targetCb.addValueFilter(fa, column, filter);
+				});
+			} else if (field.kind === "m2o") {
+				const column = field.serde.columns[0];
+				const sub = subFilter[key];
+				const joinKind = field.required && parentJoin !== "outer" ? "inner" : "outer";
+				if (require_queries_find_Aliases.isAlias(sub)) {
+					const a = getAlias(field.otherMetadata().tableName);
+					addTable(field.otherMetadata(), a, joinKind, require_queries_sql_keywords.kqDot(fa, column.columnName), require_queries_sql_keywords.kqDot(a, "id"), sub, void 0, targetCb);
+				}
+				const f = require_queries_valueFilters.parseEntityFilter(field.otherMetadata(), sub);
+				if (!f) {} else if (f.kind === "join") {
+					const a = getAlias(field.otherMetadata().tableName);
+					addTable(field.otherMetadata(), a, joinKind, require_queries_sql_keywords.kqDot(fa, column.columnName), require_queries_sql_keywords.kqDot(a, "id"), sub, void 0, targetCb);
+				} else targetCb.addValueFilter(fa, column, f);
+			} else if (field.kind === "poly") {
+				const f = require_queries_valueFilters.parseEntityFilter(meta, subFilter[key]);
+				if (!f) {} else if (f.kind === "join") throw new Error("Joins through polys are not supported");
+				else if (f.kind === "eq" || f.kind === "ne") {
+					const comp = field.components.find((p) => {
+						const otherMeta = p.otherMetadata();
+						const cstr = require_configure.getConstructorFromTaggedId(f.value);
+						return otherMeta.cstr === cstr || otherMeta.baseType === cstr.name;
+					});
+					if (!comp) require_utils.fail(`Invalid tagged id passed to ${meta.type}.${key}: ${f.value}`);
+					const column = field.serde.columns.find((c) => c.columnName === comp.columnName);
+					targetCb.addValueFilter(fa, column, f);
+				} else if (f.kind === "is-null") field.components.forEach((comp) => {
+					const column = field.serde.columns.find((c) => c.columnName === comp.columnName);
+					targetCb.addSimpleCondition({
+						kind: "column",
+						alias: fa,
+						column: comp.columnName,
+						dbType: column.dbType,
+						cond: f
+					});
+				});
+				else if (f.kind === "not-null") {
+					const conditions = field.components.map((comp) => {
+						const column = field.serde.columns.find((c) => c.columnName === comp.columnName);
+						return {
+							kind: "column",
+							alias: fa,
+							column: comp.columnName,
+							dbType: column.dbType,
+							cond: { kind: "not-null" }
+						};
+					});
+					targetCb.addParsedExpression({
+						kind: "exp",
+						op: "or",
+						conditions
+					});
+				} else if (f.kind === "in") {
+					if (f.value.length === 0) {
+						targetCb.addValueFilter(fa, field.serde.columns[0], {
+							kind: "in",
+							value: []
+						});
+						return;
+					}
+					const idsByConstructor = (0, joist_utils.groupBy)(f.value, (id) => require_configure.getConstructorFromTaggedId(id).name);
+					const conditions = Object.entries(idsByConstructor).map(([cstrName, ids]) => {
+						const column = field.serde.columns.find((c) => c.otherMetadata().cstr.name === cstrName || c.otherMetadata().baseType === cstrName) ?? require_utils.fail(`Invalid tagged ids passed to ${meta.type}.${key}: ${ids}`);
+						return {
+							kind: "column",
+							alias: fa,
+							column: column.columnName,
+							dbType: column.dbType,
+							cond: require_queries_valueFilters.mapToDb(column, {
+								kind: "in",
+								value: ids
+							})
+						};
+					});
+					targetCb.addParsedExpression({
+						kind: "exp",
+						op: "or",
+						conditions
+					});
+				} else throw new Error(`Filters on polys for ${f.kind} are not supported`);
+			} else if (field.kind === "o2o") {
+				const otherMeta = field.otherMetadata();
+				const a = getAlias(otherMeta.tableName);
+				const otherField = otherMeta.allFields[field.otherFieldName];
+				const otherColumn = otherField.kind === "poly" ? otherField.components.find((c) => c.otherMetadata() === meta || c.otherMetadata() === require_EntityMetadata.getBaseMeta(meta)).columnName : otherField.serde.columns[0].columnName;
+				addTable(field.otherMetadata(), a, "outer", require_queries_sql_keywords.kqDot(tableAlias, "id"), require_queries_sql_keywords.kqDot(a, otherColumn), subFilter[key], field.otherFieldName, targetCb);
+			} else if (field.kind === "o2m") {
+				const otherMeta = field.otherMetadata();
+				const otherField = otherMeta.allFields[field.otherFieldName];
+				let otherColumn = otherField.serde.columns[0].columnName;
+				if (otherField.kind === "poly") otherColumn = (otherField.components.find((c) => c.otherMetadata() === meta) ?? require_utils.fail(`No poly component found for ${otherField.fieldName}`)).columnName;
+				const isCtiBaseFk = otherMeta.inheritanceType === "cti" && field.otherFieldName && !(field.otherFieldName in otherMeta.fields);
+				const a = getAlias(otherMeta.tableName);
+				addTable(otherMeta, a, "outer", require_queries_sql_keywords.kqDot(tableAlias, "id"), require_queries_sql_keywords.kqDot(a, otherColumn), subFilter[key], field.otherFieldName, targetCb, true);
+				if (!isCtiBaseFk) {
+					const table = tables.find((t) => t.alias === a);
+					if (table && (table.join === "inner" || table.join === "outer")) table.collection = {
+						parentAlias: tableAlias,
+						rootAlias: a,
+						kind: "o2m"
+					};
+				}
+			} else if (field.kind === "m2m") {
+				const sub = subFilter[key];
+				const f = require_queries_valueFilters.parseEntityFilter(field.otherMetadata(), sub);
+				if (!f && !require_queries_find_Aliases.isAlias(sub)) return;
+				const ja = getAlias(field.joinTableName);
+				tables.push({
+					join: "outer",
+					alias: ja,
+					table: field.joinTableName,
+					col1: require_queries_sql_keywords.kqDot(tableAlias, "id"),
+					col2: require_queries_sql_keywords.kqDot(ja, field.columnNames[0]),
+					collection: {
+						parentAlias: tableAlias,
+						rootAlias: ja,
+						kind: "m2m"
+					}
+				});
+				if (require_queries_find_Aliases.isAlias(sub) || f?.kind === "join" || require_queries_entityQueryUtils.filterSoftDeletes(field.otherMetadata(), softDeletes)) {
+					const a = getAlias(field.otherMetadata().tableName);
+					addTable(field.otherMetadata(), a, "outer", require_queries_sql_keywords.kqDot(ja, field.columnNames[1]), require_queries_sql_keywords.kqDot(a, "id"), sub, void 0, targetCb, true);
+					const table = tables.find((t) => t.alias === a);
+					if (table && (table.join === "inner" || table.join === "outer")) table.collection = {
+						parentAlias: ja,
+						rootAlias: ja,
+						kind: "m2m"
+					};
+				} else if (f) {
+					const otherMeta = field.otherMetadata();
+					const column = {
+						columnName: field.columnNames[1],
+						dbType: otherMeta.idDbType,
+						mapToDb(value) {
+							return value === null ? value : require_keys.keyToNumber(otherMeta, require_keys.maybeResolveReferenceToId(value));
+						}
+					};
+					targetCb.addSimpleCondition({
+						kind: "column",
+						alias: ja,
+						column: field.columnNames[1],
+						dbType: otherMeta.idDbType,
+						cond: require_queries_valueFilters.mapToDb(column, f)
+					});
+				}
+			} else if (field.kind === "m2mEnum") {
+				const ja = getAlias(field.joinTableName);
+				tables.push({
+					join: "outer",
+					alias: ja,
+					table: field.joinTableName,
+					col1: require_queries_sql_keywords.kqDot(tableAlias, "id"),
+					col2: require_queries_sql_keywords.kqDot(ja, field.columnNames[0]),
+					collection: {
+						parentAlias: tableAlias,
+						rootAlias: ja,
+						kind: "m2m"
+					}
+				});
+				const column = {
+					columnName: field.columnNames[1],
+					dbType: "int",
+					mapToDb(value) {
+						return value === null || value === void 0 ? value : field.enumDetailType.getByCode(value).id;
+					}
+				};
+				require_queries_valueFilters.parseValueFilter(subFilter[key]).forEach((filter) => {
+					targetCb.addValueFilter(ja, column, filter);
+				});
+			} else throw new Error(`Unsupported field ${key}`);
+		});
+	}
+	function addLogicalFilter(meta, tableAlias, op, value, targetCb, parentJoin) {
+		const conditions = (Array.isArray(value) ? value : [value]).flatMap((filter) => {
+			const branchCb = new require_queries_ConditionBuilder.ConditionBuilder();
+			addFilterAt(meta, tableAlias, filter, branchCb, void 0, parentJoin);
+			const condition = branchCb.toExpressionFilter();
+			return condition ? [condition] : [];
+		});
+		if (conditions.length > 0) targetCb.addParsedExpression({
+			kind: "exp",
+			op,
+			conditions
+		});
+	}
+	function addOrderBy(meta, alias, orderBy) {
+		const entries = Object.entries(orderBy);
+		if (entries.length === 0) return;
+		for (const [key, value] of entries) {
+			if (!value) continue;
+			const field = meta.allFields[key] ?? require_utils.fail(`${key} not found on ${meta.tableName}`);
+			if (field.kind === "primitive" || field.kind === "primaryKey" || field.kind === "enum") {
+				const column = field.serde.columns[0];
+				orderBys.push({
+					alias: `${alias}${field.aliasSuffix ?? ""}`,
+					column: column.columnName,
+					order: value
+				});
+			} else if (field.kind === "m2o") {
+				let table = tables.find((t) => t.table === field.otherMetadata().tableName);
+				if (table) {
+					addTablePerClassJoinsAndClassTag(query, field.otherMetadata(), table.alias, false);
+					addOrderBy(field.otherMetadata(), table.alias, value);
+				} else {
+					const table = field.otherMetadata().tableName;
+					const a = getAlias(table);
+					const column = field.serde.columns[0].columnName;
+					const fa = require_queries_find_Aliases.getMaybeCtiAlias(meta, field, meta, alias);
+					tables.push({
+						alias: a,
+						table,
+						join: "outer",
+						col1: require_queries_sql_keywords.kqDot(fa, column),
+						col2: require_queries_sql_keywords.kqDot(a, "id"),
+						distinct: false
+					});
+					addTablePerClassJoinsAndClassTag(query, field.otherMetadata(), a, false);
+					addOrderBy(field.otherMetadata(), a, value);
+				}
+			} else throw new Error(`Unsupported field ${key}`);
+		}
+	}
+	const alias$1 = getAlias(meta.tableName);
+	if (meta.hasLazyColumns) selects.push(...require_queries_entityQueryUtils.lazyExcludedSelects(meta, alias$1));
+	else selects.push(`${require_queries_sql_keywords.kq(alias$1)}.*`);
+	addTable(meta, alias$1, "primary", "n/a", "n/a", filter);
+	if (optsExpression) {
+		checkDomainCondition(optsExpression);
+		cb.maybeAddExpression(optsExpression);
+	}
+	Object.assign(query, { condition: cb.toExpressionFilter() });
+	resolveAliasConditions(query, aliasBindings);
+	if (query.tables.some((t) => t.join === "outer")) maybeAddIdNotNulls(query);
+	if (orderBy) {
+		if (Array.isArray(orderBy)) for (const ob of orderBy) addOrderBy(meta, alias$1, ob);
+		else addOrderBy(meta, alias$1, orderBy);
+	}
+	maybeAddOrderBy(query, meta, alias$1);
+	if (pruneJoins) require_queries_find_QueryParser_pruning.pruneUnusedJoins(query, keepAliases);
+	return query;
+}
+/**
+* Look for conditions doing `some_column IS NULL` in an outer join that
+* need an `id IS NOT NULL` to make sure they don't match inadvertently on
+* the child row simply not existing.
+*
+* Note: Instead of injecting an extra `id IS NOT NULL` condition, I had tried
+* using all INNER JOINs and flipping joins to OUTER only if the user explicit
+* had `id IS NULL` in their filter, but that didn't work for queries that wanted
+* to do an `OR` across two different children (which queries both children being
+* OUTER JOINs, and detecting that case seemed complicated).
+*/
+function maybeAddIdNotNulls(query) {
+	require_queries_find_QueryVisitor.visitConditions(query, { visitCond(c) {
+		if (c.cond.kind !== "is-null" || c.column === "id" || c.pruneable) return c;
+		const table = query.tables.find((t) => t.alias === c.alias);
+		if (table && table.join === "outer") {
+			const meta = require_configure.getMetadataForTable(table.table);
+			return {
+				kind: "exp",
+				op: "and",
+				conditions: [c, {
+					kind: "column",
+					alias: c.alias,
+					column: "id",
+					dbType: meta.idDbType,
+					cond: { kind: "not-null" }
+				}]
+			};
+		}
+		return c;
+	} });
+}
+/** Returns the `a` from `"a".*`. */
+function parseAlias(alias) {
+	return alias.split(".")[0].replaceAll(`"`, "");
+}
+/** Finds a filter field by fieldName or generated fieldIdName. */
+function findFilterField(meta, key) {
+	return meta.allFields[key] ?? meta.polyComponentFields?.[key] ?? Object.values(meta.allFields).find((field) => field.fieldIdName === key) ?? Object.values(meta.polyComponentFields ?? {}).find((field) => field.fieldIdName === key);
+}
+/** Adds any user-configured default order, plus an "always order by id" for determinism. */
+function maybeAddOrderBy(query, meta, alias) {
+	const { orderBys } = query;
+	if (meta.orderBy) {
+		const column = (meta.allFields[meta.orderBy] ?? require_utils.fail(`${meta.orderBy} not found on ${meta.tableName}`)).serde.columns[0].columnName;
+		if (!orderBys.find((o) => o.alias === alias && o.column === column)) orderBys.push({
+			alias,
+			column,
+			order: "ASC"
+		});
+	}
+	if (!orderBys.find((o) => o.alias === alias && o.column === "id")) orderBys.push({
+		alias,
+		column: "id",
+		order: "ASC"
+	});
+}
+function addTablePerClassJoinsAndClassTag(query, meta, alias, isPrimary) {
+	if (!needsClassPerTableJoins(meta)) return;
+	const { selects, tables } = query;
+	meta.baseTypes.forEach((bt, i) => {
+		if (isPrimary) selects.push(`${alias}_b${i}.*`);
+		tables.push({
+			alias: `${alias}_b${i}`,
+			table: bt.tableName,
+			join: "outer",
+			col1: require_queries_sql_keywords.kqDot(alias, "id"),
+			col2: `${alias}_b${i}.id`,
+			distinct: false
+		});
+	});
+	if (isPrimary) {
+		const stColumns = [];
+		meta.subTypes.forEach((st, i) => {
+			const stAlias = `${alias}_s${i}`;
+			selects.push(`${stAlias}.*`);
+			tables.push({
+				alias: stAlias,
+				table: st.tableName,
+				join: "outer",
+				col1: require_queries_sql_keywords.kqDot(alias, "id"),
+				col2: `${alias}_s${i}.id`,
+				distinct: false
+			});
+			for (const field of Object.values(st.fields)) if (field.fieldName !== "id" && field.serde) for (const c of field.serde?.columns) stColumns.push({
+				stAlias,
+				columnName: c.columnName
+			});
+		});
+		selects.push(`${require_queries_sql_keywords.kq(alias)}.id as id`);
+		Object.values((0, joist_utils.groupBy)(stColumns, (c) => c.columnName)).filter((columns) => columns.length > 1).forEach((columns) => {
+			const { columnName } = columns[0];
+			selects.push(`COALESCE(${columns.map((c) => `${c.stAlias}.${columnName}`).join(", ")}) as ${columnName}`);
+		});
+		const cases = meta.subTypes.map((st, i) => `WHEN ${alias}_s${i}.id IS NOT NULL THEN '${st.type}'`);
+		if (cases.length > 0) selects.push(`CASE ${cases.join(" ")} ELSE '_' END as __class`);
+	}
+}
+/** Rejects SQL predicates throughout a domain condition tree before optional-filter pruning. */
+function checkDomainCondition(condition) {
+	if (!condition) return;
+	if (require_queries_sql_Expr.isDeferredCondition(condition) || require_queries_conditions.predicateBrand in condition && condition[require_queries_conditions.predicateBrand] === "sql") require_utils.fail("SQL predicates are only supported by em.query/em.execute; use alias(...) predicates in em.find and scopes.");
+	if ("and" in condition && condition.and) for (const child of condition.and) checkDomainCondition(child);
+	else if ("or" in condition && condition.or) for (const child of condition.or) checkDomainCondition(child);
+}
+/** Resolves every `DeferredAliasCondition` in `query` against the parse's alias bindings. */
+function resolveAliasConditions(query, bindings) {
+	function resolve(handle) {
+		return bindings.get(handle) ?? require_utils.fail(`Alias for ${handle.tableName} is not bound to this query's join literal`);
+	}
+	function maybeResolve(c) {
+		return require_queries_find_DeferredAlias.isDeferredAliasCondition(c) ? c[require_queries_find_DeferredAlias.deferredAliasSym](resolve) : void 0;
+	}
+	require_queries_find_QueryVisitor.visitConditions(query, {
+		visitCond: maybeResolve,
+		visitRaw: maybeResolve
+	});
+}
+function getTables(query) {
+	let primary;
+	const joins = [];
+	const laterals = [];
+	const crosses = [];
+	for (const table of query.tables) if (table.join === "primary") primary = table;
+	else if (table.join === "lateral") laterals.push(table);
+	else if (table.join === "cross") crosses.push(table);
+	else joins.push(table);
+	return [
+		primary,
+		joins,
+		laterals,
+		crosses
+	];
+}
+function needsClassPerTableJoins(meta) {
+	return meta.inheritanceType === "cti" && (meta.subTypes.length > 0 || meta.baseTypes.length > 0);
+}
+function needsStiDiscriminator(meta) {
+	return meta.inheritanceType === "sti" && !meta.stiDiscriminatorField;
+}
+function addStiSubtypeFilter(cb, subtypeMeta, alias) {
+	const cond = require_queries_entityQueryUtils.stiSubtypeFilter(subtypeMeta, alias);
+	if (cond) cb.addSimpleCondition(cond);
+}
+//#endregion
+exports.addTablePerClassJoinsAndClassTag = addTablePerClassJoinsAndClassTag;
+exports.findFilterField = findFilterField;
+exports.getTables = getTables;
+exports.maybeAddIdNotNulls = maybeAddIdNotNulls;
+exports.maybeAddOrderBy = maybeAddOrderBy;
+exports.parseAlias = parseAlias;
+exports.parseFindQuery = parseFindQuery;
+
+//# sourceMappingURL=QueryParser.cjs.map