joist-core 2.3.0-next.61 → 2.3.0-next.63

package/build/Aliases.cjs

@@ -1,374 +1,219 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./typeMap.cjs");
-const require_keywords = require("./keywords.cjs");
+require("./EntityFilter.cjs");
 const require_keys = require("./keys.cjs");
+const require_DeferredAlias = require("./DeferredAlias.cjs");
 require("./serde.cjs");
 const require_EntityMetadata = require("./EntityMetadata.cjs");
 const require_utils = require("./utils.cjs");
-const require_Expr = require("./Expr.cjs");
-require("./index.cjs");
 require("./EntityManager.cjs");
 require("./Entity.cjs");
 const require_configure = require("./configure.cjs");
 const require_QueryParser = require("./QueryParser.cjs");
 let joist_utils = require("joist-utils");
 //#region src/Aliases.ts
-function alias(cstr, _name) {
+/** Creates an alias for complex domain filtering in `em.find`. */
+function alias(cstr) {
 	return newAliasProxy(cstr);
 }
 /** Creates multiple aliases for complex filtering. */
-function aliases(...type) {
-	return type.map((t) => newAliasProxy(t));
+function aliases(...types) {
+	return types.map((t) => newAliasProxy(t));
 }
 const aliasMgmt = Symbol("aliasMgmt");
+/** Returns the runtime identity bound by the find parser. */
 function getAliasMgmt(alias) {
 	return alias[aliasMgmt];
 }
-/** Returns the metadata for the entity that `alias` is bound to. */
+/** Returns the original metadata, preserving STI subtype identity. */
 function getAliasMetadata(alias) {
 	return alias[aliasMgmt].meta;
 }
+/** Creates domain predicates lazily from entity field metadata. */
 function newAliasProxy(cstr) {
 	const meta = require_EntityMetadata.getMetadata(cstr);
 	const mgmt = {
 		tableName: meta.tableName,
 		meta
 	};
-	const proxy = new Proxy(cstr, {
-		/** Create a column alias, or a relation join factory, for the given field. */
+	return new Proxy(cstr, {
 		get(_, key) {
 			if (key === aliasMgmt) return mgmt;
-			const field = meta.allFields[key] ?? require_utils.fail(`No field ${String(key)} on ${cstr.name}`);
-			switch (field.kind) {
-				case "primaryKey":
-				case "primitive":
-				case "enum": return new PrimitiveAliasImpl(meta, field, field.serde.columns[0], mgmt);
-				case "m2o": return new EntityAliasImpl(meta, field, field.serde.columns[0], mgmt);
-				case "poly": return new PolyReferenceAlias(meta, mgmt, field);
-				case "o2m":
-				case "o2o":
-				case "lo2m": return new OneToManyAliasImpl(proxy, field);
-				case "m2m": return new ManyToManyAliasImpl(proxy, field);
-				default: throw new Error(`Unsupported alias field kind ${field.kind}`);
-			}
+			if (typeof key !== "string") return void 0;
+			const field = meta.allFields[key] ?? require_utils.fail(`No field ${key} on ${cstr.name}`);
+			if (field.kind === "poly") return new PolyReferenceAlias(meta, mgmt, field);
+			if ([
+				"primaryKey",
+				"primitive",
+				"enum",
+				"m2o"
+			].includes(field.kind)) return new AliasColumnImpl(meta, field, field.serde.columns[0], mgmt);
+			return require_utils.fail(`Unsupported alias field kind ${field.kind}`);
 		},
 		has(_, key) {
 			return key === aliasMgmt || key in meta.allFields;
 		}
 	});
-	return proxy;
 }
-function isAlias(obj) {
-	return obj && typeof obj === "function" && obj[aliasMgmt] !== void 0;
+/** Recognizes only domain aliases, not physical tables. */
+function isAlias(value) {
+	return typeof value === "function" && aliasMgmt in value;
 }
-/**
-* A single column of an alias.
-*
-* For `em.find`, its methods create `ColumnCondition`s that resolve their alias against each parse's
-* join-literal bindings.
-*
-* For `em.query`, the column also implements `Expr`: it renders as `alias."column"`, decodes result
-* values through the field's serde, and inherits aggregate methods from `BaseExpr`.
-*/
-var AbstractAliasColumn = class AbstractAliasColumn extends require_Expr.BaseExpr {
+/** Builds field conditions without implementing the SQL expression protocol. */
+var AliasColumnImpl = class AliasColumnImpl {
 	meta;
 	field;
 	column;
 	mgmt;
 	constructor(meta, field, column, mgmt) {
-		super();
 		this.meta = meta;
 		this.field = field;
 		this.column = column;
 		this.mgmt = mgmt;
 	}
-	toSql(ctx) {
-		const alias = ctx.aliasFor(this.mgmt);
-		const ctiAlias = getMaybeCtiAlias(this.meta, this.field, this.meta, alias);
-		return {
-			sql: require_keywords.kqDot(ctiAlias, this.column.columnName),
-			bindings: [],
-			refs: [alias]
-		};
-	}
-	/** Decodes a result-set value the same way `hydrate` would, i.e. an int into a tagged id. */
-	decode(value) {
-		if (value === null || value === void 0) return value;
-		return this.column.mapFromDb(value);
-	}
-	encode(value) {
-		return this.column.mapToDb(value);
-	}
-	addCondition(value) {
-		const cond = {
-			kind: "column",
-			alias: "unset",
-			column: this.column.columnName,
-			dbType: this.column.dbType,
-			cond: require_QueryParser.mapToDb(this.column, value)
-		};
-		return require_Expr.withDeferredAlias(cond, (resolve) => {
-			const r = resolve(this.mgmt);
-			cond.alias = getMaybeCtiAlias(this.meta, this.field, r.meta, r.alias);
-		});
-	}
-	addRawCondition(exp, bindings) {
-		const cond = {
-			kind: "raw",
-			aliases: [],
-			condition: "unset",
-			pruneable: false,
-			bindings
-		};
-		return require_Expr.withDeferredAlias(cond, (resolve) => {
-			const r = resolve(this.mgmt);
-			const alias = getMaybeCtiAlias(this.meta, this.field, r.meta, r.alias);
-			cond.aliases = [alias];
-			cond.condition = `${alias}.${this.column.columnName} ${exp}`;
-		});
-	}
-	/**
-	* Compares this column to another expression.
-	*
-	* Another alias column becomes a `DeferredAliasCondition`, which both parsers can resolve, so it also
-	* works inside `em.find`'s complex conditions; every other expression (an aggregate, a subquery column,
-	* a `sql` template) only exists in `em.query`, so it takes the `ExprContext`-deferred path, which only
-	* the `em.query` parser resolves.
-	*/
-	compareToExpr(op, value) {
-		if (value instanceof AbstractAliasColumn) return newCrossColumnCondition(this.meta, this.field, this.mgmt, this.column.columnName, value, op);
-		return this.compare(op, value);
-	}
-};
-var PrimitiveAliasImpl = class extends AbstractAliasColumn {
 	eq(value) {
-		if (value === void 0) return require_Expr.skipCondition;
-		if (value === null) return this.addCondition({ kind: "is-null" });
-		if (require_Expr.isExpr(value)) return this.compareToExpr("=", value);
-		return this.addCondition({
-			kind: "eq",
-			value
-		});
+		return this.compare("eq", "=", value);
 	}
 	ne(value) {
-		if (value === void 0) return require_Expr.skipCondition;
-		if (value === null) return this.addCondition({ kind: "not-null" });
-		if (require_Expr.isExpr(value)) return this.compareToExpr("!=", value);
-		return this.addCondition({
-			kind: "ne",
-			value
-		});
+		return this.compare("ne", "!=", value);
 	}
 	gt(value) {
-		if (value === void 0) return require_Expr.skipCondition;
-		if (require_Expr.isExpr(value)) return this.compareToExpr(">", value);
-		return this.addCondition({
-			kind: "gt",
-			value
-		});
+		return this.compare("gt", ">", value);
 	}
 	gte(value) {
-		if (value === void 0) return require_Expr.skipCondition;
-		if (require_Expr.isExpr(value)) return this.compareToExpr(">=", value);
-		return this.addCondition({
-			kind: "gte",
-			value
-		});
+		return this.compare("gte", ">=", value);
 	}
 	lt(value) {
-		if (value === void 0) return require_Expr.skipCondition;
-		if (require_Expr.isExpr(value)) return this.compareToExpr("<", value);
-		return this.addCondition({
-			kind: "lt",
-			value
-		});
+		return this.compare("lt", "<", value);
 	}
 	lte(value) {
-		if (value === void 0) return require_Expr.skipCondition;
-		if (require_Expr.isExpr(value)) return this.compareToExpr("<=", value);
-		return this.addCondition({
-			kind: "lte",
-			value
-		});
+		return this.compare("lte", "<=", value);
 	}
-	between(v1, v2) {
-		if (v1 === void 0 || v2 === void 0) return require_Expr.skipCondition;
-		return this.addCondition({
-			kind: "between",
-			value: [v1, v2]
-		});
+	contains(value) {
+		return this.compare("contains", "@>", value);
 	}
-	like(value) {
-		if (value === void 0) return require_Expr.skipCondition;
+	ncontains(value) {
+		if (value instanceof AliasColumnImpl) return crossColumnCondition(this, value, "@>", true);
 		return this.addCondition({
-			kind: "like",
+			kind: "ncontains",
 			value
 		});
 	}
-	ilike(value) {
-		if (value === void 0) return require_Expr.skipCondition;
-		return this.addCondition({
-			kind: "ilike",
-			value
-		});
+	overlaps(value) {
+		return this.compare("overlaps", "&&", value);
 	}
-	search(value) {
-		if (!value) return require_Expr.skipCondition;
+	noverlaps(value) {
+		if (value instanceof AliasColumnImpl) return crossColumnCondition(this, value, "&&", true);
 		return this.addCondition({
-			kind: "ilike",
-			value: require_QueryParser.makeLike(value)
+			kind: "noverlaps",
+			value
 		});
 	}
 	in(values) {
-		if (values === void 0) return require_Expr.skipCondition;
-		if (require_Expr.isExpr(values)) return this.inList("IN", values);
+		if (values === void 0) return require_DeferredAlias.skipCondition;
+		if (values === null) return require_utils.fail("Unsupported");
 		if (values.includes(null)) return { or: [this.addCondition({ kind: "is-null" }), this.addCondition({
 			kind: "in",
 			value: values.filter((v) => v !== null)
 		})] };
-		else return this.addCondition({
+		return this.addCondition({
 			kind: "in",
-			value: values
+			value: [...values]
 		});
 	}
 	nin(values) {
-		if (values === void 0) return require_Expr.skipCondition;
-		if (require_Expr.isExpr(values)) return this.inList("NOT IN", values);
+		if (values === void 0) return require_DeferredAlias.skipCondition;
+		if (values === null) return require_utils.fail("Unsupported");
 		return this.addCondition({
 			kind: "nin",
 			value: values.filter((v) => v !== null)
 		});
 	}
-	contains(v1) {
-		if (v1 === void 0) return require_Expr.skipCondition;
+	between(v1, v2) {
+		if (v1 === void 0 || v2 === void 0) return require_DeferredAlias.skipCondition;
 		return this.addCondition({
-			kind: "contains",
-			value: v1
+			kind: "between",
+			value: [v1, v2]
 		});
 	}
-	ncontains(v1) {
-		if (v1 === void 0) return require_Expr.skipCondition;
+	like(value) {
 		return this.addCondition({
-			kind: "ncontains",
-			value: v1
+			kind: "like",
+			value
 		});
 	}
-	overlaps(v1) {
-		if (v1 === void 0) return require_Expr.skipCondition;
+	ilike(value) {
 		return this.addCondition({
-			kind: "overlaps",
-			value: v1
+			kind: "ilike",
+			value
 		});
 	}
-	noverlaps(v1) {
-		if (v1 === void 0) return require_Expr.skipCondition;
-		return this.addCondition({
-			kind: "noverlaps",
-			value: v1
+	search(value) {
+		return !value ? require_DeferredAlias.skipCondition : this.addCondition({
+			kind: "ilike",
+			value: require_QueryParser.makeLike(value)
 		});
 	}
-	pathExists(jsonPath) {
-		if (jsonPath === void 0) return require_Expr.skipCondition;
+	pathExists(value) {
 		return this.addCondition({
 			kind: "jsonPathExists",
-			value: jsonPath
-		});
-	}
-	pathIsTrue(jsonPath) {
-		if (jsonPath === void 0) return require_Expr.skipCondition;
-		return this.addCondition({
-			kind: "jsonPathPredicate",
-			value: jsonPath
-		});
-	}
-	raw(exp, bindings) {
-		if (bindings === void 0) return require_Expr.skipCondition;
-		return this.addRawCondition(exp, bindings);
-	}
-};
-var EntityAliasImpl = class extends AbstractAliasColumn {
-	eq(value) {
-		if (value === void 0) return require_Expr.skipCondition;
-		if (value === null) return this.addCondition({ kind: "is-null" });
-		if (require_Expr.isExpr(value)) return this.compareToExpr("=", value);
-		return this.addCondition({
-			kind: "eq",
 			value
 		});
 	}
-	ne(value) {
-		if (value === void 0) return require_Expr.skipCondition;
-		if (value === null) return this.addCondition({ kind: "not-null" });
-		if (require_Expr.isExpr(value)) return this.compareToExpr("!=", value);
+	pathIsTrue(value) {
 		return this.addCondition({
-			kind: "ne",
+			kind: "jsonPathPredicate",
 			value
 		});
 	}
-	in(values) {
-		if (values === void 0) return require_Expr.skipCondition;
-		else if (values === null) throw new Error("Unsupported");
-		else if (require_Expr.isExpr(values)) return this.inList("IN", values);
-		else if (values.includes(null)) return { or: [this.addCondition({ kind: "is-null" }), this.addCondition({
-			kind: "in",
-			value: values.filter((v) => v !== null)
-		})] };
-		else return this.addCondition({
-			kind: "in",
-			value: values
-		});
-	}
-	nin(values) {
-		if (values === void 0) return require_Expr.skipCondition;
-		else if (values === null) throw new Error("Unsupported");
-		else if (require_Expr.isExpr(values)) return this.inList("NOT IN", values);
-		else return this.addCondition({
-			kind: "nin",
-			value: values.filter((v) => v !== null)
-		});
-	}
-	gt(value) {
-		return this.compareId(">", "gt", value);
-	}
-	gte(value) {
-		return this.compareId(">=", "gte", value);
-	}
-	lt(value) {
-		return this.compareId("<", "lt", value);
-	}
-	lte(value) {
-		return this.compareId("<=", "lte", value);
-	}
 	raw(exp, bindings) {
-		if (bindings === void 0) return require_Expr.skipCondition;
-		return this.addRawCondition(exp, bindings);
-	}
-	/** Joins `other` via this FK, INNER for a required reference and LEFT for a nullable one. */
-	as(other) {
-		return this.joinEntry(this.field.required ? "inner" : "left", other);
-	}
-	inner(other) {
-		return this.joinEntry("inner", other);
-	}
-	left(other) {
-		return this.joinEntry("left", other);
+		if (bindings === void 0) return require_DeferredAlias.skipCondition;
+		return require_DeferredAlias.withDeferredAlias({
+			kind: "raw",
+			aliases: [],
+			condition: "unset",
+			pruneable: false,
+			bindings
+		}, (resolve, copy) => {
+			const r = resolve(this.mgmt);
+			const alias = getMaybeCtiAlias(this.meta, this.field, r.meta, r.alias);
+			copy.aliases = [alias];
+			copy.condition = `${alias}.${this.column.columnName} ${exp}`;
+		});
 	}
-	joinEntry(kind, other) {
-		return {
-			[kind]: requireAlias(other),
-			on: this.eq(idColumnOf(other))
+	/** Maps literal values through the field serde and binds aliases only when parsing. */
+	addCondition(value) {
+		if ("value" in value && value.value === void 0) return require_DeferredAlias.skipCondition;
+		const cond = {
+			kind: "column",
+			alias: "unset",
+			column: this.column.columnName,
+			dbType: this.column.dbType,
+			cond: require_QueryParser.mapToDb(this.column, value)
 		};
+		return require_DeferredAlias.withDeferredAlias(cond, (resolve, copy) => {
+			const r = resolve(this.mgmt);
+			copy.alias = getMaybeCtiAlias(this.meta, this.field, r.meta, r.alias);
+		});
 	}
-	compareId(op, kind, value) {
-		if (value === void 0) return require_Expr.skipCondition;
-		if (value === null) throw new Error("Unsupported");
-		if (require_Expr.isExpr(value)) return this.compareToExpr(op, value);
+	/** Handles literal values, NULL, and domain cross-alias comparisons. */
+	compare(kind, op, value) {
+		if (value === void 0) return require_DeferredAlias.skipCondition;
+		if (value instanceof AliasColumnImpl) return crossColumnCondition(this, value, op);
+		if (value === null && (kind === "eq" || kind === "ne")) return this.addCondition({ kind: kind === "eq" ? "is-null" : "not-null" });
+		if (value === null && [
+			"gt",
+			"gte",
+			"lt",
+			"lte"
+		].includes(kind)) return require_utils.fail("Unsupported");
 		return this.addCondition({
 			kind,
 			value
 		});
 	}
 };
+/** Resolves polymorphic predicates to their physical component columns. */
 var PolyReferenceAlias = class {
 	meta;
 	mgmt;
@@ -378,7 +223,6 @@ var PolyReferenceAlias = class {
 		this.mgmt = mgmt;
 		this.field = field;
 	}
-	/** Compares to a tagged id, an entity, or another alias's id column, which picks the component (`c.parent.eq(a.id)`). */
 	eq(value) {
 		return this.addEqOrNe("eq", value);
 	}
@@ -386,237 +230,64 @@ var PolyReferenceAlias = class {
 		return this.addEqOrNe("ne", value);
 	}
 	in(values) {
-		if (values === void 0) return require_Expr.skipCondition;
-		if (require_Expr.isExpr(values)) return this.inSubquery(values);
-		const idsByConstructor = (0, joist_utils.groupBy)(values, (id) => require_configure.getConstructorFromTaggedId(require_keys.maybeResolveReferenceToId(id)).name);
-		return { or: Object.entries(idsByConstructor).map(([cstrName, ids]) => {
-			const comp = this.field.components.find((p) => p.otherMetadata().cstr.name === cstrName) ?? require_utils.fail(`No component for ${cstrName}`);
-			return this.addCondition(comp, {
+		if (values === void 0) return require_DeferredAlias.skipCondition;
+		const groups = (0, joist_utils.groupBy)(values, (id) => require_configure.getConstructorFromTaggedId(require_keys.maybeResolveReferenceToId(id)).name);
+		return { or: Object.entries(groups).map(([name, ids]) => {
+			const comp = this.field.components.find((c) => c.otherMetadata().cstr.name === name) ?? require_utils.fail(`No component for ${name}`);
+			return this.component(comp).addCondition({
 				kind: "in",
 				value: ids
 			});
 		}) };
 	}
-	/** Joins `other` via this poly's component for its entity, INNER when the poly is required. */
-	as(other) {
-		return this.joinEntry(this.field.required ? "inner" : "left", other);
-	}
-	inner(other) {
-		return this.joinEntry("inner", other);
-	}
-	left(other) {
-		return this.joinEntry("left", other);
-	}
-	joinEntry(kind, other) {
-		return {
-			[kind]: requireAlias(other),
-			on: this.eq(idColumnOf(other))
-		};
-	}
-	/**
-	* i.e. `c.parent.in(query({ from: a, ..., select: a.id }))`: like `eq` against an alias column, the
-	* subquery's select column picks the component, i.e. authors pick `parent_author_id`.
-	*/
-	inSubquery(values) {
-		const select = require_Expr.asNode(values).subquerySelect;
-		if (!(select instanceof AbstractAliasColumn)) return require_utils.fail(`${this.field.fieldName} is polymorphic, so \`in\` needs a subquery selecting an id or FK column`);
-		const otherMeta = select.field.kind === "primaryKey" ? select.meta : select.field.kind === "m2o" ? select.field.otherMetadata() : require_utils.fail(`${this.field.fieldName} \`in\` needs an id or FK column, got ${select.field.fieldName}`);
-		const comp = this.field.components.find((p) => require_EntityMetadata.getBaseAndSelfMetas(otherMeta).includes(p.otherMetadata())) ?? require_utils.fail(`${this.field.fieldName} has no component for ${otherMeta.type}`);
-		return require_Expr.deferredCondition((ctx) => {
-			const alias = getMaybeCtiAlias(this.meta, this.field, this.meta, ctx.aliasFor(this.mgmt));
-			const sub = require_Expr.asNode(values).toSqlBare(ctx);
-			return {
-				sql: `${alias}.${comp.columnName} IN (${sub.sql})`,
-				bindings: sub.bindings,
-				refs: [alias, ...sub.refs]
-			};
-		});
-	}
+	/** Picks the component from an entity, tagged id, or another domain alias column. */
 	addEqOrNe(kind, value) {
-		if (value === void 0) return require_Expr.skipCondition;
-		else if (value instanceof AbstractAliasColumn) {
-			const otherMeta = value.meta;
-			const comp = this.field.components.find((p) => require_EntityMetadata.getBaseAndSelfMetas(otherMeta).includes(p.otherMetadata())) ?? require_utils.fail(`${this.field.fieldName} has no component for ${otherMeta.type}`);
-			return newCrossColumnCondition(this.meta, this.field, this.mgmt, comp.columnName, value, kind === "eq" ? "=" : "!=");
-		} else if (require_Expr.isExpr(value)) return require_utils.fail(`${this.field.fieldName} is polymorphic, so it can only be compared to tagged ids or entity alias columns`);
-		else if (value === null) {
-			const value = kind === "eq" ? { kind: "is-null" } : { kind: "not-null" };
-			return { and: this.field.components.map((p) => this.addCondition(p, value)) };
-		} else {
-			const comp = this.field.components.find((p) => p.otherMetadata().cstr === require_configure.getConstructorFromTaggedId(require_keys.maybeResolveReferenceToId(value))) || require_utils.fail(`Could not find component for ${value}`);
-			return this.addCondition(comp, {
-				kind,
-				value
-			});
-		}
-	}
-	addCondition(comp, value) {
+		if (value === void 0) return require_DeferredAlias.skipCondition;
+		if (value === null) return { and: this.field.components.map((c) => this.component(c).addCondition({ kind: kind === "eq" ? "is-null" : "not-null" })) };
+		const otherMeta = value instanceof AliasColumnImpl ? value.field.kind === "m2o" ? value.field.otherMetadata() : value.meta : require_EntityMetadata.getMetadata(require_configure.getConstructorFromTaggedId(require_keys.maybeResolveReferenceToId(value)));
+		const comp = this.field.components.find((c) => require_EntityMetadata.getBaseAndSelfMetas(otherMeta).includes(c.otherMetadata())) ?? require_utils.fail(`${this.field.fieldName} has no component for ${otherMeta.type}`);
+		const column = this.component(comp);
+		return kind === "eq" ? column.eq(value) : column.ne(value);
+	}
+	/** Uses the component serde, not the first component's codec. */
+	component(comp) {
 		const column = this.field.serde.columns.find((c) => c.columnName === comp.columnName) ?? require_utils.fail("Missing column");
-		const cond = {
-			kind: "column",
-			alias: "unset",
-			column: comp.columnName,
-			dbType: this.field.serde.columns[0].dbType,
-			cond: require_QueryParser.mapToDb(column, value)
-		};
-		return require_Expr.withDeferredAlias(cond, (resolve) => {
-			const r = resolve(this.mgmt);
-			cond.alias = getMaybeCtiAlias(this.meta, this.field, r.meta, r.alias);
-		});
+		return new AliasColumnImpl(this.meta, this.field, column, this.mgmt);
 	}
 };
-/**
-* Given an alias created for `meta`, adjusts the alias if it's bound to a potentially
-* different parent-/sub-meta in the join tree.
-*/
+/** Adjusts a field's SQL alias when a base alias is bound to a CTI subtype in the join tree. */
 function getMaybeCtiAlias(meta, field, newMeta, newAlias) {
 	if (newMeta !== meta && newMeta.inheritanceType === "cti") {
 		if (require_EntityMetadata.getBaseAndSelfMetas(newMeta).includes(newMeta)) return `${newAlias}_b0`;
 	}
 	return `${newAlias}${field.aliasSuffix}`;
 }
-/**
-* Marks a sugar join entry whose target is a *collection* (o2m/m2m), which filter soft-deletes like
-* em.find's "collections filter out soft-deletes, but m2o/o2o references still return them"; see
-* `QueryParser.addSoftDeleteCondition`'s call site. Reference joins and explicit joins are unmarked.
-*/
-const collectionJoin = Symbol("joist.collectionJoin");
-/** Marks a sugar m2m join entry (`a.tags.as(t)`) with its hidden join-table join; `parseQuery` expands it. */
-const m2mJoinTable = Symbol("joist.m2mJoinTable");
-/** The runtime identity of an m2m join table in a query, i.e. `authors_to_tags`; it has no entity. */
-var JoinTableHandle = class {
-	joinTableName;
-	constructor(joinTableName) {
-		this.joinTableName = joinTableName;
-	}
-};
-/**
-* The `as`/`inner`/`left` join factory for collection relations, i.e. `a.books.as(b)` joins with the
-* relation's default kind (LEFT: a collection may be empty) and `.inner`/`.left` override. m2o/poly
-* relations implement the same three methods directly on their column/impl classes, so `b.author`
-* stays a plain expression that is also a join factory.
-*/
-var AbstractCollectionAlias = class {
-	as(other) {
-		return this.joinEntry("left", requireAlias(other));
-	}
-	inner(other) {
-		return this.joinEntry("inner", requireAlias(other));
-	}
-	left(other) {
-		return this.joinEntry("left", requireAlias(other));
-	}
-};
-/** An o2m/lo2m/o2o relation: the ON is the other side's FK (an m2o or a poly component) back to our id. */
-var OneToManyAliasImpl = class extends AbstractCollectionAlias {
-	proxy;
-	field;
-	constructor(proxy, field) {
-		super();
-		this.proxy = proxy;
-		this.field = field;
-	}
-	joinEntry(kind, other) {
-		const { field } = this;
-		const on = other[field.otherFieldName].eq(this.proxy.id);
-		const filtered = field.kind === "o2m" ? field.softDeletes !== "include" : field.kind === "lo2m";
-		return {
-			[kind]: other,
-			on,
-			[collectionJoin]: filtered
-		};
-	}
-};
-/**
-* An m2m relation, i.e. `a.tags.as(t)`.
-*
-* The entry's own ON is `t.id = att.tag_id`, and the hidden `[m2mJoinTable]` half is
-* `att.author_id = a.id`; only the target's ON references the join table, so reference pruning keeps
-* or drops the pair together. Both are deferred conditions: the join table has no entity metadata, so
-* its alias only exists once the parser registers it.
-*/
-var ManyToManyAliasImpl = class extends AbstractCollectionAlias {
-	proxy;
-	field;
-	constructor(proxy, field) {
-		super();
-		this.proxy = proxy;
-		this.field = field;
-	}
-	joinEntry(kind, other) {
-		const { joinTableName, columnNames } = this.field;
-		const [ourColumn, otherColumn] = columnNames;
-		const jt = new JoinTableHandle(joinTableName);
-		const ourId = this.proxy.id;
-		const otherId = idColumnOf(other);
-		const jtOn = require_Expr.deferredCondition((ctx) => {
-			const jtAlias = ctx.aliasFor(jt);
-			const id = ourId.toSql(ctx);
-			return {
-				sql: `${require_keywords.kqDot(jtAlias, ourColumn)} = ${id.sql}`,
-				bindings: id.bindings,
-				refs: id.refs
-			};
-		});
-		const on = require_Expr.deferredCondition((ctx) => {
-			const jtAlias = ctx.aliasFor(jt);
-			const id = otherId.toSql(ctx);
-			return {
-				sql: `${id.sql} = ${require_keywords.kqDot(jtAlias, otherColumn)}`,
-				bindings: id.bindings,
-				refs: [...id.refs, jtAlias]
-			};
-		});
-		const filtered = this.field.softDeletes !== "include";
-		return {
-			[kind]: other,
-			on,
-			[collectionJoin]: filtered,
-			[m2mJoinTable]: {
-				handle: jt,
-				on: jtOn
-			}
-		};
-	}
-};
-/** Compares columns with per-parse aliases, i.e. `parent_author_id = <other id>` for `c.parent.eq(a.id)`. */
-function newCrossColumnCondition(meta, field, mgmt, columnName, otherColumn, op) {
-	const cond = {
+/** Compares domain columns with per-parse aliases, preserving condition reuse across find calls. */
+function crossColumnCondition(left, right, op, negate = false) {
+	return require_DeferredAlias.withDeferredAlias({
 		kind: "raw",
 		aliases: [],
 		condition: "unset",
-		pruneable: false,
-		bindings: []
-	};
-	return require_Expr.withDeferredAlias(cond, (resolve) => {
-		const r1 = resolve(mgmt);
-		const r2 = resolve(otherColumn.mgmt);
-		const a1 = getMaybeCtiAlias(meta, field, r1.meta, r1.alias);
-		const a2 = getMaybeCtiAlias(otherColumn.meta, otherColumn.field, r2.meta, r2.alias);
-		cond.aliases = [a1, a2];
-		cond.condition = `${a1}.${columnName} ${op} ${a2}.${otherColumn.column.columnName}`;
+		bindings: [],
+		pruneable: false
+	}, (resolve, copy) => {
+		const l = resolve(left.mgmt);
+		const r = resolve(right.mgmt);
+		const a1 = getMaybeCtiAlias(left.meta, left.field, l.meta, l.alias);
+		const a2 = getMaybeCtiAlias(right.meta, right.field, r.meta, r.alias);
+		copy.aliases = [a1, a2];
+		const sql = `${a1}.${left.column.columnName} ${op} ${a2}.${right.column.columnName}`;
+		copy.condition = negate ? `NOT (${sql})` : sql;
 	});
 }
-/** Fails fast when a join factory is passed something other than an alias. */
-function requireAlias(other) {
-	if (!isAlias(other)) return require_utils.fail(`Expected an alias to join, got ${other}`);
-	return other;
-}
-/** The id column of a joined alias, for building sugar ON conditions. */
-function idColumnOf(other) {
-	return other.id;
-}
 //#endregion
-exports.JoinTableHandle = JoinTableHandle;
 exports.alias = alias;
 exports.aliasMgmt = aliasMgmt;
 exports.aliases = aliases;
-exports.collectionJoin = collectionJoin;
 exports.getAliasMetadata = getAliasMetadata;
 exports.getAliasMgmt = getAliasMgmt;
 exports.getMaybeCtiAlias = getMaybeCtiAlias;
 exports.isAlias = isAlias;
-exports.m2mJoinTable = m2mJoinTable;
 exports.newAliasProxy = newAliasProxy;
 
 //# sourceMappingURL=Aliases.cjs.map