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

package/build/Aliases.cjs

@@ -1,9 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./typeMap.cjs");
+const require_keywords = require("./keywords.cjs");
 const require_keys = require("./keys.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");
@@ -11,8 +13,7 @@ const require_configure = require("./configure.cjs");
 const require_QueryParser = require("./QueryParser.cjs");
 let joist_utils = require("joist-utils");
 //#region src/Aliases.ts
-/** Creates an alias for complex filtering against `T`. */
-function alias(cstr) {
+function alias(cstr, _name) {
 	return newAliasProxy(cstr);
 }
 /** Creates multiple aliases for complex filtering. */
@@ -25,32 +26,29 @@ function getAliasMgmt(alias) {
 }
 /** Returns the metadata for the entity that `alias` is bound to. */
 function getAliasMetadata(alias) {
-	const mgmt = alias[aliasMgmt];
-	return require_configure.getMetadataForTable(mgmt.tableName);
+	return alias[aliasMgmt].meta;
 }
 function newAliasProxy(cstr) {
 	const meta = require_EntityMetadata.getMetadata(cstr);
-	const callbacks = [];
 	const mgmt = {
 		tableName: meta.tableName,
-		setAlias(newMeta, newAlias) {
-			for (const callback of callbacks) callback(newMeta, newAlias);
-		},
-		onBind(callback) {
-			callbacks.push(callback);
-		}
+		meta
 	};
-	return new Proxy(cstr, {
-		/** Create a column alias for the given field. */
+	const proxy = new Proxy(cstr, {
+		/** Create a column alias, or a relation join factory, for the given field. */
 		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, callbacks, field.serde.columns[0]);
-				case "m2o": return new EntityAliasImpl(meta, field, callbacks, field.serde.columns[0]);
-				case "poly": return new PolyReferenceAlias(meta, callbacks, field);
+				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}`);
 			}
 		},
@@ -58,20 +56,48 @@ function newAliasProxy(cstr) {
 			return key === aliasMgmt || key in meta.allFields;
 		}
 	});
+	return proxy;
 }
 function isAlias(obj) {
 	return obj && typeof obj === "function" && obj[aliasMgmt] !== void 0;
 }
-var AbstractAliasColumn = class {
+/**
+* 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 {
 	meta;
 	field;
-	callbacks;
 	column;
-	constructor(meta, field, callbacks, column) {
+	mgmt;
+	constructor(meta, field, column, mgmt) {
+		super();
 		this.meta = meta;
 		this.field = field;
-		this.callbacks = callbacks;
 		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 = {
@@ -81,128 +107,121 @@ var AbstractAliasColumn = class {
 			dbType: this.column.dbType,
 			cond: require_QueryParser.mapToDb(this.column, value)
 		};
-		this.callbacks.push((newMeta, newAlias) => {
-			cond.alias = getMaybeCtiAlias(this.meta, this.field, newMeta, newAlias);
+		return require_Expr.withDeferredAlias(cond, (resolve) => {
+			const r = resolve(this.mgmt);
+			cond.alias = getMaybeCtiAlias(this.meta, this.field, r.meta, r.alias);
 		});
-		return cond;
 	}
 	addRawCondition(exp, bindings) {
 		const cond = {
 			kind: "raw",
 			aliases: [],
-			condition: `unset.${this.column.columnName} ${exp}`,
+			condition: "unset",
 			pruneable: false,
 			bindings
 		};
-		this.callbacks.push((newMeta, newAlias) => {
-			const alias = getMaybeCtiAlias(this.meta, this.field, newMeta, newAlias);
-			if (!cond.aliases.includes(alias)) cond.aliases.push(alias);
-			cond.condition = cond.condition.replace("unset", alias);
+		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}`;
 		});
-		return cond;
 	}
-	addCrossColumnRawCondition(otherColumn, op) {
-		const cond = {
-			kind: "raw",
-			aliases: [],
-			condition: `unset1.${this.column.columnName} ${op} unset2.${otherColumn.column.columnName}`,
-			pruneable: false,
-			bindings: []
-		};
-		this.callbacks.push((newMeta, newAlias) => {
-			const alias = getMaybeCtiAlias(this.meta, this.field, newMeta, newAlias);
-			if (!cond.aliases.includes(alias)) cond.aliases.push(alias);
-			cond.condition = cond.condition.replace("unset1", alias);
-		});
-		otherColumn.callbacks.push((newMeta, newAlias) => {
-			const alias = getMaybeCtiAlias(otherColumn.meta, otherColumn.field, newMeta, newAlias);
-			if (!cond.aliases.includes(alias)) cond.aliases.push(alias);
-			cond.condition = cond.condition.replace("unset2", alias);
-		});
-		return cond;
+	/**
+	* 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 PrimitiveAliasImpl extends AbstractAliasColumn {
+var PrimitiveAliasImpl = class extends AbstractAliasColumn {
 	eq(value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
-		else if (value instanceof PrimitiveAliasImpl) return this.addCrossColumnRawCondition(value, "=");
-		else if (value === null) return this.addCondition({ kind: "is-null" });
-		else return this.addCondition({
+		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_QueryParser.skipCondition;
-		else if (value instanceof PrimitiveAliasImpl) return this.addCrossColumnRawCondition(value, "!=");
-		else if (value === null) return this.addCondition({ kind: "not-null" });
-		else return this.addCondition({
+		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
 		});
 	}
 	gt(value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
-		else if (value instanceof PrimitiveAliasImpl) return this.addCrossColumnRawCondition(value, ">");
-		else return this.addCondition({
+		if (value === void 0) return require_Expr.skipCondition;
+		if (require_Expr.isExpr(value)) return this.compareToExpr(">", value);
+		return this.addCondition({
 			kind: "gt",
 			value
 		});
 	}
 	gte(value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
-		else if (value instanceof PrimitiveAliasImpl) return this.addCrossColumnRawCondition(value, ">=");
-		else return this.addCondition({
+		if (value === void 0) return require_Expr.skipCondition;
+		if (require_Expr.isExpr(value)) return this.compareToExpr(">=", value);
+		return this.addCondition({
 			kind: "gte",
 			value
 		});
 	}
 	lt(value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
-		else if (value instanceof PrimitiveAliasImpl) return this.addCrossColumnRawCondition(value, "<");
-		else return this.addCondition({
+		if (value === void 0) return require_Expr.skipCondition;
+		if (require_Expr.isExpr(value)) return this.compareToExpr("<", value);
+		return this.addCondition({
 			kind: "lt",
 			value
 		});
 	}
 	lte(value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
-		else if (value instanceof PrimitiveAliasImpl) return this.addCrossColumnRawCondition(value, "<=");
-		else return this.addCondition({
+		if (value === void 0) return require_Expr.skipCondition;
+		if (require_Expr.isExpr(value)) return this.compareToExpr("<=", value);
+		return this.addCondition({
 			kind: "lte",
 			value
 		});
 	}
 	between(v1, v2) {
-		if (v1 === void 0 || v2 === void 0) return require_QueryParser.skipCondition;
+		if (v1 === void 0 || v2 === void 0) return require_Expr.skipCondition;
 		return this.addCondition({
 			kind: "between",
 			value: [v1, v2]
 		});
 	}
 	like(value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
+		if (value === void 0) return require_Expr.skipCondition;
 		return this.addCondition({
 			kind: "like",
 			value
 		});
 	}
 	ilike(value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
+		if (value === void 0) return require_Expr.skipCondition;
 		return this.addCondition({
 			kind: "ilike",
 			value
 		});
 	}
 	search(value) {
-		if (!value) return require_QueryParser.skipCondition;
+		if (!value) return require_Expr.skipCondition;
 		return this.addCondition({
 			kind: "ilike",
 			value: require_QueryParser.makeLike(value)
 		});
 	}
 	in(values) {
-		if (values === void 0) return require_QueryParser.skipCondition;
+		if (values === void 0) return require_Expr.skipCondition;
+		if (require_Expr.isExpr(values)) return this.inList("IN", values);
 		if (values.includes(null)) return { or: [this.addCondition({ kind: "is-null" }), this.addCondition({
 			kind: "in",
 			value: values.filter((v) => v !== null)
@@ -212,124 +231,154 @@ var PrimitiveAliasImpl = class PrimitiveAliasImpl extends AbstractAliasColumn {
 			value: values
 		});
 	}
+	nin(values) {
+		if (values === void 0) return require_Expr.skipCondition;
+		if (require_Expr.isExpr(values)) return this.inList("NOT IN", values);
+		return this.addCondition({
+			kind: "nin",
+			value: values.filter((v) => v !== null)
+		});
+	}
 	contains(v1) {
-		if (v1 === void 0) return require_QueryParser.skipCondition;
+		if (v1 === void 0) return require_Expr.skipCondition;
 		return this.addCondition({
 			kind: "contains",
 			value: v1
 		});
 	}
 	ncontains(v1) {
-		if (v1 === void 0) return require_QueryParser.skipCondition;
+		if (v1 === void 0) return require_Expr.skipCondition;
 		return this.addCondition({
 			kind: "ncontains",
 			value: v1
 		});
 	}
 	overlaps(v1) {
-		if (v1 === void 0) return require_QueryParser.skipCondition;
+		if (v1 === void 0) return require_Expr.skipCondition;
 		return this.addCondition({
 			kind: "overlaps",
 			value: v1
 		});
 	}
 	noverlaps(v1) {
-		if (v1 === void 0) return require_QueryParser.skipCondition;
+		if (v1 === void 0) return require_Expr.skipCondition;
 		return this.addCondition({
 			kind: "noverlaps",
 			value: v1
 		});
 	}
 	pathExists(jsonPath) {
-		if (jsonPath === void 0) return require_QueryParser.skipCondition;
+		if (jsonPath === void 0) return require_Expr.skipCondition;
 		return this.addCondition({
 			kind: "jsonPathExists",
 			value: jsonPath
 		});
 	}
 	pathIsTrue(jsonPath) {
-		if (jsonPath === void 0) return require_QueryParser.skipCondition;
+		if (jsonPath === void 0) return require_Expr.skipCondition;
 		return this.addCondition({
 			kind: "jsonPathPredicate",
 			value: jsonPath
 		});
 	}
 	raw(exp, bindings) {
-		if (bindings === void 0) return require_QueryParser.skipCondition;
+		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_QueryParser.skipCondition;
-		else if (value === null) return this.addCondition({ kind: "is-null" });
-		else return this.addCondition({
+		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_QueryParser.skipCondition;
-		else if (value === null) return this.addCondition({ kind: "not-null" });
-		else return this.addCondition({
+		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
 		});
 	}
 	in(values) {
-		if (values === void 0) return require_QueryParser.skipCondition;
+		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
 		});
 	}
-	gt(value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
-		else if (value === null) throw new Error("Unsupported");
+	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: "gt",
-			value
+			kind: "nin",
+			value: values.filter((v) => v !== null)
 		});
 	}
+	gt(value) {
+		return this.compareId(">", "gt", value);
+	}
 	gte(value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
-		else if (value === null) throw new Error("Unsupported");
-		else return this.addCondition({
-			kind: "gte",
-			value
-		});
+		return this.compareId(">=", "gte", value);
 	}
 	lt(value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
-		else if (value === null) throw new Error("Unsupported");
-		else return this.addCondition({
-			kind: "lt",
-			value
-		});
+		return this.compareId("<", "lt", value);
 	}
 	lte(value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
-		else if (value === null) throw new Error("Unsupported");
-		else return this.addCondition({
-			kind: "lte",
-			value
-		});
+		return this.compareId("<=", "lte", value);
 	}
 	raw(exp, bindings) {
-		if (bindings === void 0) return require_QueryParser.skipCondition;
+		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);
+	}
+	joinEntry(kind, other) {
+		return {
+			[kind]: requireAlias(other),
+			on: this.eq(idColumnOf(other))
+		};
+	}
+	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);
+		return this.addCondition({
+			kind,
+			value
+		});
+	}
 };
 var PolyReferenceAlias = class {
 	meta;
-	callbacks;
+	mgmt;
 	field;
-	constructor(meta, callbacks, field) {
+	constructor(meta, mgmt, field) {
 		this.meta = meta;
-		this.callbacks = callbacks;
+		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);
 	}
@@ -337,7 +386,8 @@ var PolyReferenceAlias = class {
 		return this.addEqOrNe("ne", value);
 	}
 	in(values) {
-		if (values === void 0) return require_QueryParser.skipCondition;
+		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}`);
@@ -347,8 +397,48 @@ var PolyReferenceAlias = class {
 			});
 		}) };
 	}
+	/** 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]
+			};
+		});
+	}
 	addEqOrNe(kind, value) {
-		if (value === void 0) return require_QueryParser.skipCondition;
+		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)) };
@@ -369,10 +459,10 @@ var PolyReferenceAlias = class {
 			dbType: this.field.serde.columns[0].dbType,
 			cond: require_QueryParser.mapToDb(column, value)
 		};
-		this.callbacks.push((newMeta, newAlias) => {
-			cond.alias = getMaybeCtiAlias(this.meta, this.field, newMeta, newAlias);
+		return require_Expr.withDeferredAlias(cond, (resolve) => {
+			const r = resolve(this.mgmt);
+			cond.alias = getMaybeCtiAlias(this.meta, this.field, r.meta, r.alias);
 		});
-		return cond;
 	}
 };
 /**
@@ -385,13 +475,148 @@ function getMaybeCtiAlias(meta, field, newMeta, newAlias) {
 	}
 	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 = {
+		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}`;
+	});
+}
+/** 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