joist-core 2.3.0 → 2.4.0

package/build/queries/find/QueryParser.collectionJoins.js

@@ -0,0 +1,352 @@
+import { pruneUnusedJoins, selectReferencesAlias } from "./QueryParser.pruning.js";
+import { maybeAddIdNotNulls, parseAlias } from "./QueryParser.js";
+import { assertNever } from "../../utils.js";
+//#region src/queries/find/QueryParser.collectionJoins.ts
+/**
+* Rewrites eligible logical collection LEFT JOINs into EXISTS after plugins have mutated the AST.
+*
+* QueryParser intentionally leaves collection filters as ordinary joins so `beforeFind` plugins see
+* stabler/simpler input than "sometimes JOINs / sometimes EXISTS".
+*
+* This pass runs after plugins and before SQL rendering:
+*
+* 1. `rewriteCollectionJoins` finds top-level collection joins and moves conditions that reference only
+*    that subtree into a correlated EXISTS subquery. I.e. `{ books: { title: "b1" } }` becomes
+*    `EXISTS (SELECT 1 FROM books b WHERE a.id = b.author_id AND b.title = 'b1')`.
+* 2. The same helper recurses into the generated subquery, so nested collections become nested EXISTS clauses.
+*    I.e. `{ books: { reviews: { rating: 5 } } }` becomes EXISTS(books WHERE EXISTS(reviews)).
+* 3. Conditions that cannot be safely moved stay as LEFT JOINs. I.e. `OR(b.title = 'x', a.first_name = 'x')`
+*    needs both aliases in one SQL scope, so `b` remains a join instead of becoming an EXISTS.
+* 4. Remaining fanout LEFT JOIN roots are rejected unless `allowMultipleLeftJoins` is set,
+*    because they can produce cross-product row explosions.
+* 5. Finally, `maybeAddIdNotNulls` and `pruneUnusedJoins` clean up the joins that remain.
+*/
+function optimizeCollectionJoins(query, opts = {}) {
+	const { allowMultipleLeftJoins = false, optimizeJoinsToExists = true, pruneJoins = true, keepAliases = [] } = opts;
+	for (const table of query.tables) if (table.join === "lateral") optimizeCollectionJoins(table.query, {
+		...opts,
+		pruneJoins: false
+	});
+	if (optimizeJoinsToExists) rewriteCollectionJoins(query, keepAliases);
+	const fanoutLeftJoinAliases = getCollectionRoots(query).filter((root) => conditionBlocksExistsRewrite(query.condition, root.aliases)).map((root) => root.table.alias);
+	if (optimizeJoinsToExists && !allowMultipleLeftJoins && fanoutLeftJoinAliases.length > 1) throw new Error(`em.find would issue multiple LEFT JOINs across collection relations (${fanoutLeftJoinAliases.join(", ")}); pass allowMultipleLeftJoins: true if this fanout is intentional`);
+	if (query.tables.some((t) => t.join === "outer")) maybeAddIdNotNulls(query);
+	if (pruneJoins) pruneUnusedJoins(query, keepAliases);
+}
+/**
+* Rewrites root-level collection join subtrees into EXISTS when their conditions are locally scoped.
+*
+* I.e. for `authors a -> books b -> book_reviews br`, `b` is the collection root and `br` is part of its subtree.
+*/
+function rewriteCollectionJoins(query, keepAliases = []) {
+	const roots = getCollectionRoots(query);
+	if (query.condition) rewriteSiblingOrExpression(query, query.condition, roots, keepAliases);
+	for (const root of roots) {
+		if (queryReferencesAliasesOutsideConditions(query, root.aliases, keepAliases)) continue;
+		if (conditionHasCrossScopeReference(query.condition, root.aliases)) continue;
+		const moved = query.condition ? removeLocallyScopedConditions(query.condition, root.aliases) : [];
+		if (moved.length === 0) continue;
+		const exists = createExistsCondition(query, root, moved);
+		if (!exists) {
+			addConditions(query, moved);
+			continue;
+		}
+		addConditions(query, [exists]);
+		query.tables = query.tables.filter((t) => !root.aliases.has(t.alias));
+	}
+	removeEmptyExpressions(query.condition);
+}
+/** Rewrites eligible sibling collection ORs while preserving outer/mixed-scope ORs as joins. */
+function rewriteSiblingOrExpression(query, condition, roots, keepAliases) {
+	if (condition.kind !== "exp") return;
+	if (condition.op === "or" && rewriteSiblingOrExpressionChildren(query, condition, roots, keepAliases)) return;
+	if (condition.op === "and") for (const child of condition.conditions) rewriteSiblingOrExpression(query, child, roots, keepAliases);
+}
+/** Returns true when OR branches that are scoped to collection subtrees became EXISTS conditions. */
+function rewriteSiblingOrExpressionChildren(query, exp, roots, keepAliases) {
+	const matches = [];
+	const usedAliases = /* @__PURE__ */ new Set();
+	const usedRoots = /* @__PURE__ */ new Set();
+	let hasAntiJoinBranch = false;
+	for (const condition of exp.conditions) {
+		if (!isRealCondition(condition)) return false;
+		const match = roots.find((root) => conditionReferencesOnlyAliases(condition, root.aliases));
+		if (!match) {
+			const found = conditionAliases(condition);
+			if (roots.some((root) => hasAnyAlias(found, root.aliases))) return false;
+			continue;
+		}
+		matches.push({
+			collectionRoot: match,
+			condition
+		});
+		usedRoots.add(match.table.alias);
+		hasAntiJoinBranch ||= isCollectionAntiJoin(condition, match);
+		for (const alias of match.aliases) usedAliases.add(alias);
+	}
+	if (matches.length === 0) return false;
+	if (matches.length === exp.conditions.length && usedRoots.size < 2 && !hasAntiJoinBranch || conditionReferencesAliasesOutside(query.condition, exp, usedAliases) || queryReferencesAliasesOutsideConditions(query, usedAliases, keepAliases)) return false;
+	const existsConditions = /* @__PURE__ */ new Map();
+	for (const match of matches) {
+		const exists = createExistsCondition(query, match.collectionRoot, [match.condition]);
+		if (!exists) return false;
+		existsConditions.set(match.condition, exists);
+	}
+	exp.conditions = exp.conditions.map((condition) => existsConditions.get(condition) ?? condition);
+	return true;
+}
+/** Creates an EXISTS/NOT EXISTS condition for moved collection filters, or undefined when a LEFT JOIN must stay. */
+function createExistsCondition(query, collectionRoot, moved) {
+	const root = collectionRoot.table;
+	const hasOnlyAntiJoin = moved.length === 1 && isCollectionAntiJoin(moved[0], collectionRoot);
+	if (!hasOnlyAntiJoin && !moved.some(isRealCondition)) return;
+	if (!hasOnlyAntiJoin && moved.some((c) => conditionContainsCollectionAntiJoin(c, collectionRoot))) return;
+	const correlationAliases = joinDependencies(root);
+	const correlation = {
+		kind: "raw",
+		aliases: [root.alias, ...correlationAliases],
+		condition: `${root.col1} = ${root.col2}`,
+		bindings: [],
+		pruneable: false
+	};
+	const conditions = hasOnlyAntiJoin ? [correlation] : [correlation, ...moved];
+	const subquery = {
+		selects: ["1"],
+		tables: query.tables.filter((t) => hasOnlyAntiJoin ? t.alias === root.alias : collectionRoot.aliases.has(t.alias)).map((t) => {
+			if (t.alias === root.alias) return {
+				join: "primary",
+				alias: t.alias,
+				table: t.table
+			};
+			if (t.join === "outer") return {
+				...t,
+				distinct: false
+			};
+			return t;
+		}),
+		condition: {
+			kind: "exp",
+			op: "and",
+			conditions
+		},
+		orderBys: []
+	};
+	rewriteCollectionJoins(subquery);
+	return {
+		kind: "exists",
+		negate: hasOnlyAntiJoin,
+		subquery,
+		outerAliases: correlationAliases
+	};
+}
+/** Appends conditions to the top-level expression, creating an AND wrapper when needed. */
+function addConditions(query, conditions) {
+	query.condition ??= {
+		kind: "exp",
+		op: "and",
+		conditions: []
+	};
+	query.condition.conditions.push(...conditions);
+}
+/** Returns top-level collection roots with their full join subtrees. */
+function getCollectionRoots(query) {
+	return getTopLevelCollectionRoots(query).map((table) => {
+		const aliases = collectJoinSubtreeAliases(query, table.alias);
+		return {
+			table,
+			aliases,
+			joinTables: query.tables.filter((t) => isJoinTable(t) && aliases.has(t.alias))
+		};
+	});
+}
+/** Returns top-level collection roots, i.e. `books b` but not nested `book_reviews br`. */
+function getTopLevelCollectionRoots(query) {
+	const joinTables = query.tables.filter(isJoinTable);
+	const collectionAliases = new Set(joinTables.flatMap((t) => t.collection ? [t.alias] : []));
+	return joinTables.filter((t) => t.collection?.rootAlias === t.alias && !collectionAliases.has(t.collection.parentAlias));
+}
+/** Returns true if a remaining real condition prevents this subtree from becoming EXISTS, i.e. a cross-scope OR. */
+function conditionBlocksExistsRewrite(condition, aliases) {
+	if (!condition || !isRealCondition(condition)) return false;
+	if (condition.kind === "exp" && condition.op === "and") return condition.conditions.some((c) => conditionBlocksExistsRewrite(c, aliases));
+	return conditionReferencesAnyAlias(condition, aliases);
+}
+/** Collects a collection root and all joins that depend on it, i.e. `b -> br -> c`. */
+function collectJoinSubtreeAliases(query, rootAlias) {
+	const aliases = /* @__PURE__ */ new Set([rootAlias]);
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const table of query.tables) {
+			if (!isJoinTable(table)) continue;
+			if (!aliases.has(table.alias) && joinReferencesAnyAlias(table, aliases)) {
+				aliases.add(table.alias);
+				changed = true;
+			}
+		}
+	}
+	return aliases;
+}
+/**
+* Removes AND-safe conditions whose aliases all live inside one collection subtree.
+*
+* I.e. in `a.age = 1 AND b.title = 'x'`, only `b.title = 'x'` moves. In `b.title = 'x' OR br.rating = 5`,
+* the whole OR moves only if every alias is inside the same subtree.
+*/
+function removeLocallyScopedConditions(exp, aliases) {
+	if (exp.op === "or") {
+		if (!conditionReferencesOnlyAliases(exp, aliases)) return [];
+		const moved = {
+			...exp,
+			conditions: [...exp.conditions]
+		};
+		exp.conditions = [];
+		return [moved];
+	}
+	const moved = [];
+	for (let i = exp.conditions.length - 1; i >= 0; i--) {
+		const condition = exp.conditions[i];
+		if (condition.kind === "exp" && condition.op === "and") {
+			moved.push(...removeLocallyScopedConditions(condition, aliases));
+			if (condition.conditions.length === 0) exp.conditions.splice(i, 1);
+		} else if (conditionReferencesOnlyAliases(condition, aliases)) {
+			moved.unshift(condition);
+			exp.conditions.splice(i, 1);
+		}
+	}
+	return moved;
+}
+/** Returns true when a condition references at least one alias and all aliases are in `aliases`, i.e. only `b`/`br`. */
+function conditionReferencesOnlyAliases(condition, aliases) {
+	const found = conditionAliases(condition);
+	return found.size > 0 && [...found].every((alias) => aliases.has(alias));
+}
+/** Returns true when `aliases` are referenced by a real condition other than the targeted OR expression. */
+function conditionReferencesAliasesOutside(condition, target, aliases) {
+	if (!condition || condition === target || !isRealCondition(condition)) return false;
+	if (condition.kind === "exp") return condition.conditions.some((child) => conditionReferencesAliasesOutside(child, target, aliases));
+	return conditionReferencesAnyAlias(condition, aliases);
+}
+/** Returns true when selected/ordered aliases would force these joins to remain in the outer query. */
+function queryReferencesAliasesOutsideConditions(query, aliases, keepAliases) {
+	return hasAnyAlias(queryRequiredAliasesOutsideConditions(query, keepAliases), aliases);
+}
+/**
+* Returns aliases needed by SELECT/GROUP/ORDER plus their join dependencies.
+*
+* I.e. `array_agg(br.rating)` requires `br`, and then `br` requires `b` because it joins through `b`.
+*/
+function queryRequiredAliasesOutsideConditions(query, keepAliases) {
+	const required = /* @__PURE__ */ new Set();
+	for (const alias of keepAliases) required.add(alias);
+	for (const orderBy of query.orderBys) required.add(orderBy.alias);
+	for (const groupBy of query.groupBys ?? []) if ("expression" in groupBy) addSelectAliases(query, required, groupBy.expression);
+	else required.add(groupBy.alias);
+	for (const select of query.selects) if (typeof select === "string") addSelectAliases(query, required, select);
+	else if ("aliases" in select) {
+		for (const alias of select.aliases) required.add(alias);
+		addSelectAliases(query, required, select.sql);
+	}
+	const todo = [...required];
+	while (todo.length > 0) {
+		const alias = todo.pop();
+		const table = query.tables.find((t) => t.alias === alias);
+		if (!table || !isJoinTable(table)) continue;
+		for (const dependency of joinDependencies(table)) if (!required.has(dependency)) {
+			required.add(dependency);
+			todo.push(dependency);
+		}
+	}
+	return required;
+}
+/** Adds aliases referenced by raw select SQL, i.e. `array_agg(br.rating)` requires `br`. */
+function addSelectAliases(query, required, select) {
+	for (const table of query.tables) if (selectReferencesAlias(select, table.alias)) required.add(table.alias);
+}
+/** Returns the aliases needed to evaluate a join's ON clause, excluding the joined alias itself. */
+function joinDependencies(table) {
+	return [parseAlias(table.col1), parseAlias(table.col2)].filter((alias) => alias !== table.alias);
+}
+/** Returns true when a condition references this subtree and another scope, i.e. `b.title = 'x' OR c.text = 'x'`. */
+function conditionHasCrossScopeReference(condition, aliases) {
+	if (!condition || !isRealCondition(condition)) return false;
+	if (condition.kind === "exp" && condition.op === "and") return condition.conditions.some((child) => conditionHasCrossScopeReference(child, aliases));
+	const found = conditionAliases(condition);
+	return hasAnyAlias(found, aliases) && ![...found].every((alias) => aliases.has(alias));
+}
+/** Returns true when a condition references any alias in `aliases`, i.e. `b` in `b.title = c.text`. */
+function conditionReferencesAnyAlias(condition, aliases) {
+	return hasAnyAlias(conditionAliases(condition), aliases);
+}
+/** Returns true when `table` is an ordinary SQL join. */
+function isJoinTable(table) {
+	return table.join === "inner" || table.join === "outer";
+}
+/** Returns true when a join's ON clause references any alias in `aliases`. */
+function joinReferencesAnyAlias(table, aliases) {
+	return joinDependencies(table).some((alias) => aliases.has(alias));
+}
+/** Returns true when two alias sets overlap. */
+function hasAnyAlias(found, aliases) {
+	return [...found].some((alias) => aliases.has(alias));
+}
+/** Returns true for collection anti-joins, i.e. `b.id IS NULL` or m2m target `t.id IS NULL` for root `att`. */
+function isCollectionAntiJoin(condition, root) {
+	return collectionAntiJoinAliases(root).some((alias) => isAliasIdNull(condition, alias));
+}
+/** Returns aliases whose `id IS NULL` means the collection root has no matching row. */
+function collectionAntiJoinAliases(root) {
+	return [...root.aliases].filter((alias) => {
+		if (alias === root.table.alias) return true;
+		return rootTable(root, alias)?.collection?.rootAlias === root.table.alias;
+	});
+}
+/** Returns a join table from a collection subtree by alias. */
+function rootTable(root, alias) {
+	return root.joinTables.find((table) => table.alias === alias);
+}
+/** Returns true for `alias.id IS NULL`, i.e. the parse shape for `{ books: { id: null } }`. */
+function isAliasIdNull(condition, alias) {
+	return condition.kind === "column" && condition.alias === alias && condition.column === "id" && condition.cond.kind === "is-null";
+}
+/** Returns true when a condition tree contains a collection anti-join branch inside an OR. */
+function conditionContainsCollectionAntiJoin(condition, root) {
+	if (isCollectionAntiJoin(condition, root)) return true;
+	if (condition.kind === "exp") return condition.conditions.some((c) => conditionContainsCollectionAntiJoin(c, root));
+	return false;
+}
+/** Removes empty expression wrappers left behind by condition movement, i.e. `AND []` after all children moved. */
+function removeEmptyExpressions(exp) {
+	if (!exp) return;
+	for (let i = exp.conditions.length - 1; i >= 0; i--) {
+		const condition = exp.conditions[i];
+		if (condition.kind === "exp") {
+			removeEmptyExpressions(condition);
+			if (condition.conditions.length === 0) exp.conditions.splice(i, 1);
+		}
+	}
+}
+/** Returns true if a condition must be preserved to maintain query semantics, i.e. user filters vs soft-delete filters. */
+function isRealCondition(condition) {
+	if (condition.kind === "column" || condition.kind === "raw") return !condition.pruneable;
+	else if (condition.kind === "exists") return true;
+	else if (condition.kind === "exp") return condition.conditions.some(isRealCondition);
+	else assertNever(condition);
+}
+/** Returns all aliases referenced by a condition, i.e. `b` and `a` in an OR. */
+function conditionAliases(condition) {
+	const aliases = /* @__PURE__ */ new Set();
+	collectAllAliases(condition, aliases);
+	return aliases;
+}
+/** Collects all aliases referenced by a condition, including inside nested expressions, i.e. `b` and `a` in an OR. */
+function collectAllAliases(cond, out) {
+	if (cond.kind === "column") out.add(cond.alias);
+	else if (cond.kind === "raw") for (const a of cond.aliases) out.add(a);
+	else if (cond.kind === "exp") for (const c of cond.conditions) collectAllAliases(c, out);
+	else if (cond.kind === "exists") {} else assertNever(cond);
+}
+//#endregion
+export { optimizeCollectionJoins };
+
+//# sourceMappingURL=QueryParser.collectionJoins.js.map

package/build/queries/find/QueryParser.collectionJoins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryParser.collectionJoins.js","names":[],"sources":["../../../src/queries/find/QueryParser.collectionJoins.ts"],"sourcesContent":["import { pruneUnusedJoins, selectReferencesAlias } from \"src/queries/find/QueryParser.pruning.ts\";\nimport {\n  type JoinTable,\n  type ParsedFindQuery,\n  type PrimaryTable,\n  maybeAddIdNotNulls,\n  parseAlias,\n} from \"src/queries/find/QueryParser.ts\";\nimport type {\n  ExistsCondition,\n  ParsedExpressionCondition,\n  ParsedExpressionFilter,\n  RawCondition,\n} from \"src/queries/parsedConditions.ts\";\nimport { assertNever } from \"src/utils.ts\";\n\n/** A collection root plus every join nested under it, i.e. `books b` with `book_reviews br`. */\ninterface CollectionRoot {\n  /** The top-level collection join that becomes the EXISTS FROM table, i.e. `books b`. */\n  table: JoinTable;\n  /** Every alias in this collection subtree, i.e. `b` and `br` for `authors -> books -> reviews`. */\n  aliases: Set<string>;\n  /** Every join table in this collection subtree, i.e. `att` and `t` for an m2m tag filter. */\n  joinTables: JoinTable[];\n}\n\n/**\n * Rewrites eligible logical collection LEFT JOINs into EXISTS after plugins have mutated the AST.\n *\n * QueryParser intentionally leaves collection filters as ordinary joins so `beforeFind` plugins see\n * stabler/simpler input than \"sometimes JOINs / sometimes EXISTS\".\n *\n * This pass runs after plugins and before SQL rendering:\n *\n * 1. `rewriteCollectionJoins` finds top-level collection joins and moves conditions that reference only\n *    that subtree into a correlated EXISTS subquery. I.e. `{ books: { title: \"b1\" } }` becomes\n *    `EXISTS (SELECT 1 FROM books b WHERE a.id = b.author_id AND b.title = 'b1')`.\n * 2. The same helper recurses into the generated subquery, so nested collections become nested EXISTS clauses.\n *    I.e. `{ books: { reviews: { rating: 5 } } }` becomes EXISTS(books WHERE EXISTS(reviews)).\n * 3. Conditions that cannot be safely moved stay as LEFT JOINs. I.e. `OR(b.title = 'x', a.first_name = 'x')`\n *    needs both aliases in one SQL scope, so `b` remains a join instead of becoming an EXISTS.\n * 4. Remaining fanout LEFT JOIN roots are rejected unless `allowMultipleLeftJoins` is set,\n *    because they can produce cross-product row explosions.\n * 5. Finally, `maybeAddIdNotNulls` and `pruneUnusedJoins` clean up the joins that remain.\n */\nexport function optimizeCollectionJoins(\n  query: ParsedFindQuery,\n  opts: {\n    allowMultipleLeftJoins?: boolean;\n    optimizeJoinsToExists?: boolean;\n    pruneJoins?: boolean;\n    keepAliases?: string[];\n  } = {},\n): void {\n  const { allowMultipleLeftJoins = false, optimizeJoinsToExists = true, pruneJoins = true, keepAliases = [] } = opts;\n  for (const table of query.tables) {\n    // I.e. batched find/count queries wrap the real query in a LATERAL subquery; optimize that inner query too,\n    // but let the outer query decide final pruning so it can keep the lateral alias itself.\n    if (table.join === \"lateral\") optimizeCollectionJoins(table.query, { ...opts, pruneJoins: false });\n  }\n  if (optimizeJoinsToExists) rewriteCollectionJoins(query, keepAliases);\n\n  // I.e. collection LEFT JOINs now fall into three buckets:\n  // 1. local real filters, like `{ books: { title: \"b1\" } }`, were rewritten to EXISTS above;\n  // 2. no local real filters, like `{ books: {}, comments: {} }`, are safe because pruning will remove them;\n  // 3. blocked real filters, like cross-scope ORs, must stay as LEFT JOINs and can multiply rows.\n  // Only the third bucket should trip the fanout guard.\n  const fanoutLeftJoinAliases = getCollectionRoots(query)\n    .filter((root) => conditionBlocksExistsRewrite(query.condition, root.aliases))\n    .map((root) => root.table.alias);\n  if (optimizeJoinsToExists && !allowMultipleLeftJoins && fanoutLeftJoinAliases.length > 1) {\n    throw new Error(\n      `em.find would issue multiple LEFT JOINs across collection relations (${fanoutLeftJoinAliases.join(\n        \", \",\n      )}); pass allowMultipleLeftJoins: true if this fanout is intentional`,\n    );\n  }\n\n  if (query.tables.some((t) => t.join === \"outer\")) {\n    // I.e. preserve legacy LEFT JOIN null semantics for any joins that could not become EXISTS.\n    maybeAddIdNotNulls(query);\n  }\n  if (pruneJoins) {\n    // I.e. remove logical collection joins that were replaced by EXISTS and any joins only needed before plugin edits.\n    pruneUnusedJoins(query, keepAliases);\n  }\n}\n\n/**\n * Rewrites root-level collection join subtrees into EXISTS when their conditions are locally scoped.\n *\n * I.e. for `authors a -> books b -> book_reviews br`, `b` is the collection root and `br` is part of its subtree.\n */\nfunction rewriteCollectionJoins(query: ParsedFindQuery, keepAliases: string[] = []): void {\n  const roots = getCollectionRoots(query);\n  if (query.condition) rewriteSiblingOrExpression(query, query.condition, roots, keepAliases);\n  for (const root of roots) {\n    if (queryReferencesAliasesOutsideConditions(query, root.aliases, keepAliases)) continue;\n    if (conditionHasCrossScopeReference(query.condition, root.aliases)) continue;\n    // I.e. move `b.title = 'x'` and `(br.rating = 5 OR br.rating = 4)`, but not `b.title = 'x' OR a.first_name = 'x'`.\n    const moved = query.condition ? removeLocallyScopedConditions(query.condition, root.aliases) : [];\n    if (moved.length === 0) continue;\n    const exists = createExistsCondition(query, root, moved);\n    if (!exists) {\n      addConditions(query, moved);\n      continue;\n    }\n    addConditions(query, [exists]);\n    // I.e. after adding EXISTS, remove `books b` and its children from the outer FROM list.\n    query.tables = query.tables.filter((t) => !root.aliases.has(t.alias));\n  }\n  removeEmptyExpressions(query.condition);\n}\n\n/** Rewrites eligible sibling collection ORs while preserving outer/mixed-scope ORs as joins. */\nfunction rewriteSiblingOrExpression(\n  query: ParsedFindQuery,\n  condition: ParsedExpressionCondition,\n  roots: CollectionRoot[],\n  keepAliases: string[],\n): void {\n  if (condition.kind !== \"exp\") return;\n  if (condition.op === \"or\" && rewriteSiblingOrExpressionChildren(query, condition, roots, keepAliases)) return;\n  if (condition.op === \"and\") {\n    for (const child of condition.conditions) rewriteSiblingOrExpression(query, child, roots, keepAliases);\n  }\n}\n\n/** Returns true when OR branches that are scoped to collection subtrees became EXISTS conditions. */\nfunction rewriteSiblingOrExpressionChildren(\n  query: ParsedFindQuery,\n  exp: ParsedExpressionFilter,\n  roots: CollectionRoot[],\n  keepAliases: string[],\n): boolean {\n  const matches: { collectionRoot: CollectionRoot; condition: ParsedExpressionCondition }[] = [];\n  const usedAliases = new Set<string>();\n  const usedRoots = new Set<string>();\n  let hasAntiJoinBranch = false;\n  for (const condition of exp.conditions) {\n    if (!isRealCondition(condition)) return false;\n    const match = roots.find((root) => conditionReferencesOnlyAliases(condition, root.aliases));\n    if (!match) {\n      const found = conditionAliases(condition);\n      // I.e. `a.first_name = 'x'` can stay in the OR while `b.title = 'x'` becomes EXISTS, but\n      // `a.first_name = 'x' AND b.title = 'x'` must stay joined because one branch spans both scopes.\n      if (roots.some((root) => hasAnyAlias(found, root.aliases))) return false;\n      continue;\n    }\n    matches.push({ collectionRoot: match, condition });\n    usedRoots.add(match.table.alias);\n    hasAntiJoinBranch ||= isCollectionAntiJoin(condition, match);\n    for (const alias of match.aliases) usedAliases.add(alias);\n  }\n  if (matches.length === 0) return false;\n  // I.e. rewrite true sibling collection ORs like `b.id IS NOT NULL OR c.id IS NOT NULL`, and same-root\n  // anti-join ORs like `b.id IS NULL OR br.rating = 5` that need `b.id IS NULL` to become `NOT EXISTS`.\n  // skip positive-only single-root ORs, i.e. ORs with no `b.id IS NULL` anti-join branch like\n  // `b.title = 'x' OR br.rating = 5`; mixed ordinary/collection ORs like `a.first_name = 'x' OR b.title = 'x'`\n  // are safe because only the collection branch is replaced. Aliases are also filtered elsewhere like\n  // `b.order = 1 AND (b.title = 'x' OR c.text = 'x')`, and aliases that must stay projected/sorted like\n  // `SELECT b.title` or `ORDER BY b.title`.\n  if (\n    (matches.length === exp.conditions.length && usedRoots.size < 2 && !hasAntiJoinBranch) ||\n    conditionReferencesAliasesOutside(query.condition, exp, usedAliases) ||\n    queryReferencesAliasesOutsideConditions(query, usedAliases, keepAliases)\n  ) {\n    return false;\n  }\n\n  const existsConditions = new Map<ParsedExpressionCondition, ExistsCondition>();\n  for (const match of matches) {\n    const exists = createExistsCondition(query, match.collectionRoot, [match.condition]);\n    if (!exists) return false;\n    existsConditions.set(match.condition, exists);\n  }\n  exp.conditions = exp.conditions.map((condition) => existsConditions.get(condition) ?? condition);\n  // I.e. leave the collection joins in place for now; pruning removes them after all rewrites.\n  return true;\n}\n\n/** Creates an EXISTS/NOT EXISTS condition for moved collection filters, or undefined when a LEFT JOIN must stay. */\nfunction createExistsCondition(\n  query: ParsedFindQuery,\n  collectionRoot: CollectionRoot,\n  moved: ParsedExpressionCondition[],\n): ExistsCondition | undefined {\n  const root = collectionRoot.table;\n  const hasOnlyAntiJoin = moved.length === 1 && isCollectionAntiJoin(moved[0], collectionRoot);\n  if (!hasOnlyAntiJoin && !moved.some(isRealCondition)) {\n    // I.e. only soft-delete/STI conditions moved; don't create an EXISTS that changes nothing.\n    return undefined;\n  }\n  if (!hasOnlyAntiJoin && moved.some((c) => conditionContainsCollectionAntiJoin(c, collectionRoot))) {\n    // I.e. `b.id IS NULL OR br.rating = 5` is not a pure anti-join; leave it as a LEFT JOIN for SQL semantics.\n    return undefined;\n  }\n\n  // I.e. `rpm` may correlate through `_pp_version.id = rpm.ready_plan_version_id`, so pruning must keep\n  // `_pp_version` even when the collection metadata's parent alias is only `pp`.\n  const correlationAliases = joinDependencies(root);\n  const correlation: RawCondition = {\n    kind: \"raw\",\n    aliases: [root.alias, ...correlationAliases],\n    condition: `${root.col1} = ${root.col2}`,\n    bindings: [],\n    pruneable: false,\n  };\n  // I.e. a pure `b.id IS NULL` anti-join becomes `NOT EXISTS (SELECT 1 FROM books b WHERE a.id = b.author_id)`.\n  const conditions = hasOnlyAntiJoin ? [correlation] : [correlation, ...moved];\n  const subquery: ParsedFindQuery = {\n    selects: [\"1\"],\n    tables: query.tables\n      .filter((t) => (hasOnlyAntiJoin ? t.alias === root.alias : collectionRoot.aliases.has(t.alias)))\n      .map((t) => {\n        // I.e. the collection root becomes the subquery's FROM table; children remain joins off that root.\n        if (t.alias === root.alias) return { join: \"primary\", alias: t.alias, table: t.table } satisfies PrimaryTable;\n        // I.e. preserve nullable paths like `LEFT JOIN p ... LEFT JOIN sp ... WHERE p.id = 1 OR sp.id = 1`; forcing\n        // children to INNER JOIN would require every optional branch to exist before the OR can match any branch.\n        if (t.join === \"outer\") return { ...t, distinct: false };\n        return t;\n      }),\n    condition: { kind: \"exp\", op: \"and\", conditions },\n    orderBys: [],\n  };\n  // I.e. nested `books.reviews` first creates an EXISTS for books, then this recursive call creates EXISTS for reviews.\n  rewriteCollectionJoins(subquery);\n  return {\n    kind: \"exists\",\n    negate: hasOnlyAntiJoin,\n    subquery,\n    outerAliases: correlationAliases,\n  };\n}\n\n/** Appends conditions to the top-level expression, creating an AND wrapper when needed. */\nfunction addConditions(query: ParsedFindQuery, conditions: ParsedExpressionCondition[]): void {\n  query.condition ??= { kind: \"exp\", op: \"and\", conditions: [] };\n  query.condition.conditions.push(...conditions);\n}\n\n/** Returns top-level collection roots with their full join subtrees. */\nfunction getCollectionRoots(query: ParsedFindQuery): CollectionRoot[] {\n  return getTopLevelCollectionRoots(query).map((table) => {\n    const aliases = collectJoinSubtreeAliases(query, table.alias);\n    return {\n      table,\n      aliases,\n      joinTables: query.tables.filter((t): t is JoinTable => isJoinTable(t) && aliases.has(t.alias)),\n    };\n  });\n}\n\n/** Returns top-level collection roots, i.e. `books b` but not nested `book_reviews br`. */\nfunction getTopLevelCollectionRoots(query: ParsedFindQuery): JoinTable[] {\n  // I.e. if `books b` is nested under another collection root, the parent pass should absorb it; don't rewrite it here.\n  const joinTables = query.tables.filter(isJoinTable);\n  const collectionAliases = new Set(joinTables.flatMap((t) => (t.collection ? [t.alias] : [])));\n  return joinTables.filter(\n    (t) => t.collection?.rootAlias === t.alias && !collectionAliases.has(t.collection.parentAlias),\n  );\n}\n\n/** Returns true if a remaining real condition prevents this subtree from becoming EXISTS, i.e. a cross-scope OR. */\nfunction conditionBlocksExistsRewrite(condition: ParsedExpressionCondition | undefined, aliases: Set<string>): boolean {\n  if (!condition || !isRealCondition(condition)) return false;\n  if (condition.kind === \"exp\" && condition.op === \"and\") {\n    return condition.conditions.some((c) => conditionBlocksExistsRewrite(c, aliases));\n  }\n  return conditionReferencesAnyAlias(condition, aliases);\n}\n\n/** Collects a collection root and all joins that depend on it, i.e. `b -> br -> c`. */\nfunction collectJoinSubtreeAliases(query: ParsedFindQuery, rootAlias: string): Set<string> {\n  const aliases = new Set([rootAlias]);\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const table of query.tables) {\n      if (!isJoinTable(table)) continue;\n      // I.e. `book_reviews br ON b.id = br.book_id` depends on `b`, so `br` belongs in the `b` subtree.\n      if (!aliases.has(table.alias) && joinReferencesAnyAlias(table, aliases)) {\n        aliases.add(table.alias);\n        changed = true;\n      }\n    }\n  }\n  return aliases;\n}\n\n/**\n * Removes AND-safe conditions whose aliases all live inside one collection subtree.\n *\n * I.e. in `a.age = 1 AND b.title = 'x'`, only `b.title = 'x'` moves. In `b.title = 'x' OR br.rating = 5`,\n * the whole OR moves only if every alias is inside the same subtree.\n */\nfunction removeLocallyScopedConditions(exp: ParsedExpressionFilter, aliases: Set<string>): ParsedExpressionCondition[] {\n  if (exp.op === \"or\") {\n    // I.e. OR cannot be split across scopes; either move the whole OR into the EXISTS, or leave it outside.\n    if (!conditionReferencesOnlyAliases(exp, aliases)) return [];\n    const moved = { ...exp, conditions: [...exp.conditions] } satisfies ParsedExpressionFilter;\n    exp.conditions = [];\n    return [moved];\n  }\n  const moved: ParsedExpressionCondition[] = [];\n  for (let i = exp.conditions.length - 1; i >= 0; i--) {\n    const condition = exp.conditions[i];\n    if (condition.kind === \"exp\" && condition.op === \"and\") {\n      // I.e. flatten nested AND movement so `a AND (b AND br)` can still move `b` and `br` into the EXISTS.\n      moved.push(...removeLocallyScopedConditions(condition, aliases));\n      if (condition.conditions.length === 0) exp.conditions.splice(i, 1);\n    } else if (conditionReferencesOnlyAliases(condition, aliases)) {\n      // I.e. move `b.title = 'x'` out of the parent AND and into the collection EXISTS.\n      moved.unshift(condition);\n      exp.conditions.splice(i, 1);\n    }\n  }\n  return moved;\n}\n\n/** Returns true when a condition references at least one alias and all aliases are in `aliases`, i.e. only `b`/`br`. */\nfunction conditionReferencesOnlyAliases(condition: ParsedExpressionCondition, aliases: Set<string>): boolean {\n  const found = conditionAliases(condition);\n  return found.size > 0 && [...found].every((alias) => aliases.has(alias));\n}\n\n/** Returns true when `aliases` are referenced by a real condition other than the targeted OR expression. */\nfunction conditionReferencesAliasesOutside(\n  condition: ParsedExpressionCondition | undefined,\n  target: ParsedExpressionCondition,\n  aliases: Set<string>,\n): boolean {\n  if (!condition || condition === target || !isRealCondition(condition)) return false;\n  if (condition.kind === \"exp\") {\n    return condition.conditions.some((child) => conditionReferencesAliasesOutside(child, target, aliases));\n  }\n  return conditionReferencesAnyAlias(condition, aliases);\n}\n\n/** Returns true when selected/ordered aliases would force these joins to remain in the outer query. */\nfunction queryReferencesAliasesOutsideConditions(\n  query: ParsedFindQuery,\n  aliases: Set<string>,\n  keepAliases: string[],\n): boolean {\n  const requiredAliases = queryRequiredAliasesOutsideConditions(query, keepAliases);\n  // I.e. if `array_agg(br.rating)` requires `br`, then `b` is required too because `br` joins through `b`; don't\n  // move `b` under EXISTS just because the select references only its child alias directly.\n  return hasAnyAlias(requiredAliases, aliases);\n}\n\n/**\n * Returns aliases needed by SELECT/GROUP/ORDER plus their join dependencies.\n *\n * I.e. `array_agg(br.rating)` requires `br`, and then `br` requires `b` because it joins through `b`.\n */\nfunction queryRequiredAliasesOutsideConditions(query: ParsedFindQuery, keepAliases: string[]): Set<string> {\n  const required = new Set<string>();\n  for (const alias of keepAliases) required.add(alias);\n  for (const orderBy of query.orderBys) required.add(orderBy.alias);\n  for (const groupBy of query.groupBys ?? []) {\n    if (\"expression\" in groupBy) {\n      addSelectAliases(query, required, groupBy.expression);\n    } else {\n      required.add(groupBy.alias);\n    }\n  }\n  for (const select of query.selects) {\n    if (typeof select === \"string\") {\n      addSelectAliases(query, required, select);\n    } else if (\"aliases\" in select) {\n      for (const alias of select.aliases) required.add(alias);\n      addSelectAliases(query, required, select.sql);\n    }\n  }\n\n  const todo = [...required];\n  while (todo.length > 0) {\n    const alias = todo.pop()!;\n    const table = query.tables.find((t) => t.alias === alias);\n    if (!table || !isJoinTable(table)) continue;\n    for (const dependency of joinDependencies(table)) {\n      if (!required.has(dependency)) {\n        required.add(dependency);\n        todo.push(dependency);\n      }\n    }\n  }\n  return required;\n}\n\n/** Adds aliases referenced by raw select SQL, i.e. `array_agg(br.rating)` requires `br`. */\nfunction addSelectAliases(query: ParsedFindQuery, required: Set<string>, select: string): void {\n  for (const table of query.tables) {\n    if (selectReferencesAlias(select, table.alias)) required.add(table.alias);\n  }\n}\n\n/** Returns the aliases needed to evaluate a join's ON clause, excluding the joined alias itself. */\nfunction joinDependencies(table: JoinTable): string[] {\n  return [parseAlias(table.col1), parseAlias(table.col2)].filter((alias) => alias !== table.alias);\n}\n\n/** Returns true when a condition references this subtree and another scope, i.e. `b.title = 'x' OR c.text = 'x'`. */\nfunction conditionHasCrossScopeReference(\n  condition: ParsedExpressionCondition | undefined,\n  aliases: Set<string>,\n): boolean {\n  if (!condition || !isRealCondition(condition)) return false;\n  if (condition.kind === \"exp\" && condition.op === \"and\") {\n    return condition.conditions.some((child) => conditionHasCrossScopeReference(child, aliases));\n  }\n  const found = conditionAliases(condition);\n  return hasAnyAlias(found, aliases) && ![...found].every((alias) => aliases.has(alias));\n}\n\n/** Returns true when a condition references any alias in `aliases`, i.e. `b` in `b.title = c.text`. */\nfunction conditionReferencesAnyAlias(condition: ParsedExpressionCondition, aliases: Set<string>): boolean {\n  return hasAnyAlias(conditionAliases(condition), aliases);\n}\n\n/** Returns true when `table` is an ordinary SQL join. */\nfunction isJoinTable(table: ParsedFindQuery[\"tables\"][number]): table is JoinTable {\n  return table.join === \"inner\" || table.join === \"outer\";\n}\n\n/** Returns true when a join's ON clause references any alias in `aliases`. */\nfunction joinReferencesAnyAlias(table: JoinTable, aliases: Set<string>): boolean {\n  return joinDependencies(table).some((alias) => aliases.has(alias));\n}\n\n/** Returns true when two alias sets overlap. */\nfunction hasAnyAlias(found: Set<string>, aliases: Set<string>): boolean {\n  return [...found].some((alias) => aliases.has(alias));\n}\n\n/** Returns true for collection anti-joins, i.e. `b.id IS NULL` or m2m target `t.id IS NULL` for root `att`. */\nfunction isCollectionAntiJoin(condition: ParsedExpressionCondition, root: CollectionRoot): boolean {\n  return collectionAntiJoinAliases(root).some((alias) => isAliasIdNull(condition, alias));\n}\n\n/** Returns aliases whose `id IS NULL` means the collection root has no matching row. */\nfunction collectionAntiJoinAliases(root: CollectionRoot): string[] {\n  return [...root.aliases].filter((alias) => {\n    if (alias === root.table.alias) return true;\n    const table = rootTable(root, alias);\n    // I.e. for m2m `authors -> authors_to_tags att -> tags t`, `t.id IS NULL` means no tag membership.\n    return table?.collection?.rootAlias === root.table.alias;\n  });\n}\n\n/** Returns a join table from a collection subtree by alias. */\nfunction rootTable(root: CollectionRoot, alias: string): JoinTable | undefined {\n  return root.joinTables.find((table) => table.alias === alias);\n}\n\n/** Returns true for `alias.id IS NULL`, i.e. the parse shape for `{ books: { id: null } }`. */\nfunction isAliasIdNull(condition: ParsedExpressionCondition, alias: string): boolean {\n  return (\n    condition.kind === \"column\" &&\n    condition.alias === alias &&\n    condition.column === \"id\" &&\n    condition.cond.kind === \"is-null\"\n  );\n}\n\n/** Returns true when a condition tree contains a collection anti-join branch inside an OR. */\nfunction conditionContainsCollectionAntiJoin(condition: ParsedExpressionCondition, root: CollectionRoot): boolean {\n  if (isCollectionAntiJoin(condition, root)) return true;\n  if (condition.kind === \"exp\") return condition.conditions.some((c) => conditionContainsCollectionAntiJoin(c, root));\n  return false;\n}\n\n/** Removes empty expression wrappers left behind by condition movement, i.e. `AND []` after all children moved. */\nfunction removeEmptyExpressions(exp: ParsedExpressionFilter | undefined): void {\n  if (!exp) return;\n  for (let i = exp.conditions.length - 1; i >= 0; i--) {\n    const condition = exp.conditions[i];\n    if (condition.kind === \"exp\") {\n      removeEmptyExpressions(condition);\n      if (condition.conditions.length === 0) exp.conditions.splice(i, 1);\n    }\n  }\n}\n\n/** Returns true if a condition must be preserved to maintain query semantics, i.e. user filters vs soft-delete filters. */\nfunction isRealCondition(condition: ParsedExpressionCondition): boolean {\n  if (condition.kind === \"column\" || condition.kind === \"raw\") {\n    return !condition.pruneable;\n  } else if (condition.kind === \"exists\") {\n    return true;\n  } else if (condition.kind === \"exp\") {\n    return condition.conditions.some(isRealCondition);\n  } else {\n    assertNever(condition);\n  }\n}\n\n/** Returns all aliases referenced by a condition, i.e. `b` and `a` in an OR. */\nfunction conditionAliases(condition: ParsedExpressionCondition): Set<string> {\n  const aliases = new Set<string>();\n  collectAllAliases(condition, aliases);\n  return aliases;\n}\n\n/** Collects all aliases referenced by a condition, including inside nested expressions, i.e. `b` and `a` in an OR. */\nfunction collectAllAliases(cond: ParsedExpressionCondition, out: Set<string>): void {\n  if (cond.kind === \"column\") {\n    out.add(cond.alias);\n  } else if (cond.kind === \"raw\") {\n    for (const a of cond.aliases) out.add(a);\n  } else if (cond.kind === \"exp\") {\n    for (const c of cond.conditions) collectAllAliases(c, out);\n  } else if (cond.kind === \"exists\") {\n    // I.e. an EXISTS subquery is already a scoped unit; outer movement decisions should not inspect its internals.\n  } else {\n    assertNever(cond);\n  }\n}\n"],"mappings":"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"}

package/build/queries/find/QueryParser.d.cts

@@ -0,0 +1,192 @@
+import { ParsedExpressionFilter } from "../parsedConditions.cjs";
+import { ExpressionFilter, OrderBy } from "./EntityFilter.cjs";
+import { EntityMetadata, Field } from "../../EntityMetadata.cjs";
+//#region src/queries/find/QueryParser.d.ts
+interface PrimaryTable {
+  join: "primary";
+  alias: string;
+  table: string;
+}
+interface JoinTable {
+  join: "inner" | "outer";
+  alias: string;
+  table: string;
+  col1: string;
+  col2: string;
+  distinct?: boolean;
+  /**
+   * Metadata used by `optimizeCollectionJoins` to rewrite collection joins into EXISTS.
+   *
+   * I.e. for `Author.books.reviews`:
+   * ```sql
+   * authors a
+   * LEFT JOIN books b ON a.id = b.author_id
+   * LEFT JOIN book_reviews br ON b.id = br.book_id
+   * ```
+   * `books b` has `parentAlias: "a"` and `rootAlias: "b"`, while `book_reviews br` has
+   * `parentAlias: "b"` and `rootAlias: "br"`.
+   *
+   * I.e. for `Author.tags`, the m2m join table is the collection root:
+   * ```sql
+   * authors a
+   * LEFT JOIN authors_to_tags att ON a.id = att.author_id
+   * LEFT JOIN tags t ON att.tag_id = t.id
+   * ```
+   * `authors_to_tags att` has `alias: "att"` and `rootAlias: "att"`, while `tags t` has `alias: "t"`
+   * but still has `rootAlias: "att"` because it belongs to the m2m subtree rooted at the join table.
+   */
+  collection?: {
+    /** The collection relation type, i.e. `o2m` for `Author.books`, or `m2m` for `Author.tags`. */
+    kind: "o2m" | "m2m";
+    /** The alias that owns this collection path, i.e. `a` for `Author.books`, or `att` for `Author.tags -> tags`. */
+    parentAlias: string;
+    /** The top-level alias in this collection subtree, i.e. `b` for `Author.books.reviews`, or `att` for `Author.tags`. */
+    rootAlias: string;
+  };
+}
+/**
+ * Creates a `CROSS JOIN`, currently used for our `em.find` batching.
+ *
+ * I.e. queries like:
+ *
+ * ```sql
+ * WITH _find (tag, arg1, arg2) AS (VALUES
+ *   (0::int, 'a'::varchar, 'a'::varchar),
+ *   (1, 'b', 'b'),
+ *   (2, 'c', 'c')
+ * )
+ * SELECT a.*, array_agg(_find.tag) AS _tags
+ * FROM authors a
+ * CROSS JOIN _find AS _find
+ * WHERE a.first_name = _find.arg0 OR a.last_name = _find.arg1
+ * GROUP BY a.id
+ * ```
+ */
+interface CrossJoinTable {
+  join: "cross";
+  /** The new alias for the joined table. */
+  alias: string;
+  /** The table name to join into the query. */
+  table: string;
+}
+/**
+ * Adds `WITH` CTE clauses to the query.
+ *
+ * I.e. queries like:
+ *
+ * ```sql
+ * WITH _find (tag, arg0, arg1) AS (
+ *   VALUES ($1::int, $2::character varying, $3::character varying), ($4, $5, $6)
+ * )
+ * ```
+ */
+interface ParsedCteClause {
+  /** The new alias for the CTE, i.e. `_find` in the above query. */
+  alias: string;
+  /** The columns, i.e. `tag, arg0, arg1` in the above query. */
+  columns?: {
+    columnName: string;
+    dbType: string;
+  }[];
+  /** The subquery for the AS of the CTE clause. */
+  query: {
+    kind: "raw";
+    sql: string;
+    bindings: readonly any[];
+  } | {
+    kind: "ast";
+    query: ParsedFindQuery;
+  };
+  /** Whether to include a `RECURSIVE` keyword after the `WITH`. */
+  recursive?: boolean;
+}
+/**
+ * Creates `LATERAL JOIN`s, currently used by `findCount` and JSON preloading.
+ */
+interface LateralJoinTable {
+  join: "lateral";
+  alias: string;
+  /** Used for join dependency tracking. */
+  fromAlias: string;
+  /** Used more for bookkeeping/consistency with other join tables than the query itself. */
+  table: string;
+  /** The subquery that will look for/roll-up N children. */
+  query: ParsedFindQuery;
+  /** Optional settings for the subquery, i.e. per-parent pagination. */
+  settings?: {
+    limit?: number;
+    offset?: number;
+  };
+}
+type ParsedTable = PrimaryTable | JoinTable | CrossJoinTable | LateralJoinTable;
+interface ParsedOrderBy {
+  alias: string;
+  column: string;
+  order: OrderBy;
+}
+type ParsedGroupBy = {
+  alias: string;
+  column: string;
+} | {
+  expression: string;
+};
+type ParsedSelect = string | ParsedSelectWithBindings;
+type ParsedSelectWithBindings = {
+  sql: string;
+  bindings: any[];
+  aliases: string[];
+};
+/** The result of parsing an `em.find` filter. */
+interface ParsedFindQuery {
+  selects: ParsedSelect[];
+  /** The primary table plus any joins. */
+  tables: ParsedTable[];
+  /** The query's conditions. */
+  condition?: ParsedExpressionFilter;
+  /** Extremely optional group bys; we generally don't support adhoc/aggregate queries, but the auto-batching infra uses these. */
+  groupBys?: ParsedGroupBy[];
+  /** Any optional orders to add before the default 'order by id'. */
+  orderBys: ParsedOrderBy[];
+  /** Optional CTE to prefix to the query, i.e. for recursive relations. */
+  ctes?: ParsedCteClause[];
+}
+/**
+ * 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.
+ */
+declare function parseFindQuery(meta: EntityMetadata, filter: any, opts?: {
+  conditions?: ExpressionFilter;
+  orderBy?: any;
+  pruneJoins?: boolean;
+  keepAliases?: string[];
+  softDeletes?: "include" | "exclude";
+  allowMultipleLeftJoins?: boolean;
+  optimizeJoinsToExists?: boolean;
+}): ParsedFindQuery;
+/**
+ * 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).
+ */
+declare function maybeAddIdNotNulls(query: ParsedFindQuery): void;
+/** Returns the `a` from `"a".*`. */
+declare function parseAlias(alias: string): string;
+/** Finds a filter field by fieldName or generated fieldIdName. */
+declare function findFilterField(meta: EntityMetadata, key: string): (Field & {
+  aliasSuffix: string;
+}) | undefined;
+/** Adds any user-configured default order, plus an "always order by id" for determinism. */
+declare function maybeAddOrderBy(query: ParsedFindQuery, meta: EntityMetadata, alias: string): void;
+declare function addTablePerClassJoinsAndClassTag(query: ParsedFindQuery, meta: EntityMetadata, alias: string, isPrimary: boolean): void;
+declare function getTables(query: ParsedFindQuery): [PrimaryTable, JoinTable[], LateralJoinTable[], CrossJoinTable[]];
+//#endregion
+export { CrossJoinTable, JoinTable, LateralJoinTable, ParsedCteClause, ParsedFindQuery, ParsedGroupBy, ParsedOrderBy, ParsedSelect, ParsedTable, PrimaryTable, addTablePerClassJoinsAndClassTag, findFilterField, getTables, maybeAddIdNotNulls, maybeAddOrderBy, parseAlias, parseFindQuery };
+//# sourceMappingURL=QueryParser.d.cts.map

package/build/queries/find/QueryParser.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryParser.d.cts","names":[],"sources":["../../../src/queries/find/QueryParser.ts"],"mappings":";;;;UA6BiB;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;EAsBA;;IAEE;;IAEA;;IAEA;;;;;;;;;;;;;;;;;;;;;UAsBa;EACf;;EAEA;;EAEA;;;;;;;;;;;;;UAce;;EAEf;;EAEA;IAAY;IAAoB;;;EAEhC;IAAS;IAAa;IAAa;;IAA+B;IAAa,OAAO;;;EAEtF;;;;;UAMe;EACf;EACA;;EAEA;;EAEA;;EAEA,OAAO;;EAEP;IAAa;IAAgB;;;KAGnB,cAAc,eAAe,YAAY,iBAAiB;UAErD;EACf;EACA;EACA,OAAO;;KAGG;EAAkB;EAAe;;EAAqB;;KAEtD,wBAAwB;KAC/B;EAA6B;EAAa;EAAiB;;;UAG/C;EACf,SAAS;;EAET,QAAQ;;EAER,YAAY;;EAEZ,WAAW;;EAEX,UAAU;;EAEV,OAAO;;;;;;;;iBASO,eACd,MAAM,gBACN,aACA;EACE,aAAa;EACb;EACA;EACA;EACA;EACA;EACA;IAED;;;;;;;;;;;;iBAqhBa,mBAAmB,OAAO;;iBAgC1B,WAAW;;iBAKX,gBAAgB,MAAM,gBAAgB,eAAe;EAAU;;;iBAU/D,gBAAgB,OAAO,iBAAiB,MAAM,gBAAgB;iBAiB9D,iCACd,OAAO,iBACP,MAAM,gBACN,eACA;iBA8Fc,UAAU,OAAO,mBAAmB,cAAc,aAAa,oBAAoB"}