@prisma-next/sql-orm-client 0.10.0-dev.2 → 0.10.0-dev.20

package/dist/index.mjs

@@ -442,6 +442,44 @@ function capabilityFlag(contract, flag) {
 	return contract.capabilities[contract.targetFamily]?.[flag] === true || contract.capabilities[contract.target]?.[flag] === true;
 }
 //#endregion
+//#region src/include-tree-predicates.ts
+/**
+* Recursive predicate: does any include in the tree carry a
+* non-leaf `distinct()` — i.e. `nested.distinct` set on an include
+* whose `nested.includes` is non-empty?
+*
+* Such shapes cannot be lowered into the lateral / correlated
+* single-query strategies: the child SELECT would emit
+* `SELECT DISTINCT <scalars>, json_agg(<nested>) FROM ...`, and
+* Postgres rejects equality on `json`. The dispatch path routes
+* these to multi-query (which applies distinct to scalar-only rows
+* before grandchildren stitch in JS); the planner rejects them at
+* the boundary.
+*
+* `distinctOn` is intentionally not included: Postgres only
+* compares the `ON (...)` expressions for equality, so a hashable
+* key column plus json projections is well-defined.
+*/
+function hasNonLeafIncludeWithDistinct(includes) {
+	return includes.some((include) => include.nested.distinct !== void 0 && include.nested.distinct.length > 0 && include.nested.includes.length > 0 || hasNonLeafIncludeWithDistinct(include.nested.includes));
+}
+/**
+* Recursive predicate: does any include in the tree carry a scalar
+* selector (`count` / `sum` / ...) or a `combine()` descriptor?
+*
+* Such shapes cannot be lowered into the lateral / correlated
+* single-query strategies (TML-2595). The dispatch path uses this
+* to gate the whole tree to multi-query at any depth; the planner
+* (`compileSelectWithIncludeStrategy`) uses the same predicate to
+* fail fast at the boundary rather than build a malformed plan.
+* Without the recursion, a depth-2+ row include containing a
+* depth-3 `count()` would fall through to the planner and hit its
+* explicit `throw` instead of routing to multi-query.
+*/
+function hasScalarOrCombineIncludeDescriptors(includes) {
+	return includes.some((include) => include.scalar !== void 0 || include.combine !== void 0 || hasScalarOrCombineIncludeDescriptors(include.nested.includes));
+}
+//#endregion
 //#region src/query-plan-meta.ts
 function deriveParamsFromAst(ast) {
 	return { params: collectOrderedParamRefs(ast).map((p) => p.kind === "param-ref" ? p.value : void 0) };
@@ -708,7 +746,7 @@ function compileUpsertReturning(contract, tableName, createValues, updateValues,
 	const createAssignments = toParamAssignments(contract, tableName, createValues);
 	const updateAssignments = Object.keys(updateValues).length > 0 ? toParamAssignments(contract, tableName, updateValues) : void 0;
 	const onConflict = updateAssignments ? InsertOnConflict.on(conflictColumns.map((column) => ColumnRef.of(tableName, column))).doUpdateSet(updateAssignments.assignments) : InsertOnConflict.on(conflictColumns.map((column) => ColumnRef.of(tableName, column))).doNothing();
-	const ast = InsertAst.into(TableSource.named(tableName)).withValues(createAssignments.assignments).withOnConflict(onConflict).withReturning(buildReturningColumns(contract, tableName, returningColumns));
+	const ast = InsertAst.into(TableSource.named(tableName)).withRows([createAssignments.assignments]).withOnConflict(onConflict).withReturning(buildReturningColumns(contract, tableName, returningColumns));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
@@ -927,17 +965,55 @@ function buildIncludeOrderArtifacts(relationName, rowAlias, childOrderBy) {
 		})
 	};
 }
-function buildIncludeChildRowsSelect(contract, parentTableName, include) {
+/**
+* Recursively build the join + projection artifacts for the nested
+* includes attached to a child SELECT. Used by
+* `buildIncludeChildRowsSelect` to wire depth-2+ aggregates into the
+* inner SELECT at each level.
+*
+* Under the `lateral` strategy each nested include contributes one
+* LEFT JOIN LATERAL plus one projection item that references the
+* lateral alias. Under the `correlated` strategy each nested include
+* contributes a single projection item whose expression is a
+* correlated subquery; no joins are produced. The two cases are
+* symmetric, which is why both paths share `buildIncludeChildRowsSelect`.
+*/
+function buildNestedIncludeArtifacts(contract, parentTableRef, includes, strategy) {
+	if (includes.length === 0) return {
+		joins: [],
+		projections: []
+	};
+	const joins = [];
+	const projections = [];
+	for (const nested of includes) {
+		if (strategy === "lateral") {
+			const artifact = buildLateralIncludeArtifacts(contract, parentTableRef, nested);
+			joins.push(artifact.join);
+			projections.push(artifact.projection);
+			continue;
+		}
+		const artifact = buildCorrelatedIncludeProjection(contract, parentTableRef, nested);
+		projections.push(artifact.projection);
+	}
+	return {
+		joins,
+		projections
+	};
+}
+function buildIncludeChildRowsSelect(contract, parentTableName, include, strategy) {
 	const childState = include.nested;
 	const childTableAlias = include.relatedTableName === parentTableName ? `${include.relationName}__child` : void 0;
 	const childTableRef = childTableAlias ?? include.relatedTableName;
 	const rowsAlias = `${include.relationName}__rows`;
-	const childProjection = buildProjection(contract, include.relatedTableName, childState.selectedFields, childTableRef);
-	const { childOrderBy, hiddenOrderProjection, aggregateOrderBy } = buildIncludeOrderArtifacts(include.relationName, rowsAlias, childState.orderBy);
+	const scalarProjection = buildProjection(contract, include.relatedTableName, childState.selectedFields, childTableRef);
+	const remappedChildOrderBy = childTableAlias && childState.orderBy ? childState.orderBy.map((item) => item.rewrite(createTableRefRemapper(include.relatedTableName, childTableRef))) : childState.orderBy;
+	const { childOrderBy, hiddenOrderProjection, aggregateOrderBy } = buildIncludeOrderArtifacts(include.relationName, rowsAlias, remappedChildOrderBy);
 	const childWhere = buildStateWhere(contract, childTableRef, childState, { filterTableName: include.relatedTableName });
 	const joinExpr = BinaryExpr.eq(ColumnRef.of(childTableRef, include.targetColumn), ColumnRef.of(parentTableName, include.localColumn));
 	const whereExpr = childWhere ? AndExpr.of([joinExpr, childWhere]) : joinExpr;
-	let childRows = SelectAst.from(TableSource.named(include.relatedTableName, childTableAlias)).withProjection([...childProjection, ...hiddenOrderProjection]).withWhere(whereExpr);
+	const { joins: nestedJoins, projections: nestedProjections } = buildNestedIncludeArtifacts(contract, childTableRef, childState.includes, strategy);
+	const childProjection = [...scalarProjection, ...nestedProjections];
+	let childRows = SelectAst.from(TableSource.named(include.relatedTableName, childTableAlias)).withProjection([...childProjection, ...hiddenOrderProjection]).withJoins(nestedJoins).withWhere(whereExpr);
 	if (childOrderBy) childRows = childRows.withOrderBy(childOrderBy);
 	if (childState.distinctOn && childState.distinctOn.length > 0) childRows = childRows.withDistinctOn(childState.distinctOn.map((column) => ColumnRef.of(childTableRef, column)));
 	else if (childState.distinct && childState.distinct.length > 0) childRows = childRows.withDistinct(true);
@@ -951,7 +1027,7 @@ function buildIncludeChildRowsSelect(contract, parentTableName, include) {
 	};
 }
 function buildLateralIncludeArtifacts(contract, parentTableName, include) {
-	const { childRows, childProjection, rowsAlias, aggregateOrderBy } = buildIncludeChildRowsSelect(contract, parentTableName, include);
+	const { childRows, childProjection, rowsAlias, aggregateOrderBy } = buildIncludeChildRowsSelect(contract, parentTableName, include, "lateral");
 	const lateralAlias = `${include.relationName}_lateral`;
 	const jsonObjectExpr = JsonObjectExpr.fromEntries(childProjection.map((item) => JsonObjectExpr.entry(item.alias, ColumnRef.of(rowsAlias, item.alias))));
 	const aggregateQuery = SelectAst.from(DerivedTableSource.as(rowsAlias, childRows)).withProjection([ProjectionItem.of(include.relationName, JsonArrayAggExpr.of(jsonObjectExpr, "emptyArray", aggregateOrderBy))]);
@@ -961,7 +1037,7 @@ function buildLateralIncludeArtifacts(contract, parentTableName, include) {
 	};
 }
 function buildCorrelatedIncludeProjection(contract, parentTableName, include) {
-	const { childRows, childProjection, rowsAlias, aggregateOrderBy } = buildIncludeChildRowsSelect(contract, parentTableName, include);
+	const { childRows, childProjection, rowsAlias, aggregateOrderBy } = buildIncludeChildRowsSelect(contract, parentTableName, include, "correlated");
 	const jsonObjectExpr = JsonObjectExpr.fromEntries(childProjection.map((item) => JsonObjectExpr.entry(item.alias, ColumnRef.of(rowsAlias, item.alias))));
 	const aggregateQuery = SelectAst.from(DerivedTableSource.as(rowsAlias, childRows)).withProjection([ProjectionItem.of(include.relationName, JsonArrayAggExpr.of(jsonObjectExpr, "emptyArray", aggregateOrderBy))]);
 	return { projection: ProjectionItem.of(include.relationName, SubqueryExpr.of(aggregateQuery)) };
@@ -1026,7 +1102,8 @@ function compileRelationSelect(contract, relatedTableName, targetColumn, parentP
 	});
 }
 function compileSelectWithIncludeStrategy(contract, tableName, state, strategy, modelName) {
-	if (state.includes.some((include) => include.scalar !== void 0 || include.combine !== void 0)) throw new Error("single-query include strategy does not support scalar include selectors or combine()");
+	if (hasScalarOrCombineIncludeDescriptors(state.includes)) throw new Error("single-query include strategy does not support scalar include selectors or combine()");
+	if (hasNonLeafIncludeWithDistinct(state.includes)) throw new Error("single-query include strategy does not support distinct() on a non-leaf include");
 	const includeJoins = [];
 	const includeProjection = [];
 	const topLevelWhere = buildStateWhere(contract, tableName, state);
@@ -1067,7 +1144,7 @@ function dispatchCollectionRows(options) {
 }
 function dispatchWithIncludeStrategy(options) {
 	const strategy = selectIncludeStrategy(options.contract);
-	if (hasNestedIncludes(options.state.includes) || hasComplexIncludeDescriptors(options.state.includes)) return dispatchWithMultiQueryIncludes(options);
+	if (hasScalarOrCombineIncludeDescriptors(options.state.includes) || hasNonLeafIncludeWithDistinct(options.state.includes)) return dispatchWithMultiQueryIncludes(options);
 	switch (strategy) {
 		case "lateral": return dispatchWithSingleQueryIncludes({
 			...options,
@@ -1100,11 +1177,7 @@ function dispatchWithSingleQueryIncludes(options) {
 				};
 			});
 			for (const parent of parentRows) {
-				for (const include of state.includes) {
-					if (include.scalar || include.combine) throw new Error("single-query include strategy does not support scalar include selectors or combine()");
-					const mappedChildren = parseIncludedRows(parent.raw[include.relationName]).map((childRow) => mapStorageRowToModelFields(contract, include.relatedModelName, childRow));
-					parent.mapped[include.relationName] = coerceSingleQueryIncludeResult(mappedChildren, include.cardinality);
-				}
+				for (const include of state.includes) parent.mapped[include.relationName] = decodeIncludePayload(contract, include, parent.raw[include.relationName]);
 				if (hiddenParentColumns.length > 0) stripHiddenMappedFields(contract, modelName, parent.mapped, hiddenParentColumns);
 			}
 			for (const row of parentRows) yield row.mapped;
@@ -1199,7 +1272,9 @@ async function stitchRowInclude(scope, contract, parentRows, include, state, par
 	}
 }
 async function resolveRowsByParent(scope, contract, include, state, parentJoinValues) {
-	const { selectedForQuery: childSelectedForQuery, hiddenColumns: hiddenChildColumns } = augmentSelectionForJoinColumns(state.selectedFields, [include.targetColumn]);
+	const nestedJoinColumns = state.includes.map((nested) => nested.localColumn);
+	const requiredChildColumns = Array.from(new Set([include.targetColumn, ...nestedJoinColumns]));
+	const { selectedForQuery: childSelectedForQuery, hiddenColumns: hiddenChildColumns } = augmentSelectionForJoinColumns(state.selectedFields, requiredChildColumns);
 	const childRows = (await executeQueryPlan(scope, compileRelationSelect(contract, include.relatedTableName, include.targetColumn, parentJoinValues, {
 		...state,
 		selectedFields: childSelectedForQuery
@@ -1246,11 +1321,26 @@ async function resolveScalarByParent(scope, contract, include, selector, parentJ
 function uniqueValues(values) {
 	return [...new Set(values)];
 }
-function hasNestedIncludes(includes) {
-	return includes.some((include) => include.nested.includes.length > 0);
-}
-function hasComplexIncludeDescriptors(includes) {
-	return includes.some((include) => include.scalar !== void 0 || include.combine !== void 0);
+/**
+* Decode a single-query include payload from a parent row's raw cell
+* into the model-shaped value that downstream consumers see. Recurses
+* through `include.nested.includes` so depth-2+ trees — emitted by the
+* recursive lateral / correlated builders — are decoded symmetrically.
+*
+* The shape produced by the SQL side is one JSON column per top-level
+* include; values nested inside that JSON are already-parsed JS values
+* after the outer `JSON.parse`, so `parseIncludedRows` recognises both
+* the string (top-level) and array (nested) forms.
+*/
+function decodeIncludePayload(contract, include, raw) {
+	return coerceSingleQueryIncludeResult(parseIncludedRows(raw).map((childRow) => {
+		const mapped = mapStorageRowToModelFields(contract, include.relatedModelName, childRow);
+		for (const nestedInclude of include.nested.includes) {
+			if (nestedInclude.scalar || nestedInclude.combine) throw new Error("single-query include strategy does not support nested scalar include selectors or combine()");
+			mapped[nestedInclude.relationName] = decodeIncludePayload(contract, nestedInclude, mapped[nestedInclude.relationName]);
+		}
+		return mapped;
+	}), include.cardinality);
 }
 function assignEmptyIncludeResult(parentRows, include) {
 	if (include.combine) {