@prisma/orm-family-sql 8.0.0-rc.17-dev.42 → 8.0.0-rc.18

package/dist/orm-client.mjs

@@ -1610,9 +1610,13 @@ function aliasTarget(namespaceId, tableName) {
 		tableName
 	});
 }
-function buildReturningColumns(contract, modelName, target, returningColumns) {
+function projectTableColumns(contract, target, columns) {
 	const { namespaceId, tableName } = target.storage;
-	return (returningColumns && returningColumns.length > 0 ? [...returningColumns] : getColumnsReadOnTable(contract, namespaceId, modelName, tableName)).map((column) => ProjectionItem.of(column, target.column(column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column)));
+	return columns.map((column) => ProjectionItem.of(column, target.column(column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column)));
+}
+function returningProjection(contract, modelName, target, returningColumns) {
+	const { namespaceId, tableName } = target.storage;
+	return projectTableColumns(contract, target, returningColumns && returningColumns.length > 0 ? [...returningColumns] : getColumnsReadOnTable(contract, namespaceId, modelName, tableName));
 }
 function toParamAssignments(contract, namespaceId, tableName, values) {
 	const assignments = {};
@@ -1671,7 +1675,7 @@ function conflictSkipClause(target, conflictSkip) {
 function compileInsertReturning(contract, namespaceId, modelName, tableName, rows, returningColumns, conflictSkip) {
 	const target = aliasTarget(namespaceId, tableName);
 	const { rows: normalizedRows } = normalizeInsertRows(contract, namespaceId, tableName, rows);
-	const ast = InsertAst.into(target.tableSource(contract)).withRows(normalizedRows).withOnConflict(conflictSkipClause(target, conflictSkip)).withReturning(buildReturningColumns(contract, modelName, target, returningColumns));
+	const ast = InsertAst.into(target.tableSource(contract)).withRows(normalizedRows).withOnConflict(conflictSkipClause(target, conflictSkip)).withReturning(returningProjection(contract, modelName, target, returningColumns));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
@@ -1687,7 +1691,7 @@ function stripUndefinedValues(row) {
 	for (const [key, value] of Object.entries(row)) if (value !== void 0) result[key] = value;
 	return result;
 }
-function buildCountMutationWhere(contract, tables, filters, variantValue) {
+function countMutationWhere(contract, tables, filters, variantValue) {
 	const variantTable = variantValue === void 0 ? void 0 : tables.variants.get(variantValue);
 	if (variantTable === void 0) return combineWhereExprs(filters);
 	const { root } = tables;
@@ -1736,42 +1740,31 @@ function compileUpsertReturning(contract, namespaceId, modelName, tableName, cre
 	const target = aliasTarget(namespaceId, tableName);
 	const conflictTarget = InsertOnConflict.on(conflictColumns.map((column) => target.column(column)));
 	const onConflict = updateAssignments ? conflictTarget.doUpdateSet(updateAssignments.assignments) : conflictTarget.doNothing();
-	const ast = InsertAst.into(target.tableSource(contract)).withRows([createAssignments.assignments]).withOnConflict(onConflict).withReturning(buildReturningColumns(contract, modelName, target, returningColumns));
+	const ast = InsertAst.into(target.tableSource(contract)).withRows([createAssignments.assignments]).withOnConflict(onConflict).withReturning(returningProjection(contract, modelName, target, returningColumns));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileUpdateReturning(contract, modelName, tables, setValues, filters, returningColumns) {
+function updateAst(contract, tables, setValues, where) {
 	const { root } = tables;
 	const { namespaceId, tableName } = root.storage;
-	const where = combineWhereExprs(filters);
 	const { assignments } = toParamAssignments(contract, namespaceId, tableName, setValues);
-	let ast = UpdateAst.table(root.tableSource(contract)).withSet(assignments).withReturning(buildReturningColumns(contract, modelName, root, returningColumns));
-	if (where) ast = ast.withWhere(where);
-	const { params } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params);
+	return UpdateAst.table(root.tableSource(contract)).withSet(assignments).withWhere(where);
 }
-function compileUpdateCount(contract, tables, setValues, filters, variantValue) {
-	const { root } = tables;
-	const { namespaceId, tableName } = root.storage;
-	const where = buildCountMutationWhere(contract, tables, filters, variantValue);
-	const { assignments } = toParamAssignments(contract, namespaceId, tableName, setValues);
-	let ast = UpdateAst.table(root.tableSource(contract)).withSet(assignments);
-	if (where) ast = ast.withWhere(where);
+function deleteAst(contract, tables, where) {
+	return DeleteAst.from(tables.root.tableSource(contract)).withWhere(where);
+}
+function compileUpdateReturning(contract, modelName, tables, setValues, filters, returningColumns) {
+	const ast = updateAst(contract, tables, setValues, combineWhereExprs(filters)).withReturning(returningProjection(contract, modelName, tables.root, returningColumns));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileDeleteReturning(contract, modelName, tables, filters, returningColumns) {
-	const { root } = tables;
-	const where = combineWhereExprs(filters);
-	let ast = DeleteAst.from(root.tableSource(contract)).withReturning(buildReturningColumns(contract, modelName, root, returningColumns));
-	if (where) ast = ast.withWhere(where);
+function compileUpdateCount(contract, tables, setValues, filters, variantValue) {
+	const ast = updateAst(contract, tables, setValues, countMutationWhere(contract, tables, filters, variantValue));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileDeleteCount(contract, tables, filters, variantValue) {
-	const where = buildCountMutationWhere(contract, tables, filters, variantValue);
-	let ast = DeleteAst.from(tables.root.tableSource(contract));
-	if (where) ast = ast.withWhere(where);
+	const ast = deleteAst(contract, tables, countMutationWhere(contract, tables, filters, variantValue));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
@@ -2366,21 +2359,24 @@ function buildRootPolymorphism(contract, state, modelName) {
 		projection: [...mtiArtifacts?.projection ?? [], ...buildHiddenDiscriminatorProjection(contract, root, polyInfo, selection.needsHiddenDiscriminator)]
 	};
 }
-function compileSelect(contract, modelName, state) {
+function collectionSelectAst(contract, modelName, state) {
 	assertLockCompatible(state);
 	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
 	const polymorphism = buildRootPolymorphism(contract, state, modelName);
-	const ast = buildSelectAst(contract, modelName, {
+	return buildSelectAst(contract, modelName, {
 		...polymorphism.projectionState,
 		includes: []
 	}, {
 		joins: polymorphism.joins,
 		includeProjection: polymorphism.projection
 	});
+}
+function compileSelect(contract, modelName, state) {
+	const ast = collectionSelectAst(contract, modelName, state);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params, state.annotations);
 }
-function compileSelectWithIncludes(contract, aggregates, modelName, state) {
+function collectionSelectWithIncludesAst(contract, aggregates, modelName, state) {
 	assertLockCompatible(state);
 	const topLevelWhere = buildStateWhere(contract, state);
 	const polymorphism = buildRootPolymorphism(contract, state, modelName);
@@ -2391,7 +2387,7 @@ function compileSelectWithIncludes(contract, aggregates, modelName, state) {
 		const artifact = buildCorrelatedIncludeProjection(contract, aggregates, scope, parent, include);
 		includeProjection.push(artifact.projection);
 	}
-	const ast = buildSelectAst(contract, modelName, {
+	return buildSelectAst(contract, modelName, {
 		...polymorphism.projectionState,
 		includes: []
 	}, {
@@ -2399,6 +2395,9 @@ function compileSelectWithIncludes(contract, aggregates, modelName, state) {
 		includeProjection,
 		...ifDefined("where", topLevelWhere)
 	});
+}
+function compileSelectWithIncludes(contract, aggregates, modelName, state) {
+	const ast = collectionSelectWithIncludesAst(contract, aggregates, modelName, state);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params, state.annotations);
 }
@@ -2412,22 +2411,20 @@ function describeCollectionRows(options) {
 	};
 }
 function describeExecutionRows(options) {
-	const { context, state, modelName, namespaceId } = options;
+	const { context, state, modelName } = options;
 	const { contract } = context;
-	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
-	if (state.includes.length === 0) {
-		const compiled = compileSelect(contract, modelName, state);
-		const mapper = polyInfo ? (rawRow) => blindCast(mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, state.tables, rawRow, state.variantValue)) : (rawRow) => blindCast(mapStorageRowToModelFields(contract, namespaceId, modelName, rawRow));
-		return {
-			plan: compiled,
-			consume: (rows) => mapResultRows(rows, mapper)
-		};
-	}
 	return {
-		plan: compileSelectWithIncludes(contract, context.aggregateDescriptors, modelName, state),
-		consume: (rows) => consumeIncludeRows(context, state, namespaceId, modelName, rows)
+		plan: state.includes.length === 0 ? compileSelect(contract, modelName, state) : compileSelectWithIncludes(contract, context.aggregateDescriptors, modelName, state),
+		consume: (rows) => consumeCollectionRows(options, rows)
 	};
 }
+function consumeCollectionRows(options, rows) {
+	const { context, state, modelName, namespaceId } = options;
+	const { contract } = context;
+	if (state.includes.length > 0) return consumeIncludeRows(context, state, namespaceId, modelName, rows);
+	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
+	return mapResultRows(rows, polyInfo ? (rawRow) => blindCast(mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, state.tables, rawRow, state.variantValue)) : (rawRow) => blindCast(mapStorageRowToModelFields(contract, namespaceId, modelName, rawRow)));
+}
 function deferResolution(resolve) {
 	try {
 		const value = resolve();
@@ -4088,7 +4085,7 @@ async function executeNestedCreateMutation(options) {
 	return withMutationScope(options.runtime, async (scope) => createGraph(scope, options.context, options.namespaceId, options.modelName, options.data));
 }
 async function executeNestedUpdateMutation(options) {
-	return withMutationScope(options.runtime, async (scope) => updateFirstGraph(scope, options.context, options.namespaceId, options.modelName, options.tables, options.filters, options.data));
+	return withMutationScope(options.runtime, async (scope) => updateFirstGraph$1(scope, options.context, options.namespaceId, options.modelName, options.tables, options.filters, options.data));
 }
 function buildRowIdentityFilterFromRow(contract, namespaceId, modelName, row) {
 	const tableName = resolveModelTableName(contract, namespaceId, modelName);
@@ -4165,7 +4162,7 @@ async function createGraph(scope, context, namespaceId, modelName, input) {
 	for (const relationMutation of junctionOwned) await applyJunctionOwnedMutation(scope, context, namespaceId, modelName, parentRow, relationMutation.relation, relationMutation.mutation);
 	return parentRow;
 }
-async function updateFirstGraph(scope, context, namespaceId, modelName, tables, filters, input) {
+async function updateFirstGraph$1(scope, context, namespaceId, modelName, tables, filters, input) {
 	const contract = context.contract;
 	const existingRow = await findFirstByFilters(scope, contract, namespaceId, modelName, tables, filters);
 	if (!existingRow) return null;
@@ -4596,6 +4593,352 @@ function getRelationDefinitions(contract, namespaceId, modelName) {
 function toFieldName(contract, namespaceId, modelName, columnName) {
 	return fieldOfColumn(getModelColumnFields(contract, namespaceId, modelName), modelName, columnName);
 }
+function executeFiltered(ast, filter, run) {
+	if (filter === null) return executeStatement$1(ast, run);
+	if (filter.some((conditions) => conditions.length === 0)) return noRows();
+	const where = combineWhereExprs([...ast.where === void 0 ? [] : [ast.where], ...filter.map(anyOf)]);
+	return executeStatement$1(ast.withWhere(where), run);
+}
+function executeStatement$1(ast, run) {
+	return ast.kind === "select" || ast.returning !== void 0 ? run.query(ast) : run.execute(ast);
+}
+function anyOf(conditions) {
+	const [first, ...others] = conditions;
+	return first !== void 0 && others.length === 0 ? first : OrExpr.of(conditions);
+}
+function withColumns(returned, columns) {
+	const present = new Set(returned.map((item) => item.alias));
+	return [...returned, ...columns.filter((column) => !present.has(column.alias))];
+}
+function noRows() {
+	const generator = async function* () {};
+	return new AsyncIterableResult(generator());
+}
+var Node = class {};
+var Delete = class Delete extends Node {
+	ast;
+	constructor(ast) {
+		super();
+		this.ast = ast;
+		Object.freeze(this);
+	}
+	get returns() {
+		return this.ast.returning ?? [];
+	}
+	execute(inputs, run) {
+		return executeFiltered(this.ast, inputs.filter, run);
+	}
+	withReturning(columns) {
+		return new Delete(this.ast.withReturning(withColumns(this.returns, columns)));
+	}
+};
+var Edge = class {
+	from;
+	columns;
+	constructor(from, columns) {
+		this.from = from;
+		this.columns = Object.freeze([...columns]);
+	}
+};
+var FilterData = class extends Edge {
+	constructor(from, columns) {
+		super(from, columns);
+		Object.freeze(this);
+	}
+	output(sourceRow) {
+		const conditions = this.columns.map(([source, target]) => BinaryExpr.eq(target.expr, ParamRef.of(sourceRow[source.alias], {
+			name: target.alias,
+			...ifDefined("codec", target.codec)
+		})));
+		const [first, ...others] = conditions;
+		return first !== void 0 && others.length === 0 ? first : AndExpr.of(conditions);
+	}
+};
+var Find = class Find extends Node {
+	ast;
+	constructor(ast) {
+		super();
+		this.ast = ast;
+		Object.freeze(this);
+	}
+	get returns() {
+		return this.ast.projection;
+	}
+	execute(inputs, run) {
+		return executeFiltered(this.ast, inputs.filter, run);
+	}
+	withReturning(columns) {
+		return new Find(this.ast.withProjection(withColumns(this.returns, columns)));
+	}
+};
+var Graph = class {
+	#ids = [];
+	#nodes = [];
+	#inputs = [];
+	#readers = [];
+	#result = void 0;
+	get result() {
+		return this.#result;
+	}
+	setResult(node) {
+		this.#result = node;
+	}
+	add(node, inputs) {
+		const id = blindCast(this.#nodes.length);
+		this.#ids.push(id);
+		this.#nodes.push(node);
+		this.#inputs.push(inputs);
+		this.#readers.push([]);
+		for (const edge of Object.values(inputs).flat()) {
+			this.#readers[edge.from]?.push({
+				reader: id,
+				edge
+			});
+			this.#nodes[edge.from] = this.#nodes[edge.from]?.withReturning(edge.columns.map(([source]) => source));
+		}
+		return id;
+	}
+	replace(id, next) {
+		this.#nodes[id] = next;
+	}
+	remove(id) {
+		for (const edge of Object.values(this.inputsOf(id)).flat()) this.#readers[edge.from] = this.readersOf(edge.from).filter((entry) => entry.edge !== edge);
+		for (const { reader, edge } of this.readersOf(id)) this.#inputs[reader] = Object.fromEntries(Object.entries(this.inputsOf(reader)).map(([slot, edges]) => [slot, edges.filter((other) => other !== edge)]));
+		this.#nodes[id] = void 0;
+		this.#inputs[id] = {};
+		this.#readers[id] = [];
+	}
+	nodes() {
+		return this.#ids.flatMap((id) => {
+			const node = this.#nodes[id];
+			return node === void 0 ? [] : [[id, node]];
+		});
+	}
+	inputsOf(id) {
+		return this.#inputs[id] ?? {};
+	}
+	readersOf(id) {
+		return this.#readers[id] ?? [];
+	}
+};
+var Update = class Update extends Node {
+	ast;
+	constructor(ast) {
+		super();
+		this.ast = ast;
+		Object.freeze(this);
+	}
+	get returns() {
+		return this.ast.returning ?? [];
+	}
+	execute(inputs, run) {
+		return executeFiltered(this.ast, inputs.filter, run);
+	}
+	withReturning(columns) {
+		return new Update(this.ast.withReturning(withColumns(this.returns, columns)));
+	}
+};
+function updateAllGraph(collection, set) {
+	const { context, state } = collection;
+	const graph = new Graph();
+	if (Object.keys(set).length === 0) {
+		graph.setResult(graph.add(new Find(selectRowsAst(collection, state)), { filter: [] }));
+		return graph;
+	}
+	requireIdentityColumnsForIncludes(collection);
+	const update = updateAst(context.contract, state.tables, set, whereOf(collection));
+	const updated = graph.add(new Update(update), { filter: [] });
+	graph.setResult(addWithIncludes(graph, collection, updated));
+	return graph;
+}
+function deleteAllGraph(collection) {
+	const { context, state } = collection;
+	const graph = new Graph();
+	const del = new Delete(deleteAst(context.contract, state.tables, whereOf(collection)));
+	if (state.includes.length === 0) {
+		graph.setResult(graph.add(del, { filter: [] }));
+		return graph;
+	}
+	graph.setResult(graph.add(new Find(selectRowsAst(collection, state)), { filter: [] }));
+	graph.add(del, { filter: [] });
+	return graph;
+}
+function updateFirstGraph(collection, set) {
+	const { context, state } = collection;
+	const graph = new Graph();
+	const nothingToSet = Object.keys(set).length === 0;
+	if (!nothingToSet) {
+		requireIdentityColumns(collection);
+		requireIdentityColumnsForIncludes(collection);
+	}
+	const find = addFindOfFirstRow(graph, collection, nothingToSet ? selectRowsAst : selectIdentityAst);
+	if (find === void 0) return graph;
+	if (nothingToSet) {
+		graph.setResult(find);
+		return graph;
+	}
+	const update = updateAst(context.contract, state.tables, set, void 0);
+	const updated = graph.add(new Update(update), { filter: [sameRow(find, collection)] });
+	graph.setResult(addWithIncludes(graph, collection, updated));
+	return graph;
+}
+function deleteFirstGraph(collection) {
+	const { context, state } = collection;
+	const withIncludes = state.includes.length > 0;
+	const graph = new Graph();
+	requireIdentityColumns(collection);
+	const find = addFindOfFirstRow(graph, collection, withIncludes ? selectRowsAst : selectIdentityAst);
+	if (find === void 0) return graph;
+	const del = deleteAst(context.contract, state.tables, void 0);
+	const deleted = graph.add(new Delete(del), { filter: [sameRow(find, collection)] });
+	graph.setResult(withIncludes ? find : deleted);
+	return graph;
+}
+function addWithIncludes(graph, collection, written) {
+	const { state } = collection;
+	if (state.includes.length === 0) return written;
+	const select = selectRowsAst(collection, {
+		...emptyState(state.tables),
+		selectedFields: state.selectedFields,
+		includes: state.includes
+	});
+	return graph.add(new Find(select), { filter: [sameRow(written, collection)] });
+}
+function requireIdentityColumnsForIncludes(collection) {
+	const { modelName, state } = collection;
+	const { tableName } = state.tables.root.storage;
+	if (state.includes.length > 0 && identityColumnsOf(collection).length === 0) throw ormError("ORM.ROW_IDENTITY_MISSING", `Cannot load includes for the mutation result on model "${modelName}": table "${tableName}" has no primary key or unique constraint to key the include read-back on.`, { meta: {
+		model: modelName,
+		table: tableName
+	} });
+}
+function addFindOfFirstRow(graph, collection, select) {
+	const { state } = collection;
+	checkLimitOffset("limit", state.limit);
+	if (state.limit === 0) return;
+	return graph.add(new Find(select(collection, {
+		...state,
+		limit: 1
+	})), { filter: [] });
+}
+function requireIdentityColumns(collection) {
+	const { modelName, state } = collection;
+	const { tableName } = state.tables.root.storage;
+	if (identityColumnsOf(collection).length === 0) throw ormError("ORM.ROW_IDENTITY_MISSING", `update()/delete() on model "${modelName}" requires the table to have a primary key or unique constraint`, { meta: {
+		model: modelName,
+		table: tableName
+	} });
+}
+function selectIdentityAst(collection, state) {
+	return collectionSelectAst(collection.context.contract, collection.modelName, {
+		...state,
+		includes: [],
+		selectedFields: identityColumnsOf(collection)
+	});
+}
+function selectRowsAst(collection, state) {
+	const { context, modelName } = collection;
+	if (state.includes.length === 0) return collectionSelectAst(context.contract, modelName, state);
+	return collectionSelectWithIncludesAst(context.contract, context.aggregateDescriptors, modelName, state);
+}
+function identityColumnsOf(collection) {
+	const { namespaceId, tableName } = collection.state.tables.root.storage;
+	return resolveRowIdentityColumns(collection.context.contract, namespaceId, tableName);
+}
+function sameRow(find, collection) {
+	const { context, state } = collection;
+	return new FilterData(find, projectTableColumns(context.contract, state.tables.root, identityColumnsOf(collection)).map((column) => [column, column]));
+}
+function whereOf(collection) {
+	const { context, state } = collection;
+	return countMutationWhere(context.contract, state.tables, state.filters, state.variantValue);
+}
+function queryGraph(graph, ctx, annotations, callerRows) {
+	returnCallerColumns(graph, callerRows);
+	const [only, ...others] = graph.nodes();
+	if (only !== void 0 && others.length === 0 && only[0] === graph.result) {
+		const [id, node] = only;
+		const run = runOn(ctx, annotations);
+		return shapeRows(graph, id, rowStream(node.execute(inputsOf(graph, id, []), run)), callerRows);
+	}
+	const generator = async function* () {
+		yield* (await runAllNodes(graph, ctx, annotations, callerRows)).rows;
+	};
+	return new AsyncIterableResult(generator());
+}
+async function executeGraph(graph, ctx, annotations) {
+	return { affectedRows: (await runAllNodes(graph, ctx, annotations, void 0)).count };
+}
+function returnCallerColumns(graph, callerRows) {
+	const { context, modelName, state } = callerRows;
+	const columns = returningProjection(context.contract, modelName, state.tables.root, state.selectedFields);
+	for (const [id, node] of graph.nodes()) if (id === graph.result) graph.replace(id, node.withReturning(columns));
+}
+function runAllNodes(graph, ctx, annotations, callerRows) {
+	if (graph.nodes().length > 1) return withMutationScope(ctx.runtime, (scope) => runNodesInOrder(graph, {
+		...ctx,
+		runtime: scope
+	}, annotations, callerRows));
+	return runNodesInOrder(graph, ctx, annotations, callerRows);
+}
+async function runNodesInOrder(graph, ctx, annotations, callerRows) {
+	const run = runOn(ctx, annotations);
+	const collected = [];
+	let rows = [];
+	let count = 0;
+	for (const [id, node] of graph.nodes()) {
+		const executed = await node.execute(inputsOf(graph, id, collected), run);
+		collected[id] = executed;
+		if (id !== graph.result) continue;
+		const storageRows = rowsOf(executed);
+		count = typeof executed === "number" ? executed : storageRows.length;
+		if (callerRows !== void 0) rows = await shapeRows(graph, id, streamOf(storageRows), callerRows).toArray();
+	}
+	return {
+		rows,
+		count
+	};
+}
+function inputsOf(graph, id, collected) {
+	const outputs = {};
+	const slots = graph.inputsOf(id);
+	for (const slot in slots) {
+		const edges = slots[slot] ?? [];
+		outputs[slot] = edges.length === 0 ? null : edges.map((edge) => rowsOf(collected[edge.from]).map((row) => edge.output(row)));
+	}
+	return outputs;
+}
+function runOn(ctx, annotations) {
+	const { contract } = ctx.context;
+	const planOf = (ast) => mergeAnnotations(buildOrmQueryPlan(contract, ast, deriveParamsFromAst(ast).params), annotations);
+	return {
+		query: (ast) => queryPlanRows(ctx.runtime, planOf(ast)),
+		execute: async (ast) => (await ctx.runtime.execute(planOf(ast))).affectedRows
+	};
+}
+function shapeRows(graph, id, storageRows, callerRows) {
+	const { context, namespaceId, modelName, state } = callerRows;
+	const { contract } = context;
+	const { tableName } = state.tables.root.storage;
+	const selected = state.selectedFields ?? getColumnsReadOnTable(contract, namespaceId, modelName, tableName);
+	const hiddenColumns = graph.readersOf(id).flatMap(({ edge }) => edge.columns.map(([source]) => source.alias)).filter((column) => !selected.includes(column));
+	return mapResultRows(consumeCollectionRows(callerRows, storageRows), (row) => {
+		stripHiddenMappedFields(contract, namespaceId, modelName, row, hiddenColumns);
+		return blindCast(row);
+	});
+}
+function rowsOf(executed) {
+	return typeof executed === "object" ? executed : [];
+}
+function rowStream(executed) {
+	return executed instanceof AsyncIterableResult ? executed : streamOf([]);
+}
+function streamOf(rows) {
+	const generator = async function* () {
+		yield* rows;
+	};
+	return new AsyncIterableResult(generator());
+}
 function normalizeWhereArg(arg, options) {
 	if (arg === void 0) return;
 	if (arg === null) throw ormError("ORM.ARGUMENT_INVALID", "WhereArg cannot be null. Pass undefined or a valid WhereExpr/ToWhereExpr payload.", { meta: { argument: "where" } });
@@ -5451,132 +5794,56 @@ var CollectionBase = class CollectionBase {
 			return this.#reloadMutationRowByIdentity(identityCriterion);
 		}
 		assertModelFieldNames(this.contract, this.namespaceId, this.modelName, blindCast(data));
-		return withMutationScope(this.ctx.runtime, async (scope) => {
-			const scoped = this.#withRuntime(scope);
-			const identityWhere = await scoped.#findFirstMatchingRowIdentityWhere();
-			if (!identityWhere) return null;
-			return (await scoped.#clone({ filters: [identityWhere] }).#updateAllWithAnnotations(blindCast(data), annotationsMap))[0] ?? null;
-		});
+		const values = this.#updateValues(blindCast(data));
+		return consumeFirstRow(queryGraph(updateFirstGraph(this.#descriptionOptions(), values), this.ctx, annotationsMap, this.#descriptionOptions()));
 	}
 	updateAll(data, configure) {
 		assertBulkWriteIgnoresNothing(this.state, this.modelName, "updateAll");
 		assertLockCompatible(this.state, "mutation");
-		return this.#updateAllWithAnnotations(data, this.#collectAnnotationsFromMeta(configure, "write", "updateAll"));
-	}
-	#updateAllWithAnnotations(data, annotationsMap) {
+		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "updateAll");
 		assertReturningCapability(this.contract, "updateAll()");
-		const mappedData = mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, data);
-		if (Object.keys(mappedData).length === 0) {
-			const generator = async function* () {};
-			return new AsyncIterableResult(generator());
-		}
-		applyUpdateDefaults(this.ctx, this.namespaceId, this.tableName, mappedData);
-		const { selectedForQuery: selectedForUpdate, hiddenColumns } = this.#augmentMutationSelection();
-		const compiled = mergeAnnotations(compileUpdateReturning(this.contract, this.modelName, this.state.tables, mappedData, this.state.filters, selectedForUpdate), annotationsMap);
-		return dispatchMutationRows({
-			context: this.ctx.context,
-			runtime: this.ctx.runtime,
-			compiled,
-			tables: this.state.tables,
-			modelName: this.modelName,
-			namespaceId: this.namespaceId,
-			variantValue: this.state.variantValue,
-			includes: this.state.includes,
-			selectedFields: this.state.selectedFields,
-			hiddenColumns,
-			mapRow: (mapped) => blindCast(mapped)
-		});
+		return queryGraph(updateAllGraph(this.#descriptionOptions(), this.#updateValues(data)), this.ctx, annotationsMap, this.#descriptionOptions());
 	}
 	async updateAndCount(data, configure) {
 		assertBulkWriteIgnoresNothing(this.state, this.modelName, "updateAndCount");
 		assertLockCompatible(this.state, "mutation");
-		const mappedData = mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, data);
-		if (Object.keys(mappedData).length === 0) return 0;
-		applyUpdateDefaults(this.ctx, this.namespaceId, this.tableName, mappedData);
+		const values = this.#updateValues(data);
+		const graph = Object.keys(values).length === 0 ? new Graph() : updateAllGraph(this.#descriptionWithoutIncludes(), values);
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "updateAndCount");
-		const compiled = mergeAnnotations(compileUpdateCount(this.contract, this.state.tables, mappedData, this.state.filters, this.state.variantValue), annotationsMap);
-		return (await this.ctx.runtime.execute(compiled)).affectedRows;
+		return (await executeGraph(graph, this.ctx, annotationsMap)).affectedRows;
 	}
 	async delete(configure) {
 		assertLockCompatible(this.state, "mutation");
 		assertReturningCapability(this.contract, "delete()");
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "delete");
-		return withMutationScope(this.ctx.runtime, async (scope) => {
-			const scoped = this.#withRuntime(scope);
-			const identityWhere = await scoped.#findFirstMatchingRowIdentityWhere();
-			if (!identityWhere) return null;
-			return (await scoped.#clone({
-				filters: [identityWhere],
-				limit: void 0,
-				offset: void 0
-			}).#executeDeleteReturning(annotationsMap).toArray())[0] ?? null;
-		});
+		return consumeFirstRow(queryGraph(deleteFirstGraph(this.#descriptionOptions()), this.ctx, annotationsMap, this.#descriptionOptions()));
 	}
 	deleteAll(configure) {
 		assertBulkWriteIgnoresNothing(this.state, this.modelName, "deleteAll");
 		assertLockCompatible(this.state, "mutation");
-		return this.#deleteAllWithAnnotations(this.#collectAnnotationsFromMeta(configure, "write", "deleteAll"));
-	}
-	#deleteAllWithAnnotations(annotationsMap) {
+		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "deleteAll");
 		assertReturningCapability(this.contract, "deleteAll()");
-		return this.#executeDeleteReturning(annotationsMap);
-	}
-	#executeDeleteReturning(annotationsMap) {
-		if (this.state.includes.length > 0) return this.#executeDeleteReturningWithIncludes(annotationsMap);
-		const { selectedForQuery: selectedForDelete, hiddenColumns } = this.#augmentMutationSelection();
-		const compiled = mergeAnnotations(compileDeleteReturning(this.contract, this.modelName, this.state.tables, this.state.filters, selectedForDelete), annotationsMap);
-		return dispatchMutationRows({
-			context: this.ctx.context,
-			runtime: this.ctx.runtime,
-			compiled,
-			tables: this.state.tables,
-			modelName: this.modelName,
-			namespaceId: this.namespaceId,
-			variantValue: this.state.variantValue,
-			includes: this.state.includes,
-			selectedFields: this.state.selectedFields,
-			hiddenColumns,
-			mapRow: (mapped) => blindCast(mapped)
-		});
-	}
-	/**
-	* Delete read-back with includes.
-	*
-	* A parent-anchored single-query include read can't observe a row
-	* that has already been deleted, so this reads the rows together with
-	* their relations BEFORE issuing the DELETE. The snapshot is fully
-	* drained into a plain array with `.toArray()` while the rows still
-	* exist; only then does the DELETE run. The yielded `for..of` walks
-	* that in-memory array, not a live cursor, so nothing reads from the
-	* deleted rows after the fact. Snapshot read and delete share one
-	* `withMutationScope` so they are atomic; the returned relations
-	* reflect the row's state at delete time.
-	*/
-	#executeDeleteReturningWithIncludes(annotationsMap) {
-		const collection = this;
-		const generator = async function* () {
-			const snapshot = await withMutationScope(collection.ctx.runtime, async (scope) => {
-				const rows = await dispatchCollectionRows({
-					context: collection.ctx.context,
-					runtime: scope,
-					state: collection.state,
-					modelName: collection.modelName,
-					namespaceId: collection.namespaceId
-				}).toArray();
-				const deletePlan = mergeAnnotations(compileDeleteCount(collection.contract, collection.state.tables, collection.state.filters, collection.state.variantValue), annotationsMap);
-				await scope.execute(deletePlan);
-				return rows;
-			});
-			for (const row of snapshot) yield row;
-		};
-		return new AsyncIterableResult(generator());
+		return queryGraph(deleteAllGraph(this.#descriptionOptions()), this.ctx, annotationsMap, this.#descriptionOptions());
 	}
 	async deleteAndCount(configure) {
 		assertBulkWriteIgnoresNothing(this.state, this.modelName, "deleteAndCount");
 		assertLockCompatible(this.state, "mutation");
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "deleteAndCount");
-		const compiled = mergeAnnotations(compileDeleteCount(this.contract, this.state.tables, this.state.filters, this.state.variantValue), annotationsMap);
-		return (await this.ctx.runtime.execute(compiled)).affectedRows;
+		return (await executeGraph(deleteAllGraph(this.#descriptionWithoutIncludes()), this.ctx, annotationsMap)).affectedRows;
+	}
+	#descriptionWithoutIncludes() {
+		return {
+			...this.#descriptionOptions(),
+			state: {
+				...this.state,
+				includes: []
+			}
+		};
+	}
+	#updateValues(data) {
+		const values = mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, data);
+		if (Object.keys(values).length > 0) applyUpdateDefaults(this.ctx, this.namespaceId, this.tableName, values);
+		return values;
 	}
 	#buildUpsertConflictCriterion(createValues, conflictColumns) {
 		const criterion = {};
@@ -5618,28 +5885,6 @@ var CollectionBase = class CollectionBase {
 			hiddenColumns: []
 		};
 	}
-	async #findFirstMatchingRowIdentityWhere() {
-		const identityColumns = resolveRowIdentityColumns(this.contract, this.namespaceId, this.tableName);
-		if (identityColumns.length === 0) throw ormError("ORM.ROW_IDENTITY_MISSING", `update()/delete() on model "${this.modelName}" requires the table to have a primary key or unique constraint`, { meta: {
-			model: this.modelName,
-			table: this.tableName
-		} });
-		checkLimitOffset("limit", this.state.limit);
-		if (this.state.limit === 0) return null;
-		const firstRow = await this.#clone({
-			selectedFields: [...identityColumns],
-			includes: []
-		}).first();
-		if (!firstRow) return null;
-		const criterion = {};
-		for (const column of identityColumns) {
-			const fieldName = fieldOfColumn(getModelColumnFields(this.contract, this.namespaceId, this.modelName), this.modelName, column);
-			const value = blindCast(firstRow)[fieldName];
-			if (value === void 0) throw new InternalError(`Missing identity field "${fieldName}" while resolving single-row scope for model "${this.modelName}"`);
-			criterion[fieldName] = value;
-		}
-		return shorthandToWhereExpr(this.ctx.context, this.namespaceId, this.modelName, blindCast(criterion), this.state.tables.root) ?? null;
-	}
 	async #reloadMutationRowByIdentity(criterion) {
 		return this.#reloadMutationRowByCriterion(criterion, "row identity");
 	}
@@ -5689,18 +5934,6 @@ var CollectionBase = class CollectionBase {
 			...overrides
 		}));
 	}
-	#withRuntime(runtime) {
-		return blindCast(new (blindCast(this.constructor))({
-			...this.ctx,
-			runtime
-		}, this.modelName, {
-			tableName: this.tableName,
-			namespaceId: this.namespaceId,
-			state: this.state,
-			registry: this.registry,
-			includeRefinementMode: this.includeRefinementMode
-		}));
-	}
 	#cloneWithRow(overrides) {
 		return this.#createSelf({
 			...this.state,