@prisma/orm-family-sql 8.0.0-rc.18-dev.3 → 8.0.0-rc.18-dev.5

package/dist/orm-client.mjs

@@ -6,7 +6,7 @@ import { C as lockStrengthCapabilities, S as lockOptionCapabilities, T as missin
 import { a as isExpression, s as toExpr, t as ExpressionImpl } from "./expression-impl-B-XNINxr-vYwKVFeP.mjs";
 import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-CYK0Wzja.mjs";
 import { t as createFunctions } from "./functions-0YWByawj.mjs";
-import { t as createIndexReferences } from "./index-reference-D693Lu-E.mjs";
+import { t as createIndexReferences } from "./index-reference-DR62gjQS.mjs";
 import { o as settlementOf } from "./transaction-state-BfXhs7D7-3k10jZ8I.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
@@ -1252,6 +1252,14 @@ function buildPrimaryKeyJoinOn(left, right, primaryKeyColumns) {
 	if (primaryKeyColumns.length === 1 && firstColumn !== void 0) return EqColJoinOn.of(left.column(firstColumn), right.column(firstColumn));
 	return AndExpr.of(primaryKeyColumns.map((column) => BinaryExpr.eq(left.column(column), right.column(column))));
 }
+function labeledVariantColumn(contract, variantTable, column) {
+	const { namespaceId, tableName } = variantTable.storage;
+	return ProjectionItem.of(variantColumnLabel(variantTable, column), variantTable.column(column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column));
+}
+function variantReturning(contract, variantTable, variantModelName, keyColumns) {
+	const { namespaceId, tableName } = variantTable.storage;
+	return getColumnsReadOnTable(contract, namespaceId, variantModelName, tableName).filter((column) => !keyColumns.includes(column)).map((column) => labeledVariantColumn(contract, variantTable, column));
+}
 function buildMtiJoins(contract, tables, polyInfo, variantValue, selectedColumnsByVariant) {
 	const joins = [];
 	const projection = [];
@@ -1272,7 +1280,7 @@ function buildMtiJoins(contract, tables, polyInfo, variantValue, selectedColumns
 		for (const col of variantColumns) {
 			if (pkColumns.includes(col)) continue;
 			if (selectedColumnsByVariant !== void 0 && selectedVariantColumns?.has(col) !== true) continue;
-			projection.push(ProjectionItem.of(variantColumnLabel(variantTable, col), variantTable.column(col), codecRefForStorageColumn(contract.storage, namespaceId, tableName, col)));
+			projection.push(labeledVariantColumn(contract, variantTable, col));
 		}
 	}
 	return {
@@ -1610,9 +1618,12 @@ function aliasTarget(namespaceId, tableName) {
 		tableName
 	});
 }
-function projectTableColumns(contract, target, columns) {
+function projectTableColumn(contract, target, column) {
 	const { namespaceId, tableName } = target.storage;
-	return columns.map((column) => ProjectionItem.of(column, target.column(column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column)));
+	return ProjectionItem.of(column, target.column(column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column));
+}
+function projectTableColumns(contract, target, columns) {
+	return columns.map((column) => projectTableColumn(contract, target, column));
 }
 function returningProjection(contract, modelName, target, returningColumns) {
 	const { namespaceId, tableName } = target.storage;
@@ -1672,17 +1683,19 @@ function conflictSkipClause(target, conflictSkip) {
 	if (conflictSkip.columns.length === 0) return InsertOnConflict.doNothing();
 	return InsertOnConflict.on(conflictSkip.columns.map((column) => target.column(column))).doNothing();
 }
+function insertAst(contract, target, rows, conflictSkip) {
+	const { namespaceId, tableName } = target.storage;
+	const { rows: normalizedRows } = normalizeInsertRows(contract, namespaceId, tableName, rows);
+	return InsertAst.into(target.tableSource(contract)).withRows(normalizedRows).withOnConflict(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(returningProjection(contract, modelName, target, returningColumns));
+	const ast = insertAst(contract, target, rows, conflictSkip).withReturning(returningProjection(contract, modelName, target, returningColumns));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileInsertCount(contract, namespaceId, tableName, rows, 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));
+	const ast = insertAst(contract, aliasTarget(namespaceId, tableName), rows, conflictSkip);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
@@ -1718,31 +1731,15 @@ function groupRowsByColumnSignature(rows) {
 	if (currentGroup.length > 0) groups.push(currentGroup);
 	return groups;
 }
-function compileInsertReturningSplit(contract, namespaceId, modelName, tableName, rows, returningColumns, conflictSkip) {
-	if (rows.length === 0) throw ormError("ORM.MUTATION_DATA_MISSING", "create() requires at least one row", { meta: {
-		method: "create",
-		namespaceId,
-		tableName
-	} });
-	return groupRowsByColumnSignature(rows).map((group) => compileInsertReturning(contract, namespaceId, modelName, tableName, group, returningColumns, conflictSkip));
-}
-function compileInsertCountSplit(contract, namespaceId, tableName, rows, conflictSkip) {
-	if (rows.length === 0) throw ormError("ORM.MUTATION_DATA_MISSING", "createAndCount() requires at least one row", { meta: {
-		method: "createAndCount",
-		namespaceId,
-		tableName
-	} });
-	return groupRowsByColumnSignature(rows).map((group) => compileInsertCount(contract, namespaceId, tableName, group, conflictSkip));
-}
-function compileUpsertReturning(contract, namespaceId, modelName, tableName, createValues, updateValues, conflictColumns, returningColumns) {
+function upsertAst(contract, target, createValues, conflictColumns, updateSet) {
+	const { namespaceId, tableName } = target.storage;
 	const createAssignments = toParamAssignments(contract, namespaceId, tableName, createValues);
-	const updateAssignments = Object.keys(updateValues).length > 0 ? toParamAssignments(contract, namespaceId, tableName, updateValues) : void 0;
-	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(returningProjection(contract, modelName, target, returningColumns));
-	const { params } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params);
+	return InsertAst.into(target.tableSource(contract)).withRows([createAssignments.assignments]).withOnConflict(updateSet === void 0 ? conflictTarget.doNothing() : conflictTarget.doUpdateSet(updateSet));
+}
+function updateAssignments(contract, target, values) {
+	const { namespaceId, tableName } = target.storage;
+	return toParamAssignments(contract, namespaceId, tableName, values).assignments;
 }
 function updateAst(contract, tables, setValues, where) {
 	const { root } = tables;
@@ -2630,46 +2627,6 @@ function consumeIncludeRows(context, state, namespaceId, modelName, rows) {
 * include query can't observe an already-deleted row, so delete reads
 * its snapshot before issuing the DELETE (see `collection.ts`).
 */
-function reloadMutationRowsByIdentities(options) {
-	const { context, runtime, tables, modelName, namespaceId, identityRows, selectedFields, includes } = options;
-	const { contract } = context;
-	const { tableName } = tables.root.storage;
-	if (identityRows.length === 0) return emptyResult();
-	const identityColumns = resolveRowIdentityColumns(contract, namespaceId, tableName);
-	if (identityColumns.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
-	} });
-	const identityFilter = buildIdentityInFilter(contract, tables.root, identityColumns, identityRows);
-	if (!identityFilter) return emptyResult();
-	return dispatchCollectionRows({
-		context,
-		runtime,
-		state: {
-			...emptyState(tables),
-			filters: [identityFilter],
-			selectedFields,
-			includes
-		},
-		modelName,
-		namespaceId
-	});
-}
-function emptyResult() {
-	return new AsyncIterableResult((async function* () {})());
-}
-function buildIdentityInFilter(contract, table, identityColumns, identityRows) {
-	const { storage } = table;
-	const [singleColumn, ...rest] = identityColumns;
-	if (singleColumn !== void 0 && rest.length === 0) {
-		const values = identityRows.map((row) => row[singleColumn]).filter((value) => value !== void 0);
-		if (values.length === 0) return;
-		return BinaryExpr.in(table.column(singleColumn), ListExpression.of(values.map((value) => paramRefForStorageColumn(contract, storage, singleColumn, value))));
-	}
-	if (identityRows.length === 0) return;
-	const tuples = identityRows.map((row) => AndExpr.of(identityColumns.map((column) => BinaryExpr.eq(table.column(column), paramRefForStorageColumn(contract, storage, column, row[column])))));
-	return OrExpr.of(tuples);
-}
 /**
 * Decode a single-query include payload from a parent row's raw cell
 * into the model-shaped value that downstream consumers see. Recurses
@@ -2928,90 +2885,112 @@ function parseIncludePayload(value) {
 		return [];
 	}
 }
-function createMutationRowMapper(contract, namespaceId, modelName, tables, variantValue) {
-	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
-	return polyInfo ? (row) => mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, tables, row, variantValue) : (row) => mapStorageRowToModelFields(contract, namespaceId, modelName, row);
+const tablesByContext = /* @__PURE__ */ new WeakMap();
+const NO_METHODS = Object.freeze({});
+function modelKey(namespaceId, modelName) {
+	return JSON.stringify([namespaceId, modelName]);
 }
-function dispatchMutationRows(options) {
-	const { context, runtime, compiled, tables, modelName, namespaceId, variantValue, includes, selectedFields, hiddenColumns, mapRow } = options;
-	const { contract } = context;
-	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantValue);
-	if (includes.length === 0) return mapResultRows(queryPlanRows(runtime, compiled), (rawRow) => {
-		const mapped = mapStorageRow(rawRow);
-		if (hiddenColumns.length > 0) stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns);
-		return mapRow(mapped);
-	});
-	const generator = async function* () {
-		const identityRows = await queryPlanRows(runtime, compiled).toArray();
-		yield* reloadMutationRowsByIdentities({
-			context,
-			runtime,
-			tables,
-			modelName,
-			namespaceId,
-			identityRows,
-			selectedFields,
-			includes
+function assertUniqueIds(contributions) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const { id } of contributions) {
+		if (seen.has(id)) throw ormError("ORM.ARGUMENT_INVALID", `Two collection method contributions have the id "${id}".`, {
+			why: "A contribution is registered under its id in CollectionMethodRegistry, so an id names one contribution.",
+			fix: "List each extension once, or give one of the two contributions another id.",
+			meta: { id }
 		});
-	};
-	return new AsyncIterableResult(generator());
+		seen.add(id);
+	}
 }
-function dispatchSplitMutationRows(options) {
-	const { context, runtime, plans, tables, modelName, namespaceId, variantValue, includes, selectedFields, hiddenColumns, mapRow } = options;
+function modelViews(context) {
 	const { contract } = context;
-	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantValue);
-	const generator = async function* () {
-		if (includes.length > 0) {
-			const identityRows = [];
-			for (const plan of plans) identityRows.push(...await queryPlanRows(runtime, plan).toArray());
-			yield* reloadMutationRowsByIdentities({
-				context,
-				runtime,
-				tables,
-				modelName,
-				namespaceId,
-				identityRows,
-				selectedFields,
-				includes
-			});
-			return;
+	const views = [];
+	for (const [namespaceId, namespace] of Object.entries(contract.domain.namespaces)) for (const [name, model] of Object.entries(namespace.models)) {
+		const tableName = model.storage["table"];
+		const resolved = typeof tableName === "string" ? resolveTableForContract(contract, namespaceId, tableName) : void 0;
+		if (resolved === void 0) throw new InternalError(`Model "${name}" in namespace "${namespaceId}" has no storage table the contract declares.`);
+		views.push([modelKey(namespaceId, name), {
+			target: contract.target,
+			name,
+			fields: model.fields,
+			relations: model.relations,
+			table: resolved.table
+		}]);
+	}
+	return views;
+}
+function methodsOf(contribution, view) {
+	let methods;
+	try {
+		methods = contribution.methodsFor(view);
+	} catch (cause) {
+		throw ormError("ORM.ARGUMENT_INVALID", `Collection method contribution "${contribution.id}" failed for model "${view.name}".`, {
+			why: "The ORM client asks every contribution for every model's methods when it is created.",
+			fix: `Fix or remove the extension that contributes "${contribution.id}"; the cause is the contribution's own error.`,
+			meta: {
+				model: view.name,
+				contribution: contribution.id
+			},
+			cause
+		});
+	}
+	if (typeof methods !== "object" || methods === null) throw ormError("ORM.ARGUMENT_INVALID", `Collection method contribution "${contribution.id}" returned no object of methods for model "${view.name}".`, {
+		why: "A contribution returns an object holding a model's methods by name, empty when it gives the model none.",
+		fix: `Fix or remove the extension that contributes "${contribution.id}".`,
+		meta: {
+			model: view.name,
+			contribution: contribution.id
 		}
-		for (const plan of plans) for await (const rawRow of queryPlanRows(runtime, plan)) {
-			const mapped = mapStorageRow(rawRow);
-			if (hiddenColumns.length > 0) stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns);
-			yield mapRow(mapped);
+	});
+	for (const [name, body] of Object.entries(methods)) if (typeof body !== "function") throw ormError("ORM.ARGUMENT_INVALID", `Collection method "${name}" that contribution "${contribution.id}" gives model "${view.name}" is not a function.`, {
+		why: "A contribution returns each of a model's methods as a function of the collection and the caller's arguments.",
+		fix: `Fix or remove the extension that contributes "${contribution.id}".`,
+		meta: {
+			model: view.name,
+			method: name,
+			contribution: contribution.id
 		}
-	};
-	return new AsyncIterableResult(generator());
+	});
+	return blindCast(methods);
+}
+function mergedTable(view, contributions) {
+	const methods = Object.create(null);
+	const owners = /* @__PURE__ */ new Map();
+	for (const contribution of contributions) for (const [name, body] of Object.entries(methodsOf(contribution, view))) {
+		const owner = owners.get(name);
+		if (owner !== void 0) throw ormError("ORM.ARGUMENT_INVALID", `Collection method "${name}" of model "${view.name}" is contributed by both "${owner}" and "${contribution.id}".`, {
+			why: "A collection offers one method under each name in `using`.",
+			fix: "Remove one of the extensions that contribute these methods.",
+			meta: {
+				model: view.name,
+				method: name,
+				contributions: [owner, contribution.id]
+			}
+		});
+		owners.set(name, contribution.id);
+		methods[name] = body;
+	}
+	return Object.freeze(methods);
 }
-async function executeMutationReturningSingleRow(options) {
-	const { context, runtime, compiled, tables, modelName, namespaceId, variantValue, includes, selectedFields, hiddenColumns, mapRow, operation, onMissingRowMessage } = options;
-	const { contract } = context;
-	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantValue);
-	if (includes.length === 0) {
-		const first = (await queryPlanRows(runtime, compiled).toArray())[0];
-		if (!first) return null;
-		const mapped = mapStorageRow(first);
-		if (hiddenColumns.length > 0) stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns);
-		return mapRow(mapped);
-	}
-	const identityRows = await queryPlanRows(runtime, compiled).toArray();
-	if (identityRows.length === 0) return null;
-	for await (const row of reloadMutationRowsByIdentities({
-		context,
-		runtime,
-		tables,
-		modelName,
-		namespaceId,
-		identityRows,
-		selectedFields,
-		includes
-	})) return row;
-	throw ormError("ORM.MUTATION_ROW_MISSING", onMissingRowMessage, { meta: {
-		operation,
-		model: modelName,
-		tableName: tables.root.storage.tableName
-	} });
+/**
+* Asks each contribution for each model's methods, once per execution context. Throws `ORM.ARGUMENT_INVALID` when two contributions share an id, give one model two methods with the same name, fail, or return a method that is not a function.
+*/
+function collectionMethodTables(context) {
+	const cached = tablesByContext.get(context);
+	if (cached !== void 0) return cached;
+	const contributions = context.collectionMethods ?? [];
+	assertUniqueIds(contributions);
+	const tables = /* @__PURE__ */ new Map();
+	for (const [key, view] of modelViews(context)) tables.set(key, mergedTable(view, contributions));
+	tablesByContext.set(context, tables);
+	return tables;
+}
+/** The contributed methods of a model, by name. */
+function collectionMethodTable(context, namespaceId, modelName) {
+	return collectionMethodTables(context).get(modelKey(namespaceId, modelName)) ?? NO_METHODS;
+}
+/** The run-time value of `collection.using`. */
+function createCollectionMethods(receiver, table) {
+	return Object.freeze(Object.fromEntries(Object.entries(table).map(([name, body]) => [name, (...args) => body(receiver, ...args)])));
 }
 /** The filter expression of a condition: a condition from `fns` becomes its AST. */
 function conditionExpr(condition) {
@@ -3280,6 +3259,7 @@ function defineDeclaredFieldsFragment(declarations, body) {
 	});
 }
 const NO_INDEXES = Object.freeze({});
+const NO_COLLECTION_METHODS = Object.freeze({});
 const collectionsBehindViews = /* @__PURE__ */ new WeakMap();
 const BODY_CHAIN_METHODS = {
 	where: true,
@@ -3288,10 +3268,11 @@ const BODY_CHAIN_METHODS = {
 	offset: true
 };
 /**
-* The collection as the body of a fragment for any model sees it: a `where` or `orderBy` callback receives `fns` and an `indexes` with no members, as the body does not know its model.
+* The collection as the body of a fragment for any model sees it: a `where` or `orderBy` callback receives `fns` and an `indexes` with no members, and `using` has no members, as the body does not know its model.
 */
 function withoutIndexes(collection) {
 	const view = new Proxy(collection, { get(target, prop) {
+		if (prop === "using") return NO_COLLECTION_METHODS;
 		const member = Reflect.get(target, prop, target);
 		if (typeof member !== "function") return member;
 		if (!Object.hasOwn(BODY_CHAIN_METHODS, prop)) return member.bind(target);
@@ -4593,15 +4574,37 @@ function getRelationDefinitions(contract, namespaceId, modelName) {
 function toFieldName(contract, namespaceId, modelName, columnName) {
 	return fieldOfColumn(getModelColumnFields(contract, namespaceId, modelName), modelName, columnName);
 }
+var Node = class {};
+function executeStatement$1(ast, run) {
+	return ast.kind === "select" || ast.returning !== void 0 ? run.query(ast) : run.execute(ast);
+}
+function rowsResult(rows) {
+	const generator = async function* () {
+		yield* rows;
+	};
+	return new AsyncIterableResult(generator());
+}
+var CrossJoin = class extends Node {
+	constructor() {
+		super();
+		Object.freeze(this);
+	}
+	execute(inputs, _run) {
+		const [left] = inputs.left;
+		const [right] = inputs.right;
+		if (left === void 0 || right === void 0) return rowsResult([]);
+		return rowsResult([{
+			...left,
+			...right
+		}]);
+	}
+};
 function executeFiltered(ast, filter, run) {
 	if (filter === null) return executeStatement$1(ast, run);
-	if (filter.some((conditions) => conditions.length === 0)) return noRows();
+	if (filter.some((conditions) => conditions.length === 0)) return rowsResult([]);
 	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);
@@ -4610,12 +4613,8 @@ 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 {
+var StatementNode = class extends Node {};
+var Delete = class Delete extends StatementNode {
 	ast;
 	constructor(ast) {
 		super();
@@ -4654,7 +4653,7 @@ var FilterData = class extends Edge {
 		return first !== void 0 && others.length === 0 ? first : AndExpr.of(conditions);
 	}
 };
-var Find = class Find extends Node {
+var Find = class Find extends StatementNode {
 	ast;
 	constructor(ast) {
 		super();
@@ -4694,7 +4693,8 @@ var Graph = class {
 				reader: id,
 				edge
 			});
-			this.#nodes[edge.from] = this.#nodes[edge.from]?.withReturning(edge.columns.map(([source]) => source));
+			const source = this.#nodes[edge.from];
+			if (source instanceof StatementNode) this.#nodes[edge.from] = source.withReturning(edge.columns.map(([column]) => column));
 		}
 		return id;
 	}
@@ -4703,7 +4703,7 @@ var Graph = class {
 	}
 	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)]));
+		for (const { reader, edge } of this.readersOf(id)) this.#inputs[reader] = Object.fromEntries(Object.entries(this.inputsOf(reader)).map(([name, slot]) => [name, Array.isArray(slot) ? slot.filter((other) => other !== edge) : slot]));
 		this.#nodes[id] = void 0;
 		this.#inputs[id] = {};
 		this.#readers[id] = [];
@@ -4721,7 +4721,88 @@ var Graph = class {
 		return this.#readers[id] ?? [];
 	}
 };
-var Update = class Update extends Node {
+var Insert = class Insert extends StatementNode {
+	ast;
+	constructor(ast) {
+		super();
+		this.ast = ast;
+		Object.freeze(this);
+	}
+	get returns() {
+		return this.ast.returning ?? [];
+	}
+	execute(inputs, run) {
+		if (inputs.payload === null) return executeStatement$1(this.ast, run);
+		if (inputs.payload.some((records) => records.length === 0)) return rowsResult([]);
+		const payload = Object.assign({}, ...inputs.payload.map(([record]) => record));
+		const rows = this.ast.rows.map((row) => ({
+			...row,
+			...payload
+		}));
+		return executeStatement$1(this.ast.withRows(rows), run);
+	}
+	withReturning(columns) {
+		return new Insert(this.ast.withReturning(withColumns(this.returns, columns)));
+	}
+};
+var InsertChunked = class InsertChunked extends StatementNode {
+	asts;
+	constructor(asts) {
+		super();
+		this.asts = Object.freeze([...asts]);
+		Object.freeze(this);
+	}
+	get returns() {
+		return this.asts[0]?.returning ?? [];
+	}
+	execute(_inputs, run) {
+		if (this.returns.length === 0) return this.#sumOfCounts(run);
+		const asts = this.asts;
+		const generator = async function* () {
+			for (const ast of asts) yield* run.query(ast);
+		};
+		return new AsyncIterableResult(generator());
+	}
+	withReturning(columns) {
+		return new InsertChunked(this.asts.map((ast) => ast.withReturning(withColumns(ast.returning ?? [], columns))));
+	}
+	async #sumOfCounts(run) {
+		let count = 0;
+		for (const ast of this.asts) count += await run.execute(ast);
+		return count;
+	}
+};
+var PayloadData = class extends Edge {
+	constructor(from, columns) {
+		super(from, columns);
+		Object.freeze(this);
+	}
+	output(sourceRow) {
+		return Object.fromEntries(this.columns.map(([source, target]) => [target.alias, ParamRef.of(sourceRow[source.alias], {
+			name: target.alias,
+			...ifDefined("codec", target.codec)
+		})]));
+	}
+};
+var Rows = class extends Edge {
+	constructor(from, columns) {
+		super(from, columns);
+		Object.freeze(this);
+	}
+	output(sourceRow) {
+		return Object.fromEntries(this.columns.map(([source]) => [source.alias, sourceRow[source.alias]]));
+	}
+};
+var UnionAll = class extends Node {
+	constructor() {
+		super();
+		Object.freeze(this);
+	}
+	execute(inputs, _run) {
+		return rowsResult((inputs.rows ?? []).flat());
+	}
+};
+var Update = class Update extends StatementNode {
 	ast;
 	constructor(ast) {
 		super();
@@ -4794,6 +4875,61 @@ function deleteFirstGraph(collection) {
 	graph.setResult(withIncludes ? find : deleted);
 	return graph;
 }
+function createAllGraph(collection, rows, conflict) {
+	const { context, state } = collection;
+	const graph = new Graph();
+	if (rows.length === 0) return graph;
+	requireIdentityColumnsForIncludes(collection);
+	const { contract } = context;
+	const { root } = state.tables;
+	const inserted = supportsDefaultInInsert(contract) ? graph.add(new Insert(insertAst(contract, root, rows, conflict)), { payload: [] }) : graph.add(new InsertChunked(groupRowsByColumnSignature(rows).map((group) => insertAst(contract, root, group, conflict))), {});
+	graph.setResult(addWithIncludes(graph, collection, inserted));
+	return graph;
+}
+function supportsDefaultInInsert(contract) {
+	return contract.capabilities["sql"]?.["defaultInInsert"] === true;
+}
+function createAllVariantGraph(collection, variantTable, variantModelName, rows) {
+	const { context, modelName, state } = collection;
+	const { contract } = context;
+	const { root } = state.tables;
+	const graph = new Graph();
+	const keyColumns = resolvePrimaryKeyColumns(contract, root.storage.namespaceId, root.storage.tableName);
+	const keyPairs = keyColumns.map((column) => [projectTableColumn(contract, root, column), projectTableColumn(contract, variantTable, column)]);
+	const baseColumns = returningProjection(contract, modelName, root, void 0);
+	const variantColumns = variantReturning(contract, variantTable, variantModelName, keyColumns);
+	const joins = rows.map((row) => {
+		const baseInsert = insertAst(contract, root, [row.base], void 0).withReturning(baseColumns);
+		const base = graph.add(new Insert(baseInsert), { payload: [] });
+		const variantInsert = insertAst(contract, variantTable, [row.variant], void 0).withReturning(variantColumns);
+		const variant = graph.add(new Insert(variantInsert), { payload: [new PayloadData(base, keyPairs)] });
+		return graph.add(new CrossJoin(), {
+			left: new Rows(base, sameColumns(baseColumns)),
+			right: new Rows(variant, sameColumns(variantColumns))
+		});
+	});
+	const [only, ...others] = joins;
+	if (only !== void 0 && others.length === 0) graph.setResult(only);
+	else if (only !== void 0) {
+		const joined = sameColumns([...baseColumns, ...variantColumns]);
+		graph.setResult(graph.add(new UnionAll(), { rows: joins.map((join) => new Rows(join, joined)) }));
+	}
+	return graph;
+}
+function sameColumns(columns) {
+	return columns.map((column) => [column, column]);
+}
+function upsertGraph(collection, create, update, conflictColumns) {
+	const { context, state } = collection;
+	const { root } = state.tables;
+	const graph = new Graph();
+	requireIdentityColumnsForIncludes(collection);
+	const updateSet = Object.keys(update).length > 0 ? updateAssignments(context.contract, root, update) : Object.fromEntries(conflictColumns.slice(0, 1).map((column) => [column, ColumnRef.of("excluded", column)]));
+	const upsert = upsertAst(context.contract, root, create, conflictColumns, updateSet);
+	const upserted = graph.add(new Insert(upsert), { payload: [] });
+	graph.setResult(addWithIncludes(graph, collection, upserted));
+	return graph;
+}
 function addWithIncludes(graph, collection, written) {
 	const { state } = collection;
 	if (state.includes.length === 0) return written;
@@ -4872,7 +5008,7 @@ async function executeGraph(graph, ctx, annotations) {
 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));
+	for (const [id, node] of graph.nodes()) if (id === graph.result && node instanceof StatementNode) graph.replace(id, node.withReturning(columns));
 }
 function runAllNodes(graph, ctx, annotations, callerRows) {
 	if (graph.nodes().length > 1) return withMutationScope(ctx.runtime, (scope) => runNodesInOrder(graph, {
@@ -4901,11 +5037,9 @@ async function runNodesInOrder(graph, ctx, annotations, callerRows) {
 }
 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)));
-	}
+	const outputOf = (edge) => rowsOf(collected[edge.from]).map((row) => edge.output(row));
+	for (const [name, slot] of Object.entries(graph.inputsOf(id))) if (!Array.isArray(slot)) outputs[name] = outputOf(slot);
+	else outputs[name] = slot.length === 0 ? null : slot.map(outputOf);
 	return outputs;
 }
 function runOn(ctx, annotations) {
@@ -5099,6 +5233,7 @@ var CollectionBase = class CollectionBase {
 	registry;
 	/** @internal */
 	includeRefinementMode;
+	#using;
 	constructor(ctx, modelName, options) {
 		this.ctx = ctx;
 		this.contract = ctx.context.contract;
@@ -5164,6 +5299,13 @@ var CollectionBase = class CollectionBase {
 			filters: [...this.state.filters, filter]
 		});
 	}
+	/**
+	* The collection methods packages contribute for this model. Each contribution reads the model and names its methods. Each method returns this collection with the method's filter and order added.
+	*/
+	get using() {
+		this.#using ??= createCollectionMethods(blindCast(this), collectionMethodTable(this.ctx.context, this.namespaceId, this.modelName));
+		return blindCast(this.#using);
+	}
 	whereUnique(criterion) {
 		if (this.includeRefinementMode) throw ormError("ORM.INCLUDE_INVALID", "whereUnique() is not available inside include() refinement callbacks", { meta: { action: "whereUnique()" } });
 		if (!hasCompleteUniqueKey(this.contract, this.namespaceId, this.modelName, criterion)) throw ormError("ORM.ARGUMENT_INVALID", `whereUnique() for model "${this.modelName}" needs a value for every field of the primary key or of one unique constraint`, { meta: {
@@ -5523,40 +5665,16 @@ var CollectionBase = class CollectionBase {
 		assertReturningCapability(this.contract, "createAll()");
 		const rows = blindCast(data);
 		const mtiContext = this.#resolveMtiCreateContext();
-		if (mtiContext) return this.#executeMtiCreate(rows, mtiContext);
+		if (mtiContext) {
+			const variantTable = requireVariantTable(this.state.tables, mtiContext.variant.value);
+			return queryGraph(createAllVariantGraph(this.#descriptionWithoutIncludes(), variantTable, mtiContext.variant.modelName, this.#variantCreateRows(rows, mtiContext, variantTable)), this.ctx, annotationsMap, this.#descriptionWithoutIncludes());
+		}
+		return queryGraph(createAllGraph(this.#descriptionOptions(), this.#createValues(rows), conflictSkip), this.ctx, annotationsMap, this.#descriptionOptions());
+	}
+	#createValues(rows) {
 		const mappedRows = this.#mapCreateRows(rows);
 		applyCreateDefaults(this.ctx, this.namespaceId, this.tableName, mappedRows);
-		const { selectedForQuery: selectedForInsert, hiddenColumns } = this.#augmentMutationSelection();
-		if (this.contract.capabilities?.["sql"]?.["defaultInInsert"] !== true) {
-			const plans = compileInsertReturningSplit(this.contract, this.namespaceId, this.modelName, this.tableName, mappedRows, selectedForInsert, conflictSkip).map((plan) => mergeAnnotations(plan, annotationsMap));
-			return dispatchSplitMutationRows({
-				context: this.ctx.context,
-				runtime: this.ctx.runtime,
-				plans,
-				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)
-			});
-		}
-		const compiled = mergeAnnotations(compileInsertReturning(this.contract, this.namespaceId, this.modelName, this.tableName, mappedRows, selectedForInsert, conflictSkip), 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 mappedRows;
 	}
 	#resolveConflictSkip(options, method) {
 		if (options === void 0) return void 0;
@@ -5595,76 +5713,39 @@ var CollectionBase = class CollectionBase {
 		if (!polyInfo) return null;
 		const variant = polyInfo.variants.get(variantValue);
 		if (!isMtiVariantInfo(variant)) return null;
-		const baseFieldToColumn = getModelFieldColumns(this.contract, this.namespaceId, this.modelName);
-		const variantFieldToColumn = getOwnFieldColumns(this.contract, variant.namespaceId, variant.modelName);
-		const pkColumns = resolvePrimaryKeyColumns(this.contract, this.namespaceId, this.tableName);
 		return {
 			polyInfo,
 			variant,
-			baseFieldToColumn,
-			variantFieldToColumn,
-			mergedFieldToColumn: getModelAndVariantFieldColumns(this.contract, this.namespaceId, this.modelName, variant.value),
-			pkColumns
+			baseFieldToColumn: getModelFieldColumns(this.contract, this.namespaceId, this.modelName),
+			variantFieldToColumn: getOwnFieldColumns(this.contract, variant.namespaceId, variant.modelName),
+			mergedFieldToColumn: getModelAndVariantFieldColumns(this.contract, this.namespaceId, this.modelName, variant.value)
 		};
 	}
-	#executeMtiCreate(data, mtiCtx) {
-		const { polyInfo, variant, baseFieldToColumn, variantFieldToColumn, mergedFieldToColumn, pkColumns } = mtiCtx;
-		const contract = this.contract;
-		const collectionCtx = this.ctx;
-		const runtime = collectionCtx.runtime;
-		const tableName = this.tableName;
-		const modelName = this.modelName;
-		const namespaceId = this.namespaceId;
-		const tables = this.state.tables;
-		const variantTable = requireVariantTable(tables, variant.value);
+	#variantCreateRows(data, mtiCtx, variantTable) {
+		const { polyInfo, variant, baseFieldToColumn, variantFieldToColumn, mergedFieldToColumn } = mtiCtx;
 		const baseFieldColumns = new Set(Object.values(baseFieldToColumn));
 		const variantFieldColumns = new Set(Object.values(variantFieldToColumn));
-		const generator = async function* () {
-			const defaultValueCache = /* @__PURE__ */ new Map();
-			for (const row of data) {
-				const allMapped = {};
-				for (const [fieldName, value] of Object.entries(row)) {
-					if (value === void 0) continue;
-					allMapped[columnOfCallerField(contract, variant.namespaceId, mergedFieldToColumn, variant.modelName, fieldName)] = value;
-				}
-				allMapped[polyInfo.discriminatorColumn] = variant.value;
-				const baseRow = {};
-				const variantRow = {};
-				for (const [col, val] of Object.entries(allMapped)) {
-					if (baseFieldColumns.has(col) || col === polyInfo.discriminatorColumn) baseRow[col] = val;
-					if (variantFieldColumns.has(col)) variantRow[col] = val;
-				}
-				yield blindCast(await withMutationScope(runtime, async (scope) => {
-					applyCreateDefaults(collectionCtx, namespaceId, tableName, [baseRow], defaultValueCache);
-					const baseCreated = (await queryPlanRows(scope, compileInsertReturning(contract, namespaceId, modelName, tableName, [baseRow], void 0)).toArray())[0];
-					if (!baseCreated) throw ormError("ORM.MUTATION_ROW_MISSING", `MTI base INSERT for model "${modelName}" did not return a row`, { meta: {
-						operation: "create",
-						model: modelName,
-						table: tableName,
-						phase: "mti-base"
-					} });
-					for (const pkColumn of pkColumns) variantRow[pkColumn] = baseCreated[pkColumn];
-					applyCreateDefaults(collectionCtx, variantTable.storage.namespaceId, variantTable.storage.tableName, [variantRow], defaultValueCache);
-					const variantCreated = (await queryPlanRows(scope, compileInsertReturning(contract, variantTable.storage.namespaceId, variant.modelName, variantTable.storage.tableName, [variantRow], void 0)).toArray())[0];
-					if (!variantCreated) throw ormError("ORM.MUTATION_ROW_MISSING", `MTI variant INSERT for model "${modelName}" into "${variant.table}" did not return a row`, { meta: {
-						operation: "create",
-						model: modelName,
-						table: variant.table,
-						phase: "mti-variant"
-					} });
-					const prefixedVariant = {};
-					for (const [col, val] of Object.entries(variantCreated)) {
-						if (pkColumns.includes(col)) continue;
-						prefixedVariant[variantColumnLabel(variantTable, col)] = val;
-					}
-					return mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, tables, {
-						...baseCreated,
-						...prefixedVariant
-					}, variant.value);
-				}));
+		const defaultValueCache = /* @__PURE__ */ new Map();
+		return data.map((row) => {
+			const allMapped = {};
+			for (const [fieldName, value] of Object.entries(row)) {
+				if (value === void 0) continue;
+				allMapped[columnOfCallerField(this.contract, this.namespaceId, mergedFieldToColumn, variant.modelName, fieldName)] = value;
 			}
-		};
-		return new AsyncIterableResult(generator());
+			allMapped[polyInfo.discriminatorColumn] = variant.value;
+			const baseRow = {};
+			const variantRow = {};
+			for (const [column, value] of Object.entries(allMapped)) {
+				if (baseFieldColumns.has(column) || column === polyInfo.discriminatorColumn) baseRow[column] = value;
+				if (variantFieldColumns.has(column)) variantRow[column] = value;
+			}
+			applyCreateDefaults(this.ctx, this.namespaceId, this.tableName, [baseRow], defaultValueCache);
+			applyCreateDefaults(this.ctx, variantTable.storage.namespaceId, variantTable.storage.tableName, [variantRow], defaultValueCache);
+			return {
+				base: baseRow,
+				variant: variantRow
+			};
+		});
 	}
 	#mapCreateRows(data) {
 		const variantValue = this.state.variantValue;
@@ -5717,19 +5798,7 @@ var CollectionBase = class CollectionBase {
 		this.#assertNotMtiVariant("createAndCount()");
 		const annotationsMap = this.#collectAnnotationsFromMeta(configureCallback, "write", "createAndCount");
 		const rows = blindCast(data);
-		const mappedRows = this.#mapCreateRows(rows);
-		applyCreateDefaults(this.ctx, this.namespaceId, this.tableName, mappedRows);
-		if (this.contract.capabilities?.["sql"]?.["defaultInInsert"] !== true) {
-			const plans = compileInsertCountSplit(this.contract, this.namespaceId, this.tableName, mappedRows, conflictSkip).map((plan) => mergeAnnotations(plan, annotationsMap));
-			let affectedRows = 0;
-			for (const plan of plans) {
-				const stats = await this.ctx.runtime.execute(plan);
-				affectedRows += stats.affectedRows;
-			}
-			return affectedRows;
-		}
-		const compiled = mergeAnnotations(compileInsertCount(this.contract, this.namespaceId, this.tableName, mappedRows, conflictSkip), annotationsMap);
-		return (await this.ctx.runtime.execute(compiled)).affectedRows;
+		return (await executeGraph(createAllGraph(this.#descriptionWithoutIncludes(), this.#createValues(rows), conflictSkip), this.ctx, annotationsMap)).affectedRows;
 	}
 	async upsert(input, configure) {
 		assertLockCompatible(this.state, "mutation");
@@ -5739,36 +5808,14 @@ var CollectionBase = class CollectionBase {
 		const createValues = this.#mapCreateRows([blindCast(input.create)])[0] ?? {};
 		applyCreateDefaults(this.ctx, this.namespaceId, this.tableName, [createValues]);
 		const updateValues = mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, input.update);
-		const hasUpdateValues = Object.keys(updateValues).length > 0;
-		if (hasUpdateValues) applyUpdateDefaults(this.ctx, this.namespaceId, this.tableName, updateValues);
+		if (Object.keys(updateValues).length > 0) applyUpdateDefaults(this.ctx, this.namespaceId, this.tableName, updateValues);
 		const conflictColumns = resolveUpsertConflictColumns(this.contract, this.namespaceId, this.modelName, blindCast(input.conflictOn));
 		if (conflictColumns.length === 0) throw ormError("ORM.ARGUMENT_INVALID", `upsert() for model "${this.modelName}" requires conflict columns`, { meta: {
 			method: "upsert",
 			model: this.modelName
 		} });
-		const { selectedForQuery: selectedForUpsert, hiddenColumns } = this.#augmentMutationSelection();
-		const compiled = mergeAnnotations(compileUpsertReturning(this.contract, this.namespaceId, this.modelName, this.tableName, createValues, updateValues, conflictColumns, selectedForUpsert), annotationsMap);
-		const row = await executeMutationReturningSingleRow({
-			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),
-			operation: "upsert",
-			onMissingRowMessage: `upsert() for model "${this.modelName}" did not return a row`
-		});
+		const row = await consumeFirstRow(queryGraph(upsertGraph(this.#descriptionOptions(), createValues, updateValues, conflictColumns), this.ctx, annotationsMap, this.#descriptionOptions()));
 		if (row) return row;
-		if (!hasUpdateValues) {
-			const conflictCriterion = this.#buildUpsertConflictCriterion(createValues, conflictColumns);
-			const existing = await this.#reloadMutationRowByCriterion(conflictCriterion, "upsert conflict");
-			if (existing) return existing;
-		}
 		throw ormError("ORM.MUTATION_ROW_MISSING", `upsert() for model "${this.modelName}" did not return a row`, { meta: {
 			operation: "upsert",
 			model: this.modelName
@@ -5845,46 +5892,6 @@ var CollectionBase = class CollectionBase {
 		if (Object.keys(values).length > 0) applyUpdateDefaults(this.ctx, this.namespaceId, this.tableName, values);
 		return values;
 	}
-	#buildUpsertConflictCriterion(createValues, conflictColumns) {
-		const criterion = {};
-		for (const columnName of conflictColumns) {
-			if (!(columnName in createValues)) throw ormError("ORM.ARGUMENT_INVALID", `upsert() for model "${this.modelName}" requires create value for conflict column "${columnName}"`, { meta: {
-				method: "upsert",
-				model: this.modelName,
-				column: columnName
-			} });
-			const fieldName = fieldOfColumn(getModelColumnFields(this.contract, this.namespaceId, this.modelName), this.modelName, columnName);
-			criterion[fieldName] = createValues[columnName];
-		}
-		return criterion;
-	}
-	/**
-	* Shape the projection for a mutation's `RETURNING` clause.
-	*
-	* Without includes, the mutation returns the caller's projection
-	* directly. With includes, it returns only the row identity columns
-	* (PK / unique): those rows are reloaded through the read path
-	* (`reloadMutationRowsByIdentities`), which re-selects the caller's
-	* projection together with the relations, so the `RETURNING` clause
-	* need only carry enough to key that read-back.
-	*/
-	#augmentMutationSelection() {
-		if (this.state.includes.length > 0) {
-			const identityColumns = resolveRowIdentityColumns(this.contract, this.namespaceId, this.tableName);
-			if (identityColumns.length === 0) throw ormError("ORM.ROW_IDENTITY_MISSING", `Cannot load includes for the mutation result on model "${this.modelName}": table "${this.tableName}" has no primary key or unique constraint to key the include read-back on.`, { meta: {
-				model: this.modelName,
-				table: this.tableName
-			} });
-			return {
-				selectedForQuery: identityColumns,
-				hiddenColumns: []
-			};
-		}
-		return {
-			selectedForQuery: this.state.selectedFields,
-			hiddenColumns: []
-		};
-	}
 	async #reloadMutationRowByIdentity(criterion) {
 		return this.#reloadMutationRowByCriterion(criterion, "row identity");
 	}
@@ -6048,6 +6055,7 @@ function assertAggregateOperationsNotReserved(registry) {
 function orm(options) {
 	const { runtime, collections, context } = options;
 	assertAggregateOperationsNotReserved(context.aggregateDescriptors);
+	collectionMethodTables(context);
 	const contract = context.contract;
 	const ctx = {
 		runtime,