joist-core 2.3.0-next.7 → 2.3.0-next.71

package/build/Aliases.js

@@ -1,457 +1,285 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.alias = alias;
-exports.aliases = aliases;
-exports.getAliasMgmt = getAliasMgmt;
-exports.getAliasMetadata = getAliasMetadata;
-exports.newAliasProxy = newAliasProxy;
-exports.isAlias = isAlias;
-exports.getMaybeCtiAlias = getMaybeCtiAlias;
-const joist_utils_1 = require("joist-utils");
-const EntityMetadata_1 = require("./EntityMetadata");
-const QueryParser_1 = require("./QueryParser");
-const configure_1 = require("./configure");
-const index_1 = require("./index");
-const utils_1 = require("./utils");
-/** Creates an alias for complex filtering against `T`. */
+import "./typeMap.js";
+import "./EntityFilter.js";
+import { maybeResolveReferenceToId } from "./keys.js";
+import { getBaseAndSelfMetas, getMetadata } from "./EntityMetadata.js";
+import { fail } from "./utils.js";
+import { skipCondition } from "./skipCondition.js";
+import { withDeferredAlias } from "./DeferredAlias.js";
+import "./EntityManager.js";
+import "./Entity.js";
+import { getConstructorFromTaggedId } from "./configure.js";
+import { makeLike, mapToDb } from "./QueryParser.js";
+import { groupBy } from "joist-utils";
+//#region src/Aliases.ts
+/** Creates an alias for complex domain filtering in `em.find`. */
 function alias(cstr) {
-    return newAliasProxy(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];
+	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) {
-    const mgmt = alias[aliasMgmt];
-    return (0, configure_1.getMetadataForTable)(mgmt.tableName);
+	return alias[aliasMgmt].meta;
 }
+/** Creates domain predicates lazily from entity field metadata. */
 function newAliasProxy(cstr) {
-    const meta = (0, EntityMetadata_1.getMetadata)(cstr);
-    // Keeps a list of callbacks we've created for this specific proxy, so that parseFindQuery
-    // can tell us, after we've been creating via the `const a = alias(Author)` command, which
-    // alias we're actually bound to in the join literal.
-    const callbacks = [];
-    // Give QueryBuilder a hook to assign our actual alias
-    const mgmt = {
-        tableName: meta.tableName,
-        setAlias(newMeta, newAlias) {
-            for (const callback of callbacks)
-                callback(newMeta, newAlias);
-        },
-        onBind(callback) {
-            callbacks.push(callback);
-        },
-    };
-    return new Proxy(cstr, {
-        /** Create a column alias for the given field. */
-        get(_, key) {
-            if (key === aliasMgmt) {
-                return mgmt;
-            }
-            const field = meta.allFields[key] ?? (0, utils_1.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);
-                default:
-                    throw new Error(`Unsupported alias field kind ${field.kind}`);
-            }
-        },
-        has(_, key) {
-            return key === aliasMgmt || key in meta.allFields;
-        },
-    });
+	const meta = getMetadata(cstr);
+	const mgmt = {
+		tableName: meta.tableName,
+		meta
+	};
+	return new Proxy(cstr, {
+		get(_, key) {
+			if (key === aliasMgmt) return mgmt;
+			if (typeof key !== "string") return void 0;
+			const field = meta.allFields[key] ?? 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 fail(`Unsupported alias field kind ${field.kind}`);
+		},
+		has(_, key) {
+			return key === aliasMgmt || key in meta.allFields;
+		}
+	});
 }
-function isAlias(obj) {
-    // Oddly enough `typeof` will be a function b/c we are proxying the constructors
-    return obj && typeof obj === "function" && obj[aliasMgmt] !== undefined;
+/** Recognizes only domain aliases, not physical tables. */
+function isAlias(value) {
+	return typeof value === "function" && aliasMgmt in value;
 }
-class AbstractAliasColumn {
-    meta;
-    field;
-    callbacks;
-    column;
-    constructor(meta, field, callbacks, column) {
-        this.meta = meta;
-        this.field = field;
-        this.callbacks = callbacks;
-        this.column = column;
-    }
-    addCondition(value) {
-        const cond = {
-            kind: "column",
-            alias: "unset",
-            column: this.column.columnName,
-            dbType: this.column.dbType,
-            cond: (0, QueryParser_1.mapToDb)(this.column, value),
-        };
-        // Track the conditions we've created to re-write the alias when we're bound
-        this.callbacks.push((newMeta, newAlias) => {
-            cond.alias = getMaybeCtiAlias(this.meta, this.field, newMeta, newAlias);
-        });
-        return cond;
-    }
-    addRawCondition(exp, bindings) {
-        const cond = {
-            kind: "raw",
-            aliases: [],
-            condition: `unset.${this.column.columnName} ${exp}`,
-            pruneable: false,
-            bindings,
-        };
-        // Update `unset` placeholder when we're bound
-        this.callbacks.push((newMeta, newAlias) => {
-            // Add a base-table/sub-table alias if needed
-            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 cond;
-    }
-    addCrossColumnRawCondition(otherColumn, op) {
-        const cond = {
-            kind: "raw",
-            aliases: [],
-            condition: `unset1.${this.column.columnName} ${op} unset2.${otherColumn.column.columnName}`,
-            pruneable: false,
-            bindings: [],
-        };
-        // Update `unset1` placeholder when we're bound
-        this.callbacks.push((newMeta, newAlias) => {
-            // Add a base-table/sub-table alias if needed
-            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);
-        });
-        // Update `unset2` placeholder when we're bound
-        otherColumn.callbacks.push((newMeta, newAlias) => {
-            // Add a base-table/sub-table alias if needed
-            const alias = getMaybeCtiAlias(otherColumn.meta, otherColumn.field, newMeta, newAlias);
-            // Kinda weird, we can get bound a few times
-            if (!cond.aliases.includes(alias))
-                cond.aliases.push(alias);
-            cond.condition = cond.condition.replace("unset2", alias);
-        });
-        return cond;
-    }
-}
-class PrimitiveAliasImpl extends AbstractAliasColumn {
-    eq(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value instanceof PrimitiveAliasImpl) {
-            return this.addCrossColumnRawCondition(value, "=");
-        }
-        else if (value === null) {
-            return this.addCondition({ kind: "is-null" });
-        }
-        else {
-            return this.addCondition({ kind: "eq", value: value });
-        }
-    }
-    ne(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value instanceof PrimitiveAliasImpl) {
-            return this.addCrossColumnRawCondition(value, "!=");
-        }
-        else if (value === null) {
-            return this.addCondition({ kind: "not-null" });
-        }
-        else {
-            return this.addCondition({ kind: "ne", value });
-        }
-    }
-    gt(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value instanceof PrimitiveAliasImpl) {
-            return this.addCrossColumnRawCondition(value, ">");
-        }
-        else {
-            return this.addCondition({ kind: "gt", value });
-        }
-    }
-    gte(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value instanceof PrimitiveAliasImpl) {
-            return this.addCrossColumnRawCondition(value, ">=");
-        }
-        else {
-            return this.addCondition({ kind: "gte", value });
-        }
-    }
-    lt(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value instanceof PrimitiveAliasImpl) {
-            return this.addCrossColumnRawCondition(value, "<");
-        }
-        else {
-            return this.addCondition({ kind: "lt", value });
-        }
-    }
-    lte(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value instanceof PrimitiveAliasImpl) {
-            return this.addCrossColumnRawCondition(value, "<=");
-        }
-        else {
-            return this.addCondition({ kind: "lte", value });
-        }
-    }
-    between(v1, v2) {
-        if (v1 === undefined || v2 === undefined)
-            return QueryParser_1.skipCondition;
-        return this.addCondition({ kind: "between", value: [v1, v2] });
-    }
-    like(value) {
-        if (value === undefined)
-            return QueryParser_1.skipCondition;
-        return this.addCondition({ kind: "like", value });
-    }
-    ilike(value) {
-        if (value === undefined)
-            return QueryParser_1.skipCondition;
-        return this.addCondition({ kind: "ilike", value });
-    }
-    search(value) {
-        // Check !value so that empty strings are pruned
-        if (!value)
-            return QueryParser_1.skipCondition;
-        return this.addCondition({ kind: "ilike", value: (0, QueryParser_1.makeLike)(value) });
-    }
-    in(values) {
-        if (values === undefined)
-            return QueryParser_1.skipCondition;
-        if (values.includes(null)) {
-            const isNull = this.addCondition({ kind: "is-null" });
-            const hasValue = this.addCondition({ kind: "in", value: values.filter((v) => v !== null) });
-            return { or: [isNull, hasValue] };
-        }
-        else {
-            return this.addCondition({ kind: "in", value: values });
-        }
-    }
-    // V will already be an array
-    contains(v1) {
-        if (v1 === undefined)
-            return QueryParser_1.skipCondition;
-        return this.addCondition({ kind: "contains", value: v1 });
-    }
-    // V will already be an array
-    ncontains(v1) {
-        if (v1 === undefined)
-            return QueryParser_1.skipCondition;
-        return this.addCondition({ kind: "ncontains", value: v1 });
-    }
-    // V will already be an array
-    overlaps(v1) {
-        if (v1 === undefined)
-            return QueryParser_1.skipCondition;
-        return this.addCondition({ kind: "overlaps", value: v1 });
-    }
-    noverlaps(v1) {
-        if (v1 === undefined)
-            return QueryParser_1.skipCondition;
-        return this.addCondition({ kind: "noverlaps", value: v1 });
-    }
-    pathExists(jsonPath) {
-        if (jsonPath === undefined)
-            return QueryParser_1.skipCondition;
-        return this.addCondition({ kind: "jsonPathExists", value: jsonPath });
-    }
-    pathIsTrue(jsonPath) {
-        if (jsonPath === undefined)
-            return QueryParser_1.skipCondition;
-        return this.addCondition({ kind: "jsonPathPredicate", value: jsonPath });
-    }
-    raw(exp, bindings) {
-        if (bindings === undefined)
-            return QueryParser_1.skipCondition;
-        return this.addRawCondition(exp, bindings);
-    }
-}
-class EntityAliasImpl extends AbstractAliasColumn {
-    eq(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value === null) {
-            return this.addCondition({ kind: "is-null" });
-        }
-        else {
-            return this.addCondition({ kind: "eq", value: value });
-        }
-    }
-    ne(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value === null) {
-            return this.addCondition({ kind: "not-null" });
-        }
-        else {
-            return this.addCondition({ kind: "ne", value: value });
-        }
-    }
-    in(values) {
-        if (values === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (values === null) {
-            throw new Error("Unsupported");
-        }
-        else {
-            return this.addCondition({ kind: "in", value: values });
-        }
-    }
-    gt(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value === null) {
-            throw new Error("Unsupported");
-        }
-        else {
-            return this.addCondition({ kind: "gt", value: value });
-        }
-    }
-    gte(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value === null) {
-            throw new Error("Unsupported");
-        }
-        else {
-            return this.addCondition({ kind: "gte", value: value });
-        }
-    }
-    lt(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value === null) {
-            throw new Error("Unsupported");
-        }
-        else {
-            return this.addCondition({ kind: "lt", value: value });
-        }
-    }
-    lte(value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value === null) {
-            throw new Error("Unsupported");
-        }
-        else {
-            return this.addCondition({ kind: "lte", value: value });
-        }
-    }
-    raw(exp, bindings) {
-        if (bindings === undefined)
-            return QueryParser_1.skipCondition;
-        return this.addRawCondition(exp, bindings);
-    }
-}
-class PolyReferenceAlias {
-    meta;
-    callbacks;
-    field;
-    constructor(meta, callbacks, field) {
-        this.meta = meta;
-        this.callbacks = callbacks;
-        this.field = field;
-    }
-    eq(value) {
-        return this.addEqOrNe("eq", value);
-    }
-    ne(value) {
-        return this.addEqOrNe("ne", value);
-    }
-    // We required tagged ids for polys
-    in(values) {
-        if (values === undefined)
-            return QueryParser_1.skipCondition;
-        // Split up the ids by constructor
-        const idsByConstructor = (0, joist_utils_1.groupBy)(values, (id) => (0, index_1.getConstructorFromTaggedId)((0, index_1.maybeResolveReferenceToId)(id)).name);
-        // Or together `parent_book_id in (1,2,3) OR parent_author_id IN (4,5,6)`
-        return {
-            or: Object.entries(idsByConstructor).map(([cstrName, ids]) => {
-                const comp = this.field.components.find((p) => p.otherMetadata().cstr.name === cstrName) ??
-                    (0, utils_1.fail)(`No component for ${cstrName}`);
-                return this.addCondition(comp, { kind: "in", value: ids });
-            }),
-        };
-    }
-    addEqOrNe(kind, value) {
-        if (value === undefined) {
-            return QueryParser_1.skipCondition;
-        }
-        else if (value === null) {
-            // We can AND each of the components as many conditions
-            const value = kind === "eq" ? { kind: "is-null" } : { kind: "not-null" };
-            return {
-                and: this.field.components.map((p) => this.addCondition(p, value)),
-            };
-        }
-        else {
-            // If we have a value, we can find the component
-            const comp = this.field.components.find((p) => p.otherMetadata().cstr === (0, index_1.getConstructorFromTaggedId)((0, index_1.maybeResolveReferenceToId)(value))) || (0, utils_1.fail)(`Could not find component for ${value}`);
-            return this.addCondition(comp, { kind, value });
-        }
-    }
-    addCondition(comp, value) {
-        const column = this.field.serde.columns.find((c) => c.columnName === comp.columnName) ?? (0, utils_1.fail)("Missing column");
-        const cond = {
-            kind: "column",
-            alias: "unset",
-            column: comp.columnName,
-            dbType: this.field.serde.columns[0].dbType,
-            cond: (0, QueryParser_1.mapToDb)(column, value),
-        };
-        // Track the conditions we've created to re-write the alias when we're bound
-        this.callbacks.push((newMeta, newAlias) => {
-            cond.alias = getMaybeCtiAlias(this.meta, this.field, newMeta, newAlias);
-        });
-        return cond;
-    }
-}
-/**
- * Given an alias created for `meta`, adjusts the alias if it's bound to a potentially
- * different parent-/sub-meta in the join tree.
- */
+/** Builds field conditions without implementing the SQL expression protocol. */
+var AliasColumnImpl = class AliasColumnImpl {
+	meta;
+	field;
+	column;
+	mgmt;
+	constructor(meta, field, column, mgmt) {
+		this.meta = meta;
+		this.field = field;
+		this.column = column;
+		this.mgmt = mgmt;
+	}
+	eq(value) {
+		return this.compare("eq", "=", value);
+	}
+	ne(value) {
+		return this.compare("ne", "!=", value);
+	}
+	gt(value) {
+		return this.compare("gt", ">", value);
+	}
+	gte(value) {
+		return this.compare("gte", ">=", value);
+	}
+	lt(value) {
+		return this.compare("lt", "<", value);
+	}
+	lte(value) {
+		return this.compare("lte", "<=", value);
+	}
+	contains(value) {
+		return this.compare("contains", "@>", value);
+	}
+	ncontains(value) {
+		if (value instanceof AliasColumnImpl) return crossColumnCondition(this, value, "@>", true);
+		return this.addCondition({
+			kind: "ncontains",
+			value
+		});
+	}
+	overlaps(value) {
+		return this.compare("overlaps", "&&", value);
+	}
+	noverlaps(value) {
+		if (value instanceof AliasColumnImpl) return crossColumnCondition(this, value, "&&", true);
+		return this.addCondition({
+			kind: "noverlaps",
+			value
+		});
+	}
+	in(values) {
+		if (values === void 0) return skipCondition;
+		if (values === null) return fail("Unsupported");
+		if (values.includes(null)) return { or: [this.addCondition({ kind: "is-null" }), this.addCondition({
+			kind: "in",
+			value: values.filter((v) => v !== null)
+		})] };
+		return this.addCondition({
+			kind: "in",
+			value: [...values]
+		});
+	}
+	nin(values) {
+		if (values === void 0) return skipCondition;
+		if (values === null) return fail("Unsupported");
+		return this.addCondition({
+			kind: "nin",
+			value: values.filter((v) => v !== null)
+		});
+	}
+	between(v1, v2) {
+		if (v1 === void 0 || v2 === void 0) return skipCondition;
+		return this.addCondition({
+			kind: "between",
+			value: [v1, v2]
+		});
+	}
+	like(value) {
+		return this.addCondition({
+			kind: "like",
+			value
+		});
+	}
+	ilike(value) {
+		return this.addCondition({
+			kind: "ilike",
+			value
+		});
+	}
+	search(value) {
+		return !value ? skipCondition : this.addCondition({
+			kind: "ilike",
+			value: makeLike(value)
+		});
+	}
+	pathExists(value) {
+		return this.addCondition({
+			kind: "jsonPathExists",
+			value
+		});
+	}
+	pathIsTrue(value) {
+		return this.addCondition({
+			kind: "jsonPathPredicate",
+			value
+		});
+	}
+	raw(exp, bindings) {
+		if (bindings === void 0) return skipCondition;
+		return 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}`;
+		});
+	}
+	/** Maps literal values through the field serde and binds aliases only when parsing. */
+	addCondition(value) {
+		if ("value" in value && value.value === void 0) return skipCondition;
+		const cond = {
+			kind: "column",
+			alias: "unset",
+			column: this.column.columnName,
+			dbType: this.column.dbType,
+			cond: mapToDb(this.column, value)
+		};
+		return withDeferredAlias(cond, (resolve, copy) => {
+			const r = resolve(this.mgmt);
+			copy.alias = getMaybeCtiAlias(this.meta, this.field, r.meta, r.alias);
+		});
+	}
+	/** Handles literal values, NULL, and domain cross-alias comparisons. */
+	compare(kind, op, value) {
+		if (value === void 0) return 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 fail("Unsupported");
+		return this.addCondition({
+			kind,
+			value
+		});
+	}
+};
+/** Resolves polymorphic predicates to their physical component columns. */
+var PolyReferenceAlias = class {
+	meta;
+	mgmt;
+	field;
+	constructor(meta, mgmt, field) {
+		this.meta = meta;
+		this.mgmt = mgmt;
+		this.field = field;
+	}
+	eq(value) {
+		return this.addEqOrNe("eq", value);
+	}
+	ne(value) {
+		return this.addEqOrNe("ne", value);
+	}
+	in(values) {
+		if (values === void 0) return skipCondition;
+		const groups = groupBy(values, (id) => getConstructorFromTaggedId(maybeResolveReferenceToId(id)).name);
+		return { or: Object.entries(groups).map(([name, ids]) => {
+			const comp = this.field.components.find((c) => c.otherMetadata().cstr.name === name) ?? fail(`No component for ${name}`);
+			return this.component(comp).addCondition({
+				kind: "in",
+				value: ids
+			});
+		}) };
+	}
+	/** Picks the component from an entity, tagged id, or another domain alias column. */
+	addEqOrNe(kind, value) {
+		if (value === void 0) return 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 : getMetadata(getConstructorFromTaggedId(maybeResolveReferenceToId(value)));
+		const comp = this.field.components.find((c) => getBaseAndSelfMetas(otherMeta).includes(c.otherMetadata())) ?? 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) ?? fail("Missing column");
+		return new AliasColumnImpl(this.meta, this.field, column, this.mgmt);
+	}
+};
+/** 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) {
-    // Do we have mismatched `em.find(ChildMeta)` with a `alias(BaseMeta)`? If so, the
-    // usual `${field.aliasSuffix}` won't know it should have a suffix, so we need to calc it.
-    if (newMeta !== meta && newMeta.inheritanceType === "cti") {
-        const bases = (0, EntityMetadata_1.getBaseAndSelfMetas)(newMeta);
-        const fieldIsFromBase = bases.includes(newMeta);
-        if (fieldIsFromBase)
-            return `${newAlias}_b0`;
-    }
-    return `${newAlias}${field.aliasSuffix}`;
+	if (newMeta !== meta && newMeta.inheritanceType === "cti") {
+		if (getBaseAndSelfMetas(newMeta).includes(newMeta)) return `${newAlias}_b0`;
+	}
+	return `${newAlias}${field.aliasSuffix}`;
+}
+/** Compares domain columns with per-parse aliases, preserving condition reuse across find calls. */
+function crossColumnCondition(left, right, op, negate = false) {
+	return withDeferredAlias({
+		kind: "raw",
+		aliases: [],
+		condition: "unset",
+		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;
+	});
 }
+//#endregion
+export { alias, aliasMgmt, aliases, getAliasMetadata, getAliasMgmt, getMaybeCtiAlias, isAlias, newAliasProxy };
+
 //# sourceMappingURL=Aliases.js.map