@prisma/orm-family-sql 8.0.0-rc.12-dev.9 → 8.0.0-rc.12-dev.10

package/dist/orm-client.mjs

@@ -1,9 +1,9 @@
 import { t as resolveStorageTable } from "./resolve-storage-table-DZsfnzeW.mjs";
 import { i as isUniqueConstraintViolation } from "./dist-x6jvtkKM.mjs";
-import { C as LiteralExpr, D as OrExpr, F as SubqueryExpr, I as TableSource, L as UpdateAst, O as OrderByItem, P as SelectAst, R as WindowFuncExpr, S as ListExpression, T as NullCheckExpr, U as isWhereExpr, V as isAggregateFn, _ as InsertAst, b as JsonArrayAggExpr, c as DeleteAst, f as EqColJoinOn, j as ProjectionItem, k as ParamRef, l as DerivedTableSource, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, s as DefaultValueExpr, t as AggregateExpr, v as InsertOnConflict, w as NotExpr, x as JsonObjectExpr, y as JoinAst } from "./types-BAhLyUFj-3TARSz8c.mjs";
+import { C as LiteralExpr, D as OrExpr, F as SubqueryExpr, G as isWhereExpr, I as TableSource, L as UpdateAst, O as OrderByItem, P as SelectAst, R as WindowFuncExpr, S as ListExpression, T as NullCheckExpr, U as isOrderByNulls, V as isAggregateFn, _ as InsertAst, b as JsonArrayAggExpr, c as DeleteAst, f as EqColJoinOn, j as ProjectionItem, k as ParamRef, l as DerivedTableSource, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, s as DefaultValueExpr, t as AggregateExpr, v as InsertOnConflict, w as NotExpr, x as JsonObjectExpr, y as JoinAst } from "./types-BPi4d3WI-D8PIEqBU.mjs";
 import { t as collectOrderedParamRefs } from "./util-DQQgv2j1-D6INZaRG.mjs";
-import { n as JsonDocumentProjection, r as NativeJsonValueProjection, t as CodecJsonValueProjection } from "./ast--wLzFkbt.mjs";
-import { i as isExpression, o as toExpr } from "./expression-CrGD_4do.mjs";
+import { n as JsonDocumentProjection, r as NativeJsonValueProjection, t as CodecJsonValueProjection } from "./ast-Bhj549wG.mjs";
+import { i as isExpression, o as toExpr } from "./expression-vAEOvq7J.mjs";
 import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-ECZ4ohtG.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
@@ -589,6 +589,44 @@ function mapResultRows(result, mapper) {
 	};
 	return new AsyncIterableResult(generator());
 }
+/**
+* A keyset needs a cursor value for every order axis, so each active order must be a plain column without null placement.
+*/
+function assertCursorCompatibleOrder(orderBy) {
+	(orderBy ?? []).forEach((item, index) => {
+		const position = index + 1;
+		if (item.expr.kind !== "column-ref") throw ormError("ORM.ARGUMENT_INVALID", `cursor() cannot key on orderBy item ${position}: it orders by an expression rather than a column, and relation orders, relation counts and operation results are not cursorable. Order by the model's own columns to paginate with a cursor.`, { meta: {
+			method: "cursor",
+			position
+		} });
+		if (item.nulls !== void 0) throw ormError("ORM.ARGUMENT_INVALID", `cursor() cannot key on orderBy item ${position}: an order with nulls placement is not cursorable. Remove the nulls option to paginate with a cursor.`, { meta: {
+			method: "cursor",
+			position,
+			nulls: item.nulls
+		} });
+	});
+}
+/**
+* Postgres requires the leading `ORDER BY` items to match the `DISTINCT ON` expressions, so the first `distinctOnCount` items must be plain columns; later items only choose which row represents each group and may be any expression.
+*/
+function assertDistinctOnCompatibleOrder(orderBy, distinctOnCount) {
+	(orderBy ?? []).slice(0, distinctOnCount).forEach((item, index) => {
+		const position = index + 1;
+		if (item.expr.kind !== "column-ref") throw ormError("ORM.ARGUMENT_INVALID", `distinctOn() needs its ${distinctOnCount} column(s) as the first orderBy items, but orderBy item ${position} orders by an expression rather than a column. Put the distinctOn columns first; relation orders, relation counts and operation results may follow them.`, { meta: {
+			method: "distinctOn",
+			position,
+			distinctOnCount
+		} });
+	});
+}
+function checkedOrderByItem(dir, expr, options) {
+	const nulls = options?.nulls;
+	if (nulls !== void 0 && !isOrderByNulls(nulls)) throw ormError("ORM.ARGUMENT_INVALID", `${dir}() nulls must be "first" or "last"`, { meta: {
+		method: dir,
+		nulls: String(nulls)
+	} });
+	return new OrderByItem(expr, dir, nulls);
+}
 function deriveParamsFromAst(ast) {
 	return { params: collectOrderedParamRefs(ast).map((p) => p.kind === "param-ref" ? p.value : void 0) };
 }
@@ -753,7 +791,7 @@ function bindProjectionExpr(contract, expr) {
 	return expr.kind === "literal" ? expr : bindExpression(contract, expr);
 }
 function bindOrderByItem(contract, orderItem) {
-	return new OrderByItem(bindExpression(contract, orderItem.expr), orderItem.dir);
+	return orderItem.withExpr(bindExpression(contract, orderItem.expr));
 }
 function bindJoin(contract, join) {
 	const namespaceId = namespaceCoordinateForSource(join.source);
@@ -810,9 +848,10 @@ function buildLexicographicCursorWhere(tableName, entries) {
 }
 function buildCursorWhere(tableName, orderBy, cursor) {
 	if (!cursor || !orderBy || orderBy.length === 0) return;
+	assertCursorCompatibleOrder(orderBy);
 	const entries = [];
 	for (const order of orderBy) {
-		if (order.expr.kind !== "column-ref") continue;
+		if (order.expr.kind !== "column-ref") throw new InternalError("assertCursorCompatibleOrder admits only column orders");
 		const column = order.expr.column;
 		const value = cursor[column];
 		if (value === void 0) throw ormError("ORM.CURSOR_VALUE_MISSING", `Missing cursor value for orderBy column "${column}"`, { meta: { column } });
@@ -941,16 +980,34 @@ function hasEntries(value) {
 function buildAggregateInput(contract, namespaceId, tableName, state, modelName, projection) {
 	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
 	const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, namespaceId, polyInfo, state.variantName, void 0).joins : [];
-	const { source, where: effectiveWhere } = buildDedupedTableSource(contract, namespaceId, tableName, state, buildStateWhere(contract, tableName, state, { namespaceId }), projection, variantJoins);
+	const where = buildStateWhere(contract, tableName, state, { namespaceId });
+	const hiddenOrders = hasEntries(state.distinct) ? projectExpressionOrders(tableName, state.orderBy) : void 0;
+	const { source, where: effectiveWhere } = buildDedupedTableSource(contract, namespaceId, tableName, state, where, [...projection, ...hiddenOrders?.projection ?? []], variantJoins);
 	let inner = SelectAst.from(source).withProjection(projection);
 	if (!hasEntries(state.distinct) && variantJoins.length > 0) inner = inner.withJoins(variantJoins);
 	if (effectiveWhere) inner = inner.withWhere(effectiveWhere);
 	if (hasEntries(state.distinctOn)) inner = inner.withDistinctOn(state.distinctOn.map((column) => ColumnRef.of(tableName, column)));
-	if (hasEntries(state.orderBy)) inner = inner.withOrderBy(state.orderBy);
+	const orderBy = hiddenOrders?.orderBy ?? state.orderBy;
+	if (hasEntries(orderBy)) inner = inner.withOrderBy(orderBy);
 	if (state.limit !== void 0) inner = inner.withLimit(state.limit);
 	if (state.offset !== void 0) inner = inner.withOffset(state.offset);
 	return { source: DerivedTableSource.as(tableName, inner) };
 }
+/**
+* The dedup wrap exposes only its projection, so an order over an expression (a relation order, a count, an operation result) cannot be evaluated above it. Each such order is projected inside the wrap as a hidden `__order_N` column and the outer order reads that column.
+*/
+function projectExpressionOrders(tableName, orderBy) {
+	const projection = [];
+	return {
+		projection,
+		orderBy: (orderBy ?? []).map((item, index) => {
+			if (item.expr.kind === "column-ref") return item;
+			const alias = `__order_${index}`;
+			projection.push(ProjectionItem.of(alias, item.expr));
+			return item.withExpr(ColumnRef.of(tableName, alias));
+		})
+	};
+}
 function predicateComparison(op, left, right) {
 	const nullable = (right.kind === "list" ? [left, ...right.values] : [left, right]).find((operand) => operand.kind === "prepared-param-ref" && operand.nullable);
 	if (nullable?.kind !== "prepared-param-ref") return new BinaryExpr(op, left, right);
@@ -1045,11 +1102,11 @@ const COMPARISON_METHODS_META = {
 	},
 	asc: {
 		traits: ["order"],
-		create: (left) => () => OrderByItem.asc(left)
+		create: (left) => (options) => checkedOrderByItem("asc", left, options)
 	},
 	desc: {
 		traits: ["order"],
-		create: (left) => () => OrderByItem.desc(left)
+		create: (left) => (options) => checkedOrderByItem("desc", left, options)
 	},
 	isNull: {
 		traits: [],
@@ -1157,7 +1214,10 @@ function compileAggregate(contract, aggregates, namespaceId, tableName, state, a
 		namespaceId,
 		tableName
 	} });
-	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
+	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) {
+		assertDistinctOnCapability(contract, "distinctOn");
+		assertDistinctOnCompatibleOrder(state.orderBy, state.distinctOn.length);
+	}
 	const hasPagination = state.limit !== void 0 || state.offset !== void 0;
 	const hasDistinct = state.distinct !== void 0 && state.distinct.length > 0 || state.distinctOn !== void 0 && state.distinctOn.length > 0;
 	if (hasPagination || hasDistinct) {
@@ -1194,7 +1254,10 @@ function compileGroupedAggregate(contract, aggregates, namespaceId, tableName, p
 		namespaceId,
 		tableName
 	} });
-	if (preGroupState.distinctOn !== void 0 && preGroupState.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
+	if (preGroupState.distinctOn !== void 0 && preGroupState.distinctOn.length > 0) {
+		assertDistinctOnCapability(contract, "distinctOn");
+		assertDistinctOnCompatibleOrder(preGroupState.orderBy, preGroupState.distinctOn.length);
+	}
 	const projection = [...groupByColumns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column))), ...entries.map(([alias, selector]) => {
 		const { expr, codec } = toAggregateProjection(contract, aggregates, namespaceId, tableName, selector);
 		return ProjectionItem.of(alias, expr, codec);
@@ -1502,7 +1565,7 @@ function buildIncludeOrderArtifacts(relationName, rowAlias, childOrderBy) {
 		aggregateOrderBy: hiddenOrderProjection.map((projection, index) => {
 			const orderItem = childOrderBy[index];
 			if (!orderItem) throw new InternalError(`Missing include order metadata at index ${index}`);
-			return new OrderByItem(ColumnRef.of(rowAlias, projection.alias), orderItem.dir);
+			return orderItem.withExpr(ColumnRef.of(rowAlias, projection.alias));
 		})
 	};
 }
@@ -1648,7 +1711,10 @@ function buildManyToManyJunctionArtifacts(parentLocalRefs, childTableRef, throug
 }
 function buildIncludeChildRowsSelect(contract, aggregates, parentSource, include) {
 	const childState = include.nested;
-	if (childState.distinctOn !== void 0 && childState.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
+	if (childState.distinctOn !== void 0 && childState.distinctOn.length > 0) {
+		assertDistinctOnCapability(contract, "distinctOn");
+		assertDistinctOnCompatibleOrder(childState.orderBy, childState.distinctOn.length);
+	}
 	const parentLocalRefs = resolveParentLocalRefs(parentSource, include, localColumnsForRowInclude(include));
 	const childSource = resolveChildTableSource(include, parentLocalRefs);
 	const childTableAlias = childSource.alias;
@@ -1710,7 +1776,7 @@ function buildIncludeChildRowsSelect(contract, aggregates, parentSource, include
 			rankingOrderBy: childOrderBy ?? [],
 			rankedAlias
 		});
-		if (childOrderBy) childRows = childRows.withOrderBy(childOrderBy.map((item, index) => new OrderByItem(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`), item.dir)));
+		if (childOrderBy) childRows = childRows.withOrderBy(childOrderBy.map((item, index) => item.withExpr(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`))));
 	} else if (childOrderBy) childRows = childRows.withOrderBy(childOrderBy);
 	if (childState.limit !== void 0) childRows = childRows.withLimit(childState.limit);
 	if (childState.offset !== void 0) childRows = childRows.withOffset(childState.offset);
@@ -1754,7 +1820,7 @@ function buildDistinctNonLeafChildRowsSelect(options) {
 		rankingOrderBy: childOrderBy ?? [],
 		rankedAlias
 	});
-	if (childOrderBy) innerSelect = innerSelect.withOrderBy(childOrderBy.map((item, index) => new OrderByItem(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`), item.dir)));
+	if (childOrderBy) innerSelect = innerSelect.withOrderBy(childOrderBy.map((item, index) => item.withExpr(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`))));
 	if (childState.limit !== void 0) innerSelect = innerSelect.withLimit(childState.limit);
 	if (childState.offset !== void 0) innerSelect = innerSelect.withOffset(childState.offset);
 	const distinctAlias = `${include.relationName}__distinct`;
@@ -1821,7 +1887,10 @@ function buildIncludeChildScalarSelect(contract, aggregates, parentSource, inclu
 	const childTableAlias = childSource.alias;
 	const childTableRef = childSource.tableRef;
 	const state = scalar.state;
-	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
+	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) {
+		assertDistinctOnCapability(contract, "distinctOn");
+		assertDistinctOnCompatibleOrder(state.orderBy, state.distinctOn.length);
+	}
 	const childWhere = buildStateWhere(contract, childTableRef, state, {
 		filterTableName: include.relatedTableName,
 		namespaceId: include.relatedNamespaceId
@@ -1862,7 +1931,7 @@ function buildIncludeChildScalarSelect(contract, aggregates, parentSource, inclu
 			rankingOrderBy: remappedOrderBy ?? [],
 			rankedAlias
 		});
-		if (remappedOrderBy !== void 0 && remappedOrderBy.length > 0) inner = inner.withOrderBy(remappedOrderBy.map((item, index) => new OrderByItem(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`), item.dir)));
+		if (remappedOrderBy !== void 0 && remappedOrderBy.length > 0) inner = inner.withOrderBy(remappedOrderBy.map((item, index) => item.withExpr(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`))));
 	} else if (remappedOrderBy !== void 0 && remappedOrderBy.length > 0) inner = inner.withOrderBy(remappedOrderBy);
 	if (state.limit !== void 0) inner = inner.withLimit(state.limit);
 	if (state.offset !== void 0) inner = inner.withOffset(state.offset);
@@ -1954,7 +2023,10 @@ function buildCorrelatedIncludeProjection(contract, aggregates, parentSource, in
 }
 function buildSelectAst(contract, tableName, state, options) {
 	const namespaceId = options.namespaceId;
-	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
+	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) {
+		assertDistinctOnCapability(contract, "distinctOn");
+		assertDistinctOnCompatibleOrder(state.orderBy, state.distinctOn.length);
+	}
 	const projection = [...buildProjection(contract, namespaceId, tableName, state.selectedFields, tableName), ...options.includeProjection ?? []];
 	const { source: fromSource, where: effectiveWhere } = buildDedupedTableSource(contract, namespaceId, tableName, state, options.where ?? buildStateWhere(contract, tableName, state, { namespaceId }), resolveTableColumns(contract, namespaceId, tableName).map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column))));
 	let ast = SelectAst.from(fromSource).withProjection(projection);
@@ -2855,41 +2927,82 @@ function createExtensionMethodFactory(selfExpr, entry, context) {
 		return methods;
 	};
 }
+const RELATION_ACCESSOR_METHOD_NAMES = /* @__PURE__ */ new Set([
+	"some",
+	"every",
+	"none",
+	"count"
+]);
 function createRelationFilterAccessor(context, parentNamespaceId, parentModelName, parentScope, relation) {
 	const relatedTableName = resolveModelTableName(context.contract, relation.toNamespace, relation.to);
+	const correlate = () => correlateRelatedRows(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation);
+	const filters = {
+		some: (predicate) => buildExistsExpr(context, relation, correlate(), "some", predicate),
+		every: (predicate) => buildExistsExpr(context, relation, correlate(), "every", predicate),
+		none: (predicate) => buildExistsExpr(context, relation, correlate(), "none", predicate)
+	};
+	if (isToOneCardinality(relation.cardinality)) return new Proxy(filters, { get(target, prop) {
+		if (typeof prop !== "string") return void 0;
+		if (Object.hasOwn(target, prop)) return Reflect.get(target, prop);
+		if (RELATION_ACCESSOR_METHOD_NAMES.has(prop)) return void 0;
+		return relatedOrderableField(context, relation, relatedTableName, correlate, prop);
+	} });
 	return {
-		some: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, {
-			mode: "some",
-			predicate
-		}),
-		every: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, {
-			mode: "every",
-			predicate
-		}),
-		none: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, {
-			mode: "none",
-			predicate
-		})
+		...filters,
+		count: (predicate) => createOrderable(() => buildRelationCountExpr(context, relation, correlate(), predicate))
 	};
 }
-function buildExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, options) {
-	if (hasThrough$1(relation)) return buildManyToManyExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, options);
+function createOrderable(buildExpr) {
+	return {
+		asc: (options) => checkedOrderByItem("asc", buildExpr(), options),
+		desc: (options) => checkedOrderByItem("desc", buildExpr(), options)
+	};
+}
+function relatedOrderableField(context, relation, relatedTableName, correlate, fieldName) {
+	const fieldToColumn = getFieldToColumnMap(context.contract, relation.toNamespace, relation.to);
+	if (!Object.hasOwn(fieldToColumn, fieldName)) return void 0;
+	const columnName = fieldToColumn[fieldName];
+	if (columnName === void 0) return void 0;
+	const column = resolveColumn(context.contract, relation.toNamespace, relatedTableName, columnName);
+	if (!column || !hasTrait(context, column.codecId, "order")) return void 0;
+	return createOrderable(() => {
+		const rows = correlate();
+		return SubqueryExpr.of(rows.source.withProjection([ProjectionItem.of(columnName, rows.childScope.current.column(columnName))]).withWhere(rows.correlation));
+	});
+}
+function hasTrait(context, codecId, trait) {
+	return (context.codecDescriptors.descriptorFor(codecId)?.traits ?? []).includes(trait);
+}
+function buildRelationCountExpr(context, relation, rows, predicate) {
+	const childWhere = toRelationWhereExpr(context, relation.toNamespace, relation.to, predicate, rows.childScope);
+	return SubqueryExpr.of(rows.source.withProjection([ProjectionItem.of("count", plainAggregateExpr("count", void 0))]).withWhere(childWhere ? and(rows.correlation, childWhere) : rows.correlation));
+}
+function correlateRelatedRows(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation) {
+	if (hasThrough$1(relation)) {
+		const { through } = relation;
+		const { childScope, junctionBinding } = parentScope.forManyToManyRelation(relation.toNamespace, relatedTableName, through.namespaceId, through.table);
+		const junctionJoinOn = buildPairedColumnExprs(junctionBinding, through.childColumns, childScope.current, through.targetColumns);
+		const parentLocalColumns = relation.on.localFields.map((field) => resolveFieldToColumn(context.contract, parentNamespaceId, parentModelName, field));
+		return {
+			childScope,
+			source: SelectAst.from(childScope.current.tableSource(context.contract)).withJoins([JoinAst.inner(junctionBinding.tableSource(context.contract), junctionJoinOn)]),
+			correlation: buildPairedColumnExprs(junctionBinding, through.parentColumns, parentScope.current, parentLocalColumns),
+			keyColumn: firstJoinColumn(through.targetColumns, "targetColumns")
+		};
+	}
 	const childScope = parentScope.forRelation(relation.toNamespace, relatedTableName);
-	const filterPlan = planRelationFilterMode(buildJoinWhere(context.contract, parentNamespaceId, parentModelName, parentScope.current, childScope.current, relation), toRelationWhereExpr(context, relation.toNamespace, relation.to, options.predicate, childScope), options.mode);
-	if (filterPlan.kind === "constantTrue") return AndExpr.true();
-	const selectProjectionColumn = firstTargetColumn(context.contract, relation) ?? "id";
-	const subquery = SelectAst.from(childScope.current.tableSource(context.contract)).withProjection([ProjectionItem.of("_exists", childScope.current.column(selectProjectionColumn))]).withWhere(filterPlan.where);
-	return filterPlan.notExists ? ExistsExpr.notExists(subquery) : ExistsExpr.exists(subquery);
+	return {
+		childScope,
+		source: SelectAst.from(childScope.current.tableSource(context.contract)),
+		correlation: buildJoinWhere(context.contract, parentNamespaceId, parentModelName, parentScope.current, childScope.current, relation),
+		keyColumn: firstTargetColumn(context.contract, relation) ?? "id"
+	};
 }
-function buildManyToManyExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, options) {
-	const { through } = relation;
-	const { childScope, junctionBinding } = parentScope.forManyToManyRelation(relation.toNamespace, relatedTableName, through.namespaceId, through.table);
-	const junctionJoinOn = buildPairedColumnExprs(junctionBinding, through.childColumns, childScope.current, through.targetColumns);
-	const parentLocalColumns = relation.on.localFields.map((field) => resolveFieldToColumn(context.contract, parentNamespaceId, parentModelName, field));
-	const filterPlan = planRelationFilterMode(buildPairedColumnExprs(junctionBinding, through.parentColumns, parentScope.current, parentLocalColumns), toRelationWhereExpr(context, relation.toNamespace, relation.to, options.predicate, childScope), options.mode);
+function buildExistsExpr(context, relation, rows, mode, predicate) {
+	const childWhere = toRelationWhereExpr(context, relation.toNamespace, relation.to, predicate, rows.childScope);
+	const filterPlan = planRelationFilterMode(rows.correlation, childWhere, mode);
 	if (filterPlan.kind === "constantTrue") return AndExpr.true();
-	const firstTargetCol = firstJoinColumn(through.targetColumns, "targetColumns");
-	const subquery = SelectAst.from(childScope.current.tableSource(context.contract)).withJoins([JoinAst.inner(junctionBinding.tableSource(context.contract), junctionJoinOn)]).withProjection([ProjectionItem.of("_exists", childScope.current.column(firstTargetCol))]).withWhere(filterPlan.where);
+	const subquery = rows.source.withProjection([ProjectionItem.of("_exists", rows.childScope.current.column(rows.keyColumn))]).withWhere(filterPlan.where);
 	return filterPlan.notExists ? ExistsExpr.notExists(subquery) : ExistsExpr.exists(subquery);
 }
 function planRelationFilterMode(joinWhere, childWhere, mode) {
@@ -4068,6 +4181,7 @@ var CollectionImpl = class CollectionImpl {
 	* ```
 	*/
 	cursor(cursorValues) {
+		assertCursorCompatibleOrder(this.state.orderBy);
 		const mappedCursor = mapCursorValuesToColumns(this.contract, this.namespaceId, this.modelName, cursorValues);
 		if (Object.keys(mappedCursor).length === 0) return blindCast(this);
 		return this.#clone({ cursor: mappedCursor });
@@ -4105,6 +4219,7 @@ var CollectionImpl = class CollectionImpl {
 	*/
 	distinctOn(...fields) {
 		assertDistinctOnCapability(this.contract, "distinctOn");
+		assertDistinctOnCompatibleOrder(this.state.orderBy, fields.length);
 		const distinctOnFields = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
 		return this.#clone({
 			distinct: void 0,