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

package/dist/orm-client.mjs

@@ -346,6 +346,13 @@ function assertReturningCapability(contract, action) {
 		action
 	} });
 }
+function assertDistinctOnCapability(contract, methodName) {
+	if (contract.capabilities["postgres"]?.["distinctOn"] === true) return;
+	throw ormError("ORM.CAPABILITY_MISSING", `${methodName}() requires capability postgres.distinctOn`, { meta: {
+		capability: "postgres.distinctOn",
+		method: methodName
+	} });
+}
 function hasContractCapability(contract, capability) {
 	const capabilities = contract.capabilities;
 	const value = capabilities[capability];
@@ -611,11 +618,298 @@ function mergeAnnotations(plan, annotations) {
 		})
 	});
 }
+function namespaceCoordinateForSource(source) {
+	return source.kind === "table-source" ? source.namespaceId : void 0;
+}
+function bindWhereExpr(contract, expr, namespaceId) {
+	return bindWhereExprNode(contract, expr, namespaceId);
+}
+function bindWhereExprNode(contract, expr, namespaceId) {
+	return expr.accept({
+		columnRef(expr) {
+			return bindExpression(contract, expr);
+		},
+		identifierRef(expr) {
+			return expr;
+		},
+		subquery(expr) {
+			return bindExpression(contract, expr);
+		},
+		operation(expr) {
+			return bindExpression(contract, expr);
+		},
+		aggregate(expr) {
+			return bindExpression(contract, expr);
+		},
+		windowFunc(expr) {
+			return bindExpression(contract, expr);
+		},
+		functionCall(expr) {
+			return bindExpression(contract, expr);
+		},
+		cast(expr) {
+			return bindExpression(contract, expr);
+		},
+		case(expr) {
+			return bindExpression(contract, expr);
+		},
+		jsonObject(expr) {
+			return bindExpression(contract, expr);
+		},
+		jsonArrayAgg(expr) {
+			return bindExpression(contract, expr);
+		},
+		literal(expr) {
+			return expr;
+		},
+		param(expr) {
+			return expr;
+		},
+		preparedParam(expr) {
+			return expr;
+		},
+		list(expr) {
+			return bindExpression(contract, expr);
+		},
+		binary(expr) {
+			const left = bindExpression(contract, expr.left);
+			const bindingColumn = left.kind === "column-ref" ? left : void 0;
+			return new BinaryExpr(expr.op, left, bindComparable(contract, expr.right, bindingColumn, namespaceId));
+		},
+		and(expr) {
+			return AndExpr.of(expr.exprs.map((part) => bindWhereExprNode(contract, part, namespaceId)));
+		},
+		or(expr) {
+			return OrExpr.of(expr.exprs.map((part) => bindWhereExprNode(contract, part, namespaceId)));
+		},
+		exists(expr) {
+			return expr.notExists ? ExistsExpr.notExists(bindSelectAst(contract, expr.subquery)) : ExistsExpr.exists(bindSelectAst(contract, expr.subquery));
+		},
+		nullCheck(expr) {
+			return expr.isNull ? NullCheckExpr.isNull(bindExpression(contract, expr.expr)) : NullCheckExpr.isNotNull(bindExpression(contract, expr.expr));
+		},
+		not(expr) {
+			return new NotExpr(bindWhereExprNode(contract, expr.expr, namespaceId));
+		},
+		rawExpr(expr) {
+			return expr;
+		}
+	});
+}
+function bindComparable(contract, comparable, bindingColumn, namespaceId) {
+	if (comparable.kind === "param-ref" || bindingColumn === void 0) return comparable.kind === "param-ref" ? comparable : comparable.kind === "literal" || comparable.kind === "list" ? comparable : bindExpression(contract, comparable);
+	if (comparable.kind === "literal") return createParamRef(contract, bindingColumn, comparable.value, namespaceId);
+	if (comparable.kind === "list") return ListExpression.of(comparable.values.map((value) => value.kind === "literal" ? createParamRef(contract, bindingColumn, value.value, namespaceId) : value));
+	return bindExpression(contract, comparable);
+}
+function createParamRef(contract, columnRef, value, namespaceId) {
+	const resolved = resolveStorageTable(contract.storage, columnRef.table, namespaceId);
+	if (resolved === void 0 || !resolved.table.columns[columnRef.column]) throw ormError("ORM.COLUMN_UNKNOWN", `Unknown column "${columnRef.column}" in table "${columnRef.table}"`, { meta: {
+		tableName: columnRef.table,
+		column: columnRef.column
+	} });
+	const codec = codecRefForStorageColumn(contract.storage, resolved.namespaceId, columnRef.table, columnRef.column);
+	return ParamRef.of(value, codec ? { codec } : void 0);
+}
+function createExpressionBinder(contract) {
+	return { select: (ast) => bindSelectAst(contract, ast) };
+}
+function bindExpression(contract, expr) {
+	return expr.rewrite(createExpressionBinder(contract));
+}
+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);
+}
+function bindJoin(contract, join) {
+	const namespaceId = namespaceCoordinateForSource(join.source);
+	return new JoinAst(join.joinType, bindFromSource(contract, join.source), join.on.kind === "eq-col-join-on" ? join.on : bindWhereExprNode(contract, join.on, namespaceId), join.lateral);
+}
+function bindFromSource(contract, source) {
+	if (source.kind === "table-source") return source;
+	if (source.kind === "derived-table-source") return DerivedTableSource.as(source.alias, bindSelectAst(contract, source.query));
+	return source;
+}
+function bindSelectAst(contract, ast) {
+	const namespaceId = ast.from !== void 0 ? namespaceCoordinateForSource(ast.from) : void 0;
+	return new SelectAst({
+		...ast.from !== void 0 ? { from: bindFromSource(contract, ast.from) } : {},
+		joins: ast.joins?.map((join) => bindJoin(contract, join)),
+		projection: ast.projection.map((projection) => new ProjectionItem(projection.alias, bindProjectionExpr(contract, projection.expr), projection.codec)),
+		where: ast.where ? bindWhereExprNode(contract, ast.where, namespaceId) : void 0,
+		orderBy: ast.orderBy?.map((orderItem) => bindOrderByItem(contract, orderItem)),
+		distinct: ast.distinct,
+		distinctOn: ast.distinctOn?.map((expr) => bindExpression(contract, expr)),
+		groupBy: ast.groupBy?.map((expr) => bindExpression(contract, expr)),
+		having: ast.having ? bindWhereExprNode(contract, ast.having, namespaceId) : void 0,
+		limit: ast.limit,
+		offset: ast.offset,
+		selectAllIntent: ast.selectAllIntent
+	});
+}
 function combineWhereExprs(filters) {
 	if (filters.length === 0) return;
 	if (filters.length === 1) return filters[0];
 	return AndExpr.of(filters);
 }
+function createBoundaryExpr(tableName, entry) {
+	return new BinaryExpr(entry.direction === "asc" ? "gt" : "lt", ColumnRef.of(tableName, entry.column), LiteralExpr.of(entry.value));
+}
+function buildLexicographicCursorWhere(tableName, entries) {
+	const branches = entries.map((entry, index) => {
+		const branchExprs = [];
+		for (const prefixEntry of entries.slice(0, index)) branchExprs.push(BinaryExpr.eq(ColumnRef.of(tableName, prefixEntry.column), LiteralExpr.of(prefixEntry.value)));
+		branchExprs.push(createBoundaryExpr(tableName, entry));
+		if (branchExprs.length === 1) {
+			const branch = branchExprs[0];
+			assertDefined(branch, "cursor branch contains its boundary expression");
+			return branch;
+		}
+		return AndExpr.of(branchExprs);
+	});
+	if (branches.length === 1) {
+		const branch = branches[0];
+		assertDefined(branch, "cursor expression contains its single branch");
+		return branch;
+	}
+	return OrExpr.of(branches);
+}
+function buildCursorWhere(tableName, orderBy, cursor) {
+	if (!cursor || !orderBy || orderBy.length === 0) return;
+	const entries = [];
+	for (const order of orderBy) {
+		if (order.expr.kind !== "column-ref") continue;
+		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 } });
+		entries.push({
+			column,
+			direction: order.dir,
+			value
+		});
+	}
+	const firstEntry = entries[0];
+	if (entries.length === 1 && firstEntry !== void 0) return createBoundaryExpr(tableName, firstEntry);
+	return buildLexicographicCursorWhere(tableName, entries);
+}
+function createTableRefRemapper$1(fromTable, toTable) {
+	return {
+		columnRef: (col) => col.table === fromTable ? ColumnRef.of(toTable, col.column) : col,
+		tableSource: (source) => {
+			if (source.alias === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
+			if (!source.alias && source.name === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
+			return source;
+		},
+		eqColJoinOn: (on) => EqColJoinOn.of(on.left.table === fromTable ? ColumnRef.of(toTable, on.left.column) : on.left, on.right.table === fromTable ? ColumnRef.of(toTable, on.right.column) : on.right)
+	};
+}
+function buildStateWhere(contract, tableName, state, options) {
+	const filterTableName = options?.filterTableName;
+	const cursorWhere = buildCursorWhere(filterTableName ?? tableName, state.orderBy, state.cursor);
+	const boundFilters = state.filters.map((filter) => bindWhereExpr(contract, filter, options?.namespaceId));
+	const remappedFilters = filterTableName && filterTableName !== tableName ? boundFilters.map((filter) => filter.rewrite(createTableRefRemapper$1(filterTableName, tableName))) : boundFilters;
+	const boundCursorWhere = cursorWhere ? bindWhereExpr(contract, cursorWhere, options?.namespaceId) : void 0;
+	const remappedCursorWhere = boundCursorWhere && filterTableName && filterTableName !== tableName ? boundCursorWhere.rewrite(createTableRefRemapper$1(filterTableName, tableName)) : boundCursorWhere;
+	return combineWhereExprs(remappedCursorWhere ? [...remappedFilters, remappedCursorWhere] : remappedFilters);
+}
+/**
+* Wrap a base SELECT in a `ROW_NUMBER() OVER (PARTITION BY … ORDER BY …) = 1`
+* filter, implementing Prisma-style `.distinct(cols)` semantics: one
+* representative row per `(distinctColumnRefs)` group is kept; the rest
+* are dropped.
+*
+* Picking which row survives in each partition is governed by
+* `rankingOrderBy`. When the caller's `orderBy` doesn't fully order rows
+* within a partition (e.g. user wrote `.distinct('title')` with no
+* `orderBy`, or ties in their ordering), the choice is
+* implementation-defined — matching Prisma's documented nested-distinct
+* behaviour. Callers that want determinism should pass an `orderBy` that
+* is total within each partition.
+*
+* The wrapper forwards every column of `base.projection` through the
+* derived alias, so the wrapper's projection is byte-identical in alias
+* names — making this transparent to any outer query (`json_agg`,
+* correlated subquery, top-level SELECT) that consumes the SELECT.
+*/
+function wrapWithRowNumberDedup(options) {
+	const { base, distinctColumnRefs, rankingOrderBy, rankedAlias } = options;
+	const rnAlias = "__prisma_distinct_rn";
+	const effectiveOrderBy = rankingOrderBy.length > 0 ? rankingOrderBy : distinctColumnRefs.map((expr) => OrderByItem.asc(expr));
+	const inner = base.withProjection([...base.projection, ProjectionItem.of(rnAlias, WindowFuncExpr.rowNumber({
+		partitionBy: distinctColumnRefs,
+		orderBy: effectiveOrderBy
+	}))]);
+	return SelectAst.from(DerivedTableSource.as(rankedAlias, inner)).withProjection(base.projection.map((item) => ProjectionItem.of(item.alias, ColumnRef.of(rankedAlias, item.alias), item.codec))).withWhere(BinaryExpr.eq(ColumnRef.of(rankedAlias, rnAlias), LiteralExpr.of(1)));
+}
+/**
+* FROM source + WHERE for `state.distinct`: wraps in a `ROW_NUMBER`-ranked
+* derived table aliased back to `tableName`, so callers need no rewriting.
+*/
+function buildDedupedTableSource(contract, namespaceId, tableName, state, where, wrapProjection, joins) {
+	if (!hasEntries(state.distinct)) return {
+		source: tableSourceForContract(contract, namespaceId, tableName),
+		where
+	};
+	const distinctColumnRefs = state.distinct.map((column) => ColumnRef.of(tableName, column));
+	const rankingOrderBy = hasEntries(state.orderBy) ? state.orderBy : distinctColumnRefs.map((expr) => OrderByItem.asc(expr));
+	let inner = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection([...wrapProjection, ProjectionItem.of("__prisma_distinct_rn", WindowFuncExpr.rowNumber({
+		partitionBy: distinctColumnRefs,
+		orderBy: rankingOrderBy
+	}))]);
+	if (joins && joins.length > 0) inner = inner.withJoins(joins);
+	if (where) inner = inner.withWhere(where);
+	return {
+		source: DerivedTableSource.as(tableName, inner),
+		where: BinaryExpr.eq(ColumnRef.of(tableName, "__prisma_distinct_rn"), LiteralExpr.of(1))
+	};
+}
+function buildMtiJoins(contract, namespaceId, polyInfo, variantName, selectedColumnsByTable) {
+	const joins = [];
+	const projection = [];
+	const pkColumn = resolvePrimaryKeyColumn(contract, namespaceId, polyInfo.baseTable);
+	const variantsToJoin = variantName ? polyInfo.mtiVariants.filter((v) => v.modelName === variantName) : polyInfo.mtiVariants;
+	for (const variant of variantsToJoin) {
+		const joinType = variantName ? "inner" : "left";
+		const joinOn = EqColJoinOn.of(ColumnRef.of(polyInfo.baseTable, pkColumn), ColumnRef.of(variant.table, pkColumn));
+		const join = joinType === "inner" ? JoinAst.inner(tableSourceForContract(contract, namespaceId, variant.table), joinOn) : JoinAst.left(tableSourceForContract(contract, namespaceId, variant.table), joinOn);
+		joins.push(join);
+		const variantColumns = resolveTableColumns(contract, namespaceId, variant.table);
+		const selectedVariantColumns = selectedColumnsByTable?.get(variant.table);
+		for (const col of variantColumns) {
+			if (col === pkColumn) continue;
+			if (selectedColumnsByTable !== void 0 && selectedVariantColumns?.has(col) !== true) continue;
+			const alias = `${variant.table}__${col}`;
+			projection.push(ProjectionItem.of(alias, ColumnRef.of(variant.table, col), codecRefForStorageColumn(contract.storage, namespaceId, variant.table, col)));
+		}
+	}
+	return {
+		joins,
+		projection
+	};
+}
+function hasEntries(value) {
+	return value !== void 0 && value.length > 0;
+}
+/**
+* The rows an aggregate reduces over, one SELECT aliased to `tableName` — an
+* aggregate has no outer level of its own, so where/joins/distinct/orderBy/
+* limit/offset all have to live in this one wrap.
+*/
+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);
+	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);
+	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) };
+}
 function toAggregateProjection(contract, aggregates, namespaceId, tableName, selector) {
 	const { codec, input: inputCodec, lower } = resolveAggregate({
 		aggregates,
@@ -698,19 +992,42 @@ function validateGroupedHavingExpr(expr) {
 		rawExpr: rejectHavingExpr
 	});
 }
-function compileAggregate(contract, aggregates, namespaceId, tableName, filters, aggregateSpec) {
+function aggregateInputColumns(tableName, entries, orderBy) {
+	const columns = /* @__PURE__ */ new Set();
+	for (const [, selector] of entries) if (selector.column !== void 0) columns.add(selector.column);
+	for (const item of orderBy ?? []) if (item.expr.kind === "column-ref") columns.add(item.expr.column);
+	if (columns.size === 0) return [ProjectionItem.of("__row", LiteralExpr.of(1))];
+	return Array.from(columns, (column) => ProjectionItem.of(column, ColumnRef.of(tableName, column)));
+}
+function compileAggregate(contract, aggregates, namespaceId, tableName, state, aggregateSpec, modelName) {
 	const entries = Object.entries(aggregateSpec);
 	if (entries.length === 0) throw ormError("ORM.AGGREGATE_SELECTOR_MISSING", "aggregate() requires at least one aggregation selector", { meta: {
 		method: "aggregate",
 		namespaceId,
 		tableName
 	} });
+	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
+	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) {
+		const { source } = buildAggregateInput(contract, namespaceId, tableName, state, modelName, aggregateInputColumns(tableName, entries, state.orderBy));
+		const projection = entries.map(([alias, selector]) => {
+			const { expr, codec } = toAggregateProjection(contract, aggregates, namespaceId, tableName, selector);
+			return ProjectionItem.of(alias, expr, codec);
+		});
+		const ast = SelectAst.from(source).withProjection(projection);
+		const { params } = deriveParamsFromAst(ast);
+		return buildOrmQueryPlan(contract, ast, params);
+	}
+	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 where = buildStateWhere(contract, tableName, state, { namespaceId });
 	const projection = entries.map(([alias, selector]) => {
 		const { expr, codec } = toAggregateProjection(contract, aggregates, namespaceId, tableName, selector);
 		return ProjectionItem.of(alias, expr, codec);
 	});
 	let ast = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection(projection);
-	const where = combineWhereExprs(filters);
+	if (variantJoins.length > 0) ast = ast.withJoins(variantJoins);
 	if (where) ast = ast.withWhere(where);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
@@ -806,7 +1123,7 @@ function stripUndefinedValues(row) {
 	for (const [key, value] of Object.entries(row)) if (value !== void 0) result[key] = value;
 	return result;
 }
-function createTableRefRemapper$1(fromTable, toTable) {
+function createTableRefRemapper(fromTable, toTable) {
 	return {
 		columnRef: (col) => col.table === fromTable ? ColumnRef.of(toTable, col.column) : col,
 		tableSource: (source) => {
@@ -824,7 +1141,7 @@ function buildCountMutationWhere(contract, namespaceId, tableName, filters, vari
 	if (!polyInfo || !variant || variant.strategy !== "mti") return combineWhereExprs(filters);
 	const pkColumn = resolvePrimaryKeyColumn(contract, namespaceId, tableName);
 	const baseTableRef = `${tableName}__write_filter`;
-	const remapper = createTableRefRemapper$1(tableName, baseTableRef);
+	const remapper = createTableRefRemapper(tableName, baseTableRef);
 	const innerFilters = filters.map((filter) => filter.rewrite(remapper));
 	const where = combineWhereExprs([BinaryExpr.eq(ColumnRef.of(baseTableRef, pkColumn), ColumnRef.of(tableName, pkColumn)), ...innerFilters]);
 	const joinOn = EqColJoinOn.of(ColumnRef.of(baseTableRef, pkColumn), ColumnRef.of(variant.table, pkColumn));
@@ -917,137 +1234,6 @@ function augmentSelectionForJoinColumns(selectedFields, requiredColumns) {
 		hiddenColumns
 	};
 }
-function namespaceCoordinateForSource(source) {
-	return source.kind === "table-source" ? source.namespaceId : void 0;
-}
-function bindWhereExpr(contract, expr, namespaceId) {
-	return bindWhereExprNode(contract, expr, namespaceId);
-}
-function bindWhereExprNode(contract, expr, namespaceId) {
-	return expr.accept({
-		columnRef(expr) {
-			return bindExpression(contract, expr);
-		},
-		identifierRef(expr) {
-			return expr;
-		},
-		subquery(expr) {
-			return bindExpression(contract, expr);
-		},
-		operation(expr) {
-			return bindExpression(contract, expr);
-		},
-		aggregate(expr) {
-			return bindExpression(contract, expr);
-		},
-		windowFunc(expr) {
-			return bindExpression(contract, expr);
-		},
-		functionCall(expr) {
-			return bindExpression(contract, expr);
-		},
-		cast(expr) {
-			return bindExpression(contract, expr);
-		},
-		case(expr) {
-			return bindExpression(contract, expr);
-		},
-		jsonObject(expr) {
-			return bindExpression(contract, expr);
-		},
-		jsonArrayAgg(expr) {
-			return bindExpression(contract, expr);
-		},
-		literal(expr) {
-			return expr;
-		},
-		param(expr) {
-			return expr;
-		},
-		preparedParam(expr) {
-			return expr;
-		},
-		list(expr) {
-			return bindExpression(contract, expr);
-		},
-		binary(expr) {
-			const left = bindExpression(contract, expr.left);
-			const bindingColumn = left.kind === "column-ref" ? left : void 0;
-			return new BinaryExpr(expr.op, left, bindComparable(contract, expr.right, bindingColumn, namespaceId));
-		},
-		and(expr) {
-			return AndExpr.of(expr.exprs.map((part) => bindWhereExprNode(contract, part, namespaceId)));
-		},
-		or(expr) {
-			return OrExpr.of(expr.exprs.map((part) => bindWhereExprNode(contract, part, namespaceId)));
-		},
-		exists(expr) {
-			return expr.notExists ? ExistsExpr.notExists(bindSelectAst(contract, expr.subquery)) : ExistsExpr.exists(bindSelectAst(contract, expr.subquery));
-		},
-		nullCheck(expr) {
-			return expr.isNull ? NullCheckExpr.isNull(bindExpression(contract, expr.expr)) : NullCheckExpr.isNotNull(bindExpression(contract, expr.expr));
-		},
-		not(expr) {
-			return new NotExpr(bindWhereExprNode(contract, expr.expr, namespaceId));
-		},
-		rawExpr(expr) {
-			return expr;
-		}
-	});
-}
-function bindComparable(contract, comparable, bindingColumn, namespaceId) {
-	if (comparable.kind === "param-ref" || bindingColumn === void 0) return comparable.kind === "param-ref" ? comparable : comparable.kind === "literal" || comparable.kind === "list" ? comparable : bindExpression(contract, comparable);
-	if (comparable.kind === "literal") return createParamRef(contract, bindingColumn, comparable.value, namespaceId);
-	if (comparable.kind === "list") return ListExpression.of(comparable.values.map((value) => value.kind === "literal" ? createParamRef(contract, bindingColumn, value.value, namespaceId) : value));
-	return bindExpression(contract, comparable);
-}
-function createParamRef(contract, columnRef, value, namespaceId) {
-	const resolved = resolveStorageTable(contract.storage, columnRef.table, namespaceId);
-	if (resolved === void 0 || !resolved.table.columns[columnRef.column]) throw ormError("ORM.COLUMN_UNKNOWN", `Unknown column "${columnRef.column}" in table "${columnRef.table}"`, { meta: {
-		tableName: columnRef.table,
-		column: columnRef.column
-	} });
-	const codec = codecRefForStorageColumn(contract.storage, resolved.namespaceId, columnRef.table, columnRef.column);
-	return ParamRef.of(value, codec ? { codec } : void 0);
-}
-function createExpressionBinder(contract) {
-	return { select: (ast) => bindSelectAst(contract, ast) };
-}
-function bindExpression(contract, expr) {
-	return expr.rewrite(createExpressionBinder(contract));
-}
-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);
-}
-function bindJoin(contract, join) {
-	const namespaceId = namespaceCoordinateForSource(join.source);
-	return new JoinAst(join.joinType, bindFromSource(contract, join.source), join.on.kind === "eq-col-join-on" ? join.on : bindWhereExprNode(contract, join.on, namespaceId), join.lateral);
-}
-function bindFromSource(contract, source) {
-	if (source.kind === "table-source") return source;
-	if (source.kind === "derived-table-source") return DerivedTableSource.as(source.alias, bindSelectAst(contract, source.query));
-	return source;
-}
-function bindSelectAst(contract, ast) {
-	const namespaceId = ast.from !== void 0 ? namespaceCoordinateForSource(ast.from) : void 0;
-	return new SelectAst({
-		...ast.from !== void 0 ? { from: bindFromSource(contract, ast.from) } : {},
-		joins: ast.joins?.map((join) => bindJoin(contract, join)),
-		projection: ast.projection.map((projection) => new ProjectionItem(projection.alias, bindProjectionExpr(contract, projection.expr), projection.codec)),
-		where: ast.where ? bindWhereExprNode(contract, ast.where, namespaceId) : void 0,
-		orderBy: ast.orderBy?.map((orderItem) => bindOrderByItem(contract, orderItem)),
-		distinct: ast.distinct,
-		distinctOn: ast.distinctOn?.map((expr) => bindExpression(contract, expr)),
-		groupBy: ast.groupBy?.map((expr) => bindExpression(contract, expr)),
-		having: ast.having ? bindWhereExprNode(contract, ast.having, namespaceId) : void 0,
-		limit: ast.limit,
-		offset: ast.offset,
-		selectAllIntent: ast.selectAllIntent
-	});
-}
 /**
 * The rule for which JSON projection variant an include entry carries. Every
 * site that puts a value into a `json_build_object` or a `json_agg` goes
@@ -1131,66 +1317,6 @@ function buildHiddenDiscriminatorProjection(contract, namespaceId, polyInfo, tab
 	if (!needed) return [];
 	return [ProjectionItem.of(POLYMORPHIC_DISCRIMINATOR_ALIAS, ColumnRef.of(tableRef, polyInfo.discriminatorColumn), codecRefForStorageColumn(contract.storage, namespaceId, polyInfo.baseTable, polyInfo.discriminatorColumn))];
 }
-function createBoundaryExpr(tableName, entry) {
-	return new BinaryExpr(entry.direction === "asc" ? "gt" : "lt", ColumnRef.of(tableName, entry.column), LiteralExpr.of(entry.value));
-}
-function buildLexicographicCursorWhere(tableName, entries) {
-	const branches = entries.map((entry, index) => {
-		const branchExprs = [];
-		for (const prefixEntry of entries.slice(0, index)) branchExprs.push(BinaryExpr.eq(ColumnRef.of(tableName, prefixEntry.column), LiteralExpr.of(prefixEntry.value)));
-		branchExprs.push(createBoundaryExpr(tableName, entry));
-		if (branchExprs.length === 1) {
-			const branch = branchExprs[0];
-			assertDefined(branch, "cursor branch contains its boundary expression");
-			return branch;
-		}
-		return AndExpr.of(branchExprs);
-	});
-	if (branches.length === 1) {
-		const branch = branches[0];
-		assertDefined(branch, "cursor expression contains its single branch");
-		return branch;
-	}
-	return OrExpr.of(branches);
-}
-function buildCursorWhere(tableName, orderBy, cursor) {
-	if (!cursor || !orderBy || orderBy.length === 0) return;
-	const entries = [];
-	for (const order of orderBy) {
-		if (order.expr.kind !== "column-ref") continue;
-		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 } });
-		entries.push({
-			column,
-			direction: order.dir,
-			value
-		});
-	}
-	const firstEntry = entries[0];
-	if (entries.length === 1 && firstEntry !== void 0) return createBoundaryExpr(tableName, firstEntry);
-	return buildLexicographicCursorWhere(tableName, entries);
-}
-function createTableRefRemapper(fromTable, toTable) {
-	return {
-		columnRef: (col) => col.table === fromTable ? ColumnRef.of(toTable, col.column) : col,
-		tableSource: (source) => {
-			if (source.alias === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
-			if (!source.alias && source.name === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
-			return source;
-		},
-		eqColJoinOn: (on) => EqColJoinOn.of(on.left.table === fromTable ? ColumnRef.of(toTable, on.left.column) : on.left, on.right.table === fromTable ? ColumnRef.of(toTable, on.right.column) : on.right)
-	};
-}
-function buildStateWhere(contract, tableName, state, options) {
-	const filterTableName = options?.filterTableName;
-	const cursorWhere = buildCursorWhere(filterTableName ?? tableName, state.orderBy, state.cursor);
-	const boundFilters = state.filters.map((filter) => bindWhereExpr(contract, filter, options?.namespaceId));
-	const remappedFilters = filterTableName && filterTableName !== tableName ? boundFilters.map((filter) => filter.rewrite(createTableRefRemapper(filterTableName, tableName))) : boundFilters;
-	const boundCursorWhere = cursorWhere ? bindWhereExpr(contract, cursorWhere, options?.namespaceId) : void 0;
-	const remappedCursorWhere = boundCursorWhere && filterTableName && filterTableName !== tableName ? boundCursorWhere.rewrite(createTableRefRemapper(filterTableName, tableName)) : boundCursorWhere;
-	return combineWhereExprs(remappedCursorWhere ? [...remappedFilters, remappedCursorWhere] : remappedFilters);
-}
 function buildIncludeOrderArtifacts(relationName, rowAlias, childOrderBy) {
 	if (!childOrderBy || childOrderBy.length === 0) return {
 		childOrderBy: void 0,
@@ -1208,35 +1334,6 @@ function buildIncludeOrderArtifacts(relationName, rowAlias, childOrderBy) {
 		})
 	};
 }
-/**
-* Wrap a base SELECT in a `ROW_NUMBER() OVER (PARTITION BY … ORDER BY …) = 1`
-* filter, implementing Prisma-style `.distinct(cols)` semantics: one
-* representative row per `(distinctColumnRefs)` group is kept; the rest
-* are dropped.
-*
-* Picking which row survives in each partition is governed by
-* `rankingOrderBy`. When the caller's `orderBy` doesn't fully order rows
-* within a partition (e.g. user wrote `.distinct('title')` with no
-* `orderBy`, or ties in their ordering), the choice is
-* implementation-defined — matching Prisma's documented nested-distinct
-* behaviour. Callers that want determinism should pass an `orderBy` that
-* is total within each partition.
-*
-* The wrapper forwards every column of `base.projection` through the
-* derived alias, so the wrapper's projection is byte-identical in alias
-* names — making this transparent to any outer query (`json_agg`,
-* correlated subquery, top-level SELECT) that consumes the SELECT.
-*/
-function wrapWithRowNumberDedup(options) {
-	const { base, distinctColumnRefs, rankingOrderBy, rankedAlias } = options;
-	const rnAlias = "__prisma_distinct_rn";
-	const effectiveOrderBy = rankingOrderBy.length > 0 ? rankingOrderBy : distinctColumnRefs.map((expr) => OrderByItem.asc(expr));
-	const inner = base.withProjection([...base.projection, ProjectionItem.of(rnAlias, WindowFuncExpr.rowNumber({
-		partitionBy: distinctColumnRefs,
-		orderBy: effectiveOrderBy
-	}))]);
-	return SelectAst.from(DerivedTableSource.as(rankedAlias, inner)).withProjection(base.projection.map((item) => ProjectionItem.of(item.alias, ColumnRef.of(rankedAlias, item.alias), item.codec))).withWhere(BinaryExpr.eq(ColumnRef.of(rankedAlias, rnAlias), LiteralExpr.of(1)));
-}
 function localColumnsForRowInclude(include) {
 	return include.through?.parentLocalColumns ?? [include.localColumn];
 }
@@ -1304,7 +1401,7 @@ function buildChildPolymorphismJoinsAndProjection(contract, include, childTableA
 		hiddenProjection,
 		baseSelectedFields: selection.baseSelectedFields
 	};
-	const remapper = createTableRefRemapper(polyInfo.baseTable, childTableRef);
+	const remapper = createTableRefRemapper$1(polyInfo.baseTable, childTableRef);
 	return {
 		joins: joins.map((join) => join.rewrite(remapper)),
 		projection,
@@ -1368,12 +1465,13 @@ 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");
 	const parentLocalRefs = resolveParentLocalRefs(parentSource, include, localColumnsForRowInclude(include));
 	const childSource = resolveChildTableSource(include, parentLocalRefs);
 	const childTableAlias = childSource.alias;
 	const childTableRef = childSource.tableRef;
 	const rowsAlias = `${include.relationName}__rows`;
-	const remappedChildOrderBy = childTableAlias && childState.orderBy ? childState.orderBy.map((item) => item.rewrite(createTableRefRemapper(include.relatedTableName, childTableRef))) : childState.orderBy;
+	const remappedChildOrderBy = childTableAlias && childState.orderBy ? childState.orderBy.map((item) => item.rewrite(createTableRefRemapper$1(include.relatedTableName, childTableRef))) : childState.orderBy;
 	const { childOrderBy, hiddenOrderProjection, aggregateOrderBy } = buildIncludeOrderArtifacts(include.relationName, rowsAlias, remappedChildOrderBy);
 	const childWhere = buildStateWhere(contract, childTableRef, childState, {
 		filterTableName: include.relatedTableName,
@@ -1542,6 +1640,7 @@ 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");
 	const childWhere = buildStateWhere(contract, childTableRef, state, {
 		filterTableName: include.relatedTableName,
 		namespaceId: include.relatedNamespaceId
@@ -1558,7 +1657,7 @@ function buildIncludeChildScalarSelect(contract, aggregates, parentSource, inclu
 		const joinExpr = BinaryExpr.eq(ColumnRef.of(childTableRef, include.targetColumn), parentLocalRef);
 		whereExpr = childWhere ? AndExpr.of([joinExpr, childWhere]) : joinExpr;
 	}
-	const remappedOrderBy = childTableAlias && state.orderBy ? state.orderBy.map((item) => item.rewrite(createTableRefRemapper(include.relatedTableName, childTableRef))) : state.orderBy;
+	const remappedOrderBy = childTableAlias && state.orderBy ? state.orderBy.map((item) => item.rewrite(createTableRefRemapper$1(include.relatedTableName, childTableRef))) : state.orderBy;
 	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)) {
@@ -1676,13 +1775,11 @@ 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");
 	const projection = [...buildProjection(contract, namespaceId, tableName, state.selectedFields, tableName), ...options.includeProjection ?? []];
-	const where = options.where ?? buildStateWhere(contract, tableName, state, { namespaceId });
-	const usesRowNumberDistinct = state.distinct !== void 0 && state.distinct.length > 0;
-	const fromSource = usesRowNumberDistinct ? DerivedTableSource.as(tableName, buildTopLevelDistinctRankedInner(contract, namespaceId, tableName, state, where)) : tableSourceForContract(contract, namespaceId, tableName);
+	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);
-	if (usesRowNumberDistinct) ast = ast.withWhere(BinaryExpr.eq(ColumnRef.of(tableName, "__prisma_distinct_rn"), LiteralExpr.of(1)));
-	else if (where) ast = ast.withWhere(where);
+	if (effectiveWhere) ast = ast.withWhere(effectiveWhere);
 	if (state.orderBy) ast = ast.withOrderBy(state.orderBy);
 	if (state.selectedFields === void 0) ast = ast.withSelectAllIntent({ table: tableName });
 	if (state.distinctOn && state.distinctOn.length > 0) ast = ast.withDistinctOn(state.distinctOn.map((column) => ColumnRef.of(tableName, column)));
@@ -1691,44 +1788,8 @@ function buildSelectAst(contract, tableName, state, options) {
 	if (options.joins && options.joins.length > 0) ast = ast.withJoins(options.joins);
 	return ast;
 }
-function buildTopLevelDistinctRankedInner(contract, namespaceId, tableName, state, where) {
-	const distinctColumns = state.distinct;
-	if (distinctColumns === void 0 || distinctColumns.length === 0) throw new InternalError("buildTopLevelDistinctRankedInner called without `state.distinct`");
-	const allColsProjection = resolveTableColumns(contract, namespaceId, tableName).map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column)));
-	const distinctColumnRefs = distinctColumns.map((column) => ColumnRef.of(tableName, column));
-	const rankingOrderBy = state.orderBy && state.orderBy.length > 0 ? state.orderBy : distinctColumnRefs.map((expr) => OrderByItem.asc(expr));
-	let inner = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection([...allColsProjection, ProjectionItem.of("__prisma_distinct_rn", WindowFuncExpr.rowNumber({
-		partitionBy: distinctColumnRefs,
-		orderBy: rankingOrderBy
-	}))]);
-	if (where) inner = inner.withWhere(where);
-	return inner;
-}
-function buildMtiJoins(contract, namespaceId, polyInfo, variantName, selectedColumnsByTable) {
-	const joins = [];
-	const projection = [];
-	const pkColumn = resolvePrimaryKeyColumn(contract, namespaceId, polyInfo.baseTable);
-	const variantsToJoin = variantName ? polyInfo.mtiVariants.filter((v) => v.modelName === variantName) : polyInfo.mtiVariants;
-	for (const variant of variantsToJoin) {
-		const joinType = variantName ? "inner" : "left";
-		const joinOn = EqColJoinOn.of(ColumnRef.of(polyInfo.baseTable, pkColumn), ColumnRef.of(variant.table, pkColumn));
-		const join = joinType === "inner" ? JoinAst.inner(tableSourceForContract(contract, namespaceId, variant.table), joinOn) : JoinAst.left(tableSourceForContract(contract, namespaceId, variant.table), joinOn);
-		joins.push(join);
-		const variantColumns = resolveTableColumns(contract, namespaceId, variant.table);
-		const selectedVariantColumns = selectedColumnsByTable?.get(variant.table);
-		for (const col of variantColumns) {
-			if (col === pkColumn) continue;
-			if (selectedColumnsByTable !== void 0 && selectedVariantColumns?.has(col) !== true) continue;
-			const alias = `${variant.table}__${col}`;
-			projection.push(ProjectionItem.of(alias, ColumnRef.of(variant.table, col), codecRefForStorageColumn(contract.storage, namespaceId, variant.table, col)));
-		}
-	}
-	return {
-		joins,
-		projection
-	};
-}
 function compileSelect(contract, namespaceId, tableName, state, modelName) {
+	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
 	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
 	const selection = polyInfo && modelName ? resolvePolymorphicProjectionSelection(contract, namespaceId, modelName, polyInfo, state) : void 0;
 	const projectionState = selection ? {
@@ -3689,6 +3750,8 @@ var CollectionImpl = class CollectionImpl {
 	* prior `orderBy(...)`; replaces any previous `distinct(...)` /
 	* `distinctOn(...)` selection.
 	*
+	* Requires the `postgres.distinctOn` capability.
+	*
 	* ```typescript
 	* // Latest post per user:
 	* const latestPerUser = await db.orm.Post
@@ -3698,6 +3761,7 @@ var CollectionImpl = class CollectionImpl {
 	* ```
 	*/
 	distinctOn(...fields) {
+		assertDistinctOnCapability(this.contract, "distinctOn");
 		const distinctOnFields = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
 		return this.#clone({
 			distinct: void 0,
@@ -3809,7 +3873,7 @@ var CollectionImpl = class CollectionImpl {
 			alias
 		} });
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "read", "aggregate");
-		const compiled = mergeAnnotations(compileAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.tableName, this.state.filters, aggregateSpec), annotationsMap);
+		const compiled = mergeAnnotations(compileAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.tableName, this.state, aggregateSpec, this.modelName), annotationsMap);
 		const row = (await queryPlanRows(this.ctx.runtime, compiled).toArray())[0] ?? {};
 		const result = {};
 		for (const [alias, selector] of entries) result[alias] = row[alias] ?? this.#emptyAggregateValue(selector);