@prisma/orm-family-sql 8.0.0-rc.4-dev.13 → 8.0.0-rc.4-dev.15

package/dist/orm-client.mjs

@@ -910,6 +910,104 @@ function buildAggregateInput(contract, namespaceId, tableName, state, modelName,
 	if (state.offset !== void 0) inner = inner.withOffset(state.offset);
 	return { source: DerivedTableSource.as(tableName, inner) };
 }
+function emptyState() {
+	return {
+		filters: [],
+		includes: [],
+		orderBy: void 0,
+		cursor: void 0,
+		distinct: void 0,
+		distinctOn: void 0,
+		selectedFields: void 0,
+		limit: void 0,
+		offset: void 0,
+		variantName: void 0,
+		annotations: /* @__PURE__ */ new Map()
+	};
+}
+function emptyGroupPagingState() {
+	return {
+		orderBy: [],
+		limit: void 0,
+		offset: void 0
+	};
+}
+function param(codec, value) {
+	if (codec === void 0) return ParamRef.of(value);
+	return ParamRef.of(value, { codec });
+}
+function paramList(codec, values) {
+	return ListExpression.of(values.map((value) => param(codec, value)));
+}
+function scalarComparisonMethod(op) {
+	return ((left, codec) => (value) => {
+		if (value === null && (op === "eq" || op === "neq")) return op === "eq" ? NullCheckExpr.isNull(left) : NullCheckExpr.isNotNull(left);
+		return new BinaryExpr(op, left, param(codec, value));
+	});
+}
+function listComparisonMethod(op) {
+	return ((left, codec) => (values) => new BinaryExpr(op, left, paramList(codec, values)));
+}
+/**
+* Declares trait requirements and runtime factory for each comparison method.
+*
+* - `traits: []` means "no trait required" — always available
+* - Multi-trait: `traits: ['equality', 'order']` means BOTH traits are required
+*/
+const COMPARISON_METHODS_META = {
+	eq: {
+		traits: ["equality"],
+		create: scalarComparisonMethod("eq")
+	},
+	neq: {
+		traits: ["equality"],
+		create: scalarComparisonMethod("neq")
+	},
+	in: {
+		traits: ["equality"],
+		create: listComparisonMethod("in")
+	},
+	notIn: {
+		traits: ["equality"],
+		create: listComparisonMethod("notIn")
+	},
+	gt: {
+		traits: ["order"],
+		create: scalarComparisonMethod("gt")
+	},
+	lt: {
+		traits: ["order"],
+		create: scalarComparisonMethod("lt")
+	},
+	gte: {
+		traits: ["order"],
+		create: scalarComparisonMethod("gte")
+	},
+	lte: {
+		traits: ["order"],
+		create: scalarComparisonMethod("lte")
+	},
+	like: {
+		traits: ["textual"],
+		create: scalarComparisonMethod("like")
+	},
+	asc: {
+		traits: ["order"],
+		create: (left) => () => OrderByItem.asc(left)
+	},
+	desc: {
+		traits: ["order"],
+		create: (left) => () => OrderByItem.desc(left)
+	},
+	isNull: {
+		traits: [],
+		create: (left) => () => NullCheckExpr.isNull(left)
+	},
+	isNotNull: {
+		traits: [],
+		create: (left) => () => NullCheckExpr.isNotNull(left)
+	}
+};
 function toAggregateProjection(contract, aggregates, namespaceId, tableName, selector) {
 	const { codec, input: inputCodec, lower } = resolveAggregate({
 		aggregates,
@@ -992,8 +1090,8 @@ function validateGroupedHavingExpr(expr) {
 		rawExpr: rejectHavingExpr
 	});
 }
-function aggregateInputColumns(tableName, entries, orderBy) {
-	const columns = /* @__PURE__ */ new Set();
+function aggregateInputColumns(tableName, entries, orderBy, groupByColumns = []) {
+	const columns = new Set(groupByColumns);
 	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))];
@@ -1032,7 +1130,7 @@ function compileAggregate(contract, aggregates, namespaceId, tableName, state, a
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileGroupedAggregate(contract, aggregates, namespaceId, tableName, filters, groupByColumns, aggregateSpec, havingExpr) {
+function compileGroupedAggregate(contract, aggregates, namespaceId, tableName, preGroupState, groupByColumns, aggregateSpec, havingExpr, modelName, postGroup = emptyGroupPagingState()) {
 	if (groupByColumns.length === 0) throw ormError("ORM.GROUP_BY_FIELD_MISSING", "groupBy() requires at least one field", { meta: {
 		namespaceId,
 		tableName
@@ -1043,14 +1141,30 @@ function compileGroupedAggregate(contract, aggregates, namespaceId, tableName, f
 		namespaceId,
 		tableName
 	} });
+	if (preGroupState.distinctOn !== void 0 && preGroupState.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
 	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);
 	})];
-	let ast = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection(projection).withGroupBy(groupByColumns.map((column) => ColumnRef.of(tableName, column)));
-	const where = combineWhereExprs(filters);
-	if (where) ast = ast.withWhere(where);
+	const hasPagination = preGroupState.limit !== void 0 || preGroupState.offset !== void 0;
+	const hasDistinct = preGroupState.distinct !== void 0 && preGroupState.distinct.length > 0 || preGroupState.distinctOn !== void 0 && preGroupState.distinctOn.length > 0;
+	const needsInputSelect = hasPagination || hasDistinct;
+	let ast;
+	if (needsInputSelect) {
+		const { source } = buildAggregateInput(contract, namespaceId, tableName, preGroupState, modelName, aggregateInputColumns(tableName, entries, preGroupState.orderBy, groupByColumns));
+		ast = SelectAst.from(source).withProjection(projection).withGroupBy(groupByColumns.map((column) => ColumnRef.of(tableName, column)));
+	} else {
+		const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
+		const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, namespaceId, polyInfo, preGroupState.variantName, void 0).joins : [];
+		ast = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection(projection).withGroupBy(groupByColumns.map((column) => ColumnRef.of(tableName, column)));
+		if (variantJoins.length > 0) ast = ast.withJoins(variantJoins);
+		const where = buildStateWhere(contract, tableName, preGroupState, { namespaceId });
+		if (where) ast = ast.withWhere(where);
+	}
 	if (havingExpr) ast = ast.withHaving(validateGroupedHavingExpr(havingExpr));
+	if (postGroup.orderBy.length > 0) ast = ast.withOrderBy(postGroup.orderBy);
+	if (postGroup.limit !== void 0) ast = ast.withLimit(postGroup.limit);
+	if (postGroup.offset !== void 0) ast = ast.withOffset(postGroup.offset);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
@@ -1851,97 +1965,6 @@ function compileSelectWithIncludes(contract, aggregates, namespaceId, tableName,
 function queryPlanRows(scope, plan) {
 	return scope.query(plan);
 }
-function emptyState() {
-	return {
-		filters: [],
-		includes: [],
-		orderBy: void 0,
-		cursor: void 0,
-		distinct: void 0,
-		distinctOn: void 0,
-		selectedFields: void 0,
-		limit: void 0,
-		offset: void 0,
-		variantName: void 0,
-		annotations: /* @__PURE__ */ new Map()
-	};
-}
-function param(codec, value) {
-	if (codec === void 0) return ParamRef.of(value);
-	return ParamRef.of(value, { codec });
-}
-function paramList(codec, values) {
-	return ListExpression.of(values.map((value) => param(codec, value)));
-}
-function scalarComparisonMethod(op) {
-	return ((left, codec) => (value) => {
-		if (value === null && (op === "eq" || op === "neq")) return op === "eq" ? NullCheckExpr.isNull(left) : NullCheckExpr.isNotNull(left);
-		return new BinaryExpr(op, left, param(codec, value));
-	});
-}
-function listComparisonMethod(op) {
-	return ((left, codec) => (values) => new BinaryExpr(op, left, paramList(codec, values)));
-}
-/**
-* Declares trait requirements and runtime factory for each comparison method.
-*
-* - `traits: []` means "no trait required" — always available
-* - Multi-trait: `traits: ['equality', 'order']` means BOTH traits are required
-*/
-const COMPARISON_METHODS_META = {
-	eq: {
-		traits: ["equality"],
-		create: scalarComparisonMethod("eq")
-	},
-	neq: {
-		traits: ["equality"],
-		create: scalarComparisonMethod("neq")
-	},
-	in: {
-		traits: ["equality"],
-		create: listComparisonMethod("in")
-	},
-	notIn: {
-		traits: ["equality"],
-		create: listComparisonMethod("notIn")
-	},
-	gt: {
-		traits: ["order"],
-		create: scalarComparisonMethod("gt")
-	},
-	lt: {
-		traits: ["order"],
-		create: scalarComparisonMethod("lt")
-	},
-	gte: {
-		traits: ["order"],
-		create: scalarComparisonMethod("gte")
-	},
-	lte: {
-		traits: ["order"],
-		create: scalarComparisonMethod("lte")
-	},
-	like: {
-		traits: ["textual"],
-		create: scalarComparisonMethod("like")
-	},
-	asc: {
-		traits: ["order"],
-		create: (left) => () => OrderByItem.asc(left)
-	},
-	desc: {
-		traits: ["order"],
-		create: (left) => () => OrderByItem.desc(left)
-	},
-	isNull: {
-		traits: [],
-		create: (left) => () => NullCheckExpr.isNull(left)
-	},
-	isNotNull: {
-		traits: [],
-		create: (left) => () => NullCheckExpr.isNotNull(left)
-	}
-};
 function dispatchCollectionRows(options) {
 	const { context, runtime, state, tableName, modelName, namespaceId } = options;
 	const { contract } = context;
@@ -2389,152 +2412,6 @@ function assertFieldHasEqualityTrait(context, namespaceId, modelName, fieldName)
 		trait: "equality"
 	} });
 }
-var GroupedCollection = class GroupedCollection {
-	ctx;
-	contract;
-	modelName;
-	tableName;
-	namespaceId;
-	baseFilters;
-	groupByFields;
-	groupByColumns;
-	havingFilters;
-	constructor(ctx, modelName, options) {
-		this.ctx = ctx;
-		this.contract = ctx.context.contract;
-		this.modelName = modelName;
-		this.tableName = options.tableName;
-		this.namespaceId = options.namespaceId;
-		this.baseFilters = options.baseFilters;
-		this.groupByFields = options.groupByFields;
-		this.groupByColumns = options.groupByColumns;
-		this.havingFilters = options.havingFilters;
-	}
-	having(predicate) {
-		const havingExpr = predicate(createHavingBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.modelName, this.tableName));
-		return new GroupedCollection(this.ctx, this.modelName, {
-			tableName: this.tableName,
-			namespaceId: this.namespaceId,
-			baseFilters: this.baseFilters,
-			groupByFields: this.groupByFields,
-			groupByColumns: this.groupByColumns,
-			havingFilters: [...this.havingFilters, havingExpr]
-		});
-	}
-	/**
-	* Read terminal: run a grouped aggregate query.
-	*
-	* Accepts an optional `configure` callback that receives a
-	* `MetaBuilder<'read'>` for attaching typed annotations.
-	* Annotations are merged into the compiled plan's `meta.annotations`.
-	*/
-	async aggregate(fn, configure) {
-		const aggregateSpec = fn(createAggregateBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.modelName));
-		const aggregateEntries = Object.entries(aggregateSpec);
-		if (aggregateEntries.length === 0) throw ormError("ORM.AGGREGATE_SELECTOR_MISSING", "groupBy().aggregate() requires at least one aggregation selector", { meta: {
-			method: "groupBy.aggregate",
-			model: this.modelName
-		} });
-		for (const [alias, selector] of aggregateEntries) if (!isAggregateSelector(selector)) throw ormError("ORM.AGGREGATE_SELECTOR_INVALID", `groupBy().aggregate() selector "${alias}" is invalid`, { meta: {
-			method: "groupBy.aggregate",
-			model: this.modelName,
-			alias
-		} });
-		let annotationsMap;
-		if (configure !== void 0) {
-			const meta = createMetaBuilder("read", "groupBy.aggregate");
-			configure(meta);
-			if (meta.annotations.size > 0) annotationsMap = meta.annotations;
-		}
-		const compiled = mergeAnnotations(compileGroupedAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.tableName, this.baseFilters, this.groupByColumns, aggregateSpec, combineWhereExprs(this.havingFilters)), annotationsMap);
-		return (await queryPlanRows(this.ctx.runtime, compiled).toArray()).map((row) => {
-			const mapped = mapStorageRowToModelFields(this.contract, this.namespaceId, this.modelName, row);
-			for (const [alias] of aggregateEntries) mapped[alias] = row[alias];
-			return mapped;
-		});
-	}
-};
-/**
-* The having metric methods, one per operation the registry contributes —
-* the runtime mirror of the contract's emitted aggregate map, which is what
-* types the surface as {@link HavingBuilder}. HAVING compares the value
-* inside the database, so only an operation's plain `AggregateExpr` form is
-* sound here: an operation outside the SQL aggregate alphabet exists only in
-* its descriptor-lowered form — a rendering for the driver boundary — and is
-* refused. The typed surface already excludes it; the runtime refusal covers
-* dynamic invocation.
-*/
-function createHavingBuilder(contract, aggregates, namespaceId, modelName, tableName) {
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
-	const builder = {};
-	for (const operation of aggregateOperationNames(aggregates)) builder[operation] = (field) => {
-		if (!isAggregateFn(operation)) throw ormError("ORM.AGGREGATE_PROJECTION_ONLY", `Aggregate operation '${operation}' is projection-only: it has no plain SQL form for HAVING, ORDER BY, or comparison positions.`, {
-			why: "An operation outside the SQL aggregate alphabet reaches SQL only through its descriptor's lowering hook — a rendering for the driver boundary. HAVING and ORDER BY compare the value inside the database, where that rendering would change SQL semantics.",
-			fix: `Project '${operation}' in a select and filter or order on the projected value, or use an operation from the SQL aggregate alphabet.`,
-			meta: { operation }
-		});
-		return createHavingComparisonMethods(new AggregateExpr(operation, field === void 0 ? void 0 : ColumnRef.of(tableName, fieldToColumn[field] ?? field)));
-	};
-	return blindCast(builder);
-}
-function createHavingComparisonMethods(metric) {
-	const buildBinaryExpr = (op, value) => new BinaryExpr(op, metric, LiteralExpr.of(value));
-	return {
-		eq(value) {
-			return buildBinaryExpr("eq", value);
-		},
-		neq(value) {
-			return buildBinaryExpr("neq", value);
-		},
-		gt(value) {
-			return buildBinaryExpr("gt", value);
-		},
-		lt(value) {
-			return buildBinaryExpr("lt", value);
-		},
-		gte(value) {
-			return buildBinaryExpr("gte", value);
-		},
-		lte(value) {
-			return buildBinaryExpr("lte", value);
-		}
-	};
-}
-function createIncludeScalar(fn, state, column) {
-	return {
-		kind: "includeScalar",
-		fn,
-		state,
-		...column !== void 0 ? { column } : {}
-	};
-}
-function createIncludeCombine(branches) {
-	return {
-		kind: "includeCombine",
-		branches
-	};
-}
-function isIncludeScalar(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const candidate = value;
-	return candidate.kind === "includeScalar" && typeof candidate.fn === "string" && isCollectionState(candidate.state);
-}
-function isIncludeCombine(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const candidate = value;
-	if (candidate.kind !== "includeCombine") return false;
-	if (typeof candidate.branches !== "object" || candidate.branches === null) return false;
-	return true;
-}
-function isCollectionStateCarrier(value) {
-	if (typeof value !== "object" || value === null) return false;
-	return isCollectionState(value.state);
-}
-function isCollectionState(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const candidate = value;
-	return Array.isArray(candidate.filters) && Array.isArray(candidate.includes);
-}
 function hasThrough$1(relation) {
 	return relation.through !== void 0;
 }
@@ -2847,6 +2724,200 @@ function firstTargetColumn(contract, relation) {
 	if (!firstField) return;
 	return resolveFieldToColumn(contract, relation.toNamespace, relation.to, firstField);
 }
+var GroupedCollection = class GroupedCollection {
+	ctx;
+	contract;
+	modelName;
+	tableName;
+	namespaceId;
+	preGroupState;
+	groupByFields;
+	groupByColumns;
+	havingFilters;
+	postGroup;
+	constructor(ctx, modelName, options) {
+		this.ctx = ctx;
+		this.contract = ctx.context.contract;
+		this.modelName = modelName;
+		this.tableName = options.tableName;
+		this.namespaceId = options.namespaceId;
+		this.preGroupState = options.preGroupState;
+		this.groupByFields = options.groupByFields;
+		this.groupByColumns = options.groupByColumns;
+		this.havingFilters = options.havingFilters;
+		this.postGroup = options.postGroup;
+	}
+	#clone(overrides) {
+		return blindCast(new GroupedCollection(this.ctx, this.modelName, {
+			tableName: this.tableName,
+			namespaceId: this.namespaceId,
+			preGroupState: this.preGroupState,
+			groupByFields: this.groupByFields,
+			groupByColumns: this.groupByColumns,
+			havingFilters: this.havingFilters,
+			postGroup: this.postGroup,
+			...overrides
+		}));
+	}
+	having(predicate) {
+		const havingExpr = predicate(createHavingBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.modelName, this.tableName));
+		return this.#clone({ havingFilters: [...this.havingFilters, havingExpr] });
+	}
+	/**
+	* Append an `ORDER BY` clause on the grouped rows themselves — orders by
+	* group key. Ordering by an aggregate alias needs a builder surface over
+	* the aliases and isn't supported here. Unlocks post-group `take(...)` /
+	* `skip(...)`, which page a group order that would otherwise be undefined.
+	*/
+	orderBy(selection) {
+		const selectors = Array.isArray(selection) ? selection : [selection];
+		if (selectors.length === 0) throw ormError("ORM.ARGUMENT_INVALID", `orderBy() for model "${this.modelName}" requires at least one selector`, { meta: {
+			method: "orderBy",
+			model: this.modelName
+		} });
+		const accessor = createModelAccessor(this.ctx.context, this.namespaceId, this.modelName);
+		const nextOrders = selectors.map((selector) => selector(accessor));
+		return this.#clone({ postGroup: {
+			...this.postGroup,
+			orderBy: [...this.postGroup.orderBy, ...nextOrders]
+		} });
+	}
+	/**
+	* Apply `LIMIT n` to the grouped rows. Replaces any previous post-group
+	* limit. Requires a prior `orderBy(...)` — a database may return groups in
+	* any order, so "the first n groups" is undefined without one.
+	*/
+	take(n) {
+		return this.#clone({ postGroup: {
+			...this.postGroup,
+			limit: n
+		} });
+	}
+	/**
+	* Apply `OFFSET n` to the grouped rows. Replaces any previous post-group
+	* offset. Requires a prior `orderBy(...)`, same as `take(...)` — Prisma
+	* pairs `skip`/`take` with `orderBy` on `groupBy` for the same reason.
+	*/
+	skip(n) {
+		return this.#clone({ postGroup: {
+			...this.postGroup,
+			offset: n
+		} });
+	}
+	/**
+	* Read terminal: run a grouped aggregate query.
+	*
+	* Accepts an optional `configure` callback that receives a
+	* `MetaBuilder<'read'>` for attaching typed annotations.
+	* Annotations are merged into the compiled plan's `meta.annotations`.
+	*/
+	async aggregate(fn, configure) {
+		const aggregateSpec = fn(createAggregateBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.modelName));
+		const aggregateEntries = Object.entries(aggregateSpec);
+		if (aggregateEntries.length === 0) throw ormError("ORM.AGGREGATE_SELECTOR_MISSING", "groupBy().aggregate() requires at least one aggregation selector", { meta: {
+			method: "groupBy.aggregate",
+			model: this.modelName
+		} });
+		for (const [alias, selector] of aggregateEntries) if (!isAggregateSelector(selector)) throw ormError("ORM.AGGREGATE_SELECTOR_INVALID", `groupBy().aggregate() selector "${alias}" is invalid`, { meta: {
+			method: "groupBy.aggregate",
+			model: this.modelName,
+			alias
+		} });
+		let annotationsMap;
+		if (configure !== void 0) {
+			const meta = createMetaBuilder("read", "groupBy.aggregate");
+			configure(meta);
+			if (meta.annotations.size > 0) annotationsMap = meta.annotations;
+		}
+		const compiled = mergeAnnotations(compileGroupedAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.tableName, this.preGroupState, this.groupByColumns, aggregateSpec, combineWhereExprs(this.havingFilters), this.modelName, this.postGroup), annotationsMap);
+		return (await queryPlanRows(this.ctx.runtime, compiled).toArray()).map((row) => {
+			const mapped = mapStorageRowToModelFields(this.contract, this.namespaceId, this.modelName, row);
+			for (const [alias] of aggregateEntries) mapped[alias] = row[alias];
+			return mapped;
+		});
+	}
+};
+/**
+* The having metric methods, one per operation the registry contributes —
+* the runtime mirror of the contract's emitted aggregate map, which is what
+* types the surface as {@link HavingBuilder}. HAVING compares the value
+* inside the database, so only an operation's plain `AggregateExpr` form is
+* sound here: an operation outside the SQL aggregate alphabet exists only in
+* its descriptor-lowered form — a rendering for the driver boundary — and is
+* refused. The typed surface already excludes it; the runtime refusal covers
+* dynamic invocation.
+*/
+function createHavingBuilder(contract, aggregates, namespaceId, modelName, tableName) {
+	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const builder = {};
+	for (const operation of aggregateOperationNames(aggregates)) builder[operation] = (field) => {
+		if (!isAggregateFn(operation)) throw ormError("ORM.AGGREGATE_PROJECTION_ONLY", `Aggregate operation '${operation}' is projection-only: it has no plain SQL form for HAVING, ORDER BY, or comparison positions.`, {
+			why: "An operation outside the SQL aggregate alphabet reaches SQL only through its descriptor's lowering hook — a rendering for the driver boundary. HAVING and ORDER BY compare the value inside the database, where that rendering would change SQL semantics.",
+			fix: `Project '${operation}' in a select and filter or order on the projected value, or use an operation from the SQL aggregate alphabet.`,
+			meta: { operation }
+		});
+		return createHavingComparisonMethods(new AggregateExpr(operation, field === void 0 ? void 0 : ColumnRef.of(tableName, fieldToColumn[field] ?? field)));
+	};
+	return blindCast(builder);
+}
+function createHavingComparisonMethods(metric) {
+	const buildBinaryExpr = (op, value) => new BinaryExpr(op, metric, LiteralExpr.of(value));
+	return {
+		eq(value) {
+			return buildBinaryExpr("eq", value);
+		},
+		neq(value) {
+			return buildBinaryExpr("neq", value);
+		},
+		gt(value) {
+			return buildBinaryExpr("gt", value);
+		},
+		lt(value) {
+			return buildBinaryExpr("lt", value);
+		},
+		gte(value) {
+			return buildBinaryExpr("gte", value);
+		},
+		lte(value) {
+			return buildBinaryExpr("lte", value);
+		}
+	};
+}
+function createIncludeScalar(fn, state, column) {
+	return {
+		kind: "includeScalar",
+		fn,
+		state,
+		...column !== void 0 ? { column } : {}
+	};
+}
+function createIncludeCombine(branches) {
+	return {
+		kind: "includeCombine",
+		branches
+	};
+}
+function isIncludeScalar(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return candidate.kind === "includeScalar" && typeof candidate.fn === "string" && isCollectionState(candidate.state);
+}
+function isIncludeCombine(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	if (candidate.kind !== "includeCombine") return false;
+	if (typeof candidate.branches !== "object" || candidate.branches === null) return false;
+	return true;
+}
+function isCollectionStateCarrier(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return isCollectionState(value.state);
+}
+function isCollectionState(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return Array.isArray(candidate.filters) && Array.isArray(candidate.includes);
+}
 function createRelationMutator() {
 	return {
 		create(data) {
@@ -3655,10 +3726,11 @@ var CollectionImpl = class CollectionImpl {
 		return new GroupedCollection(this.ctx, this.modelName, {
 			tableName: this.tableName,
 			namespaceId: this.namespaceId,
-			baseFilters: this.state.filters,
+			preGroupState: this.state,
 			groupByFields: [...fields],
 			groupByColumns,
-			havingFilters: []
+			havingFilters: [],
+			postGroup: emptyGroupPagingState()
 		});
 	}
 	/**